removed namespace interface

source/orm/sql/statement_cache.cpp

@@ -24,24 +24,26 @@ public:
     size_t lock_attempts{0};
   };
 
-  explicit statement_cache_proxy(std::unique_ptr<statement_impl>&& stmt, connection_pool &pool, const size_t connection_id)
+  statement_cache_proxy(utils::message_bus &bus, std::unique_ptr<statement_impl>&& stmt, connection_pool &pool, const size_t connection_id)
   : statement_proxy(std::move(stmt))
   , pool_(pool)
-  , connection_id_(connection_id) {}
+  , connection_id_(connection_id)
+  , bus_(bus) {}
 
-  utils::result<size_t, utils::error> execute(interface::parameter_binder& bindings) override {
+  utils::result<size_t, utils::error> execute(parameter_binder& bindings) override {
     execution_metrics metrics{std::chrono::steady_clock::now()};
 
     auto result = try_with_retry([this, &bindings, &metrics]() -> utils::result<size_t, utils::error> {
       if (!try_lock()) {
         ++metrics.lock_attempts;
+        bus_.publish<statement_lock_failed_event>({sql(), std::chrono::steady_clock::now(), metrics.lock_attempt_start});
         return utils::failure(utils::error{
           error_code::STATEMENT_LOCKED,
           "Failed to execute statement because it is already in use"
         });
       }
       metrics.lock_acquired = std::chrono::steady_clock::now();
-      // publish
+      bus_.publish<statement_lock_acquired_event>({sql(), std::chrono::steady_clock::now(), metrics.lock_attempt_start, metrics.lock_acquired});
 
       auto guard = statement_guard(*this);
       if (const auto conn = pool_.acquire(connection_id_); !conn.valid()) {
@@ -55,14 +57,15 @@ public:
       auto execution_result = statement_->execute(bindings);
       metrics.execution_end = std::chrono::steady_clock::now();
 
-      // publish
+      bus_.publish<statement_execution_event>({sql(), std::chrono::steady_clock::now(), metrics.execution_start, metrics.execution_end});
+
       return execution_result;
     });
 
     return result;
   }
 
-  utils::result<std::unique_ptr<query_result_impl>, utils::error> fetch(interface::parameter_binder& bindings) override {
+  utils::result<std::unique_ptr<query_result_impl>, utils::error> fetch(parameter_binder& bindings) override {
     execution_metrics metrics{std::chrono::steady_clock::now()};
 
     auto result = try_with_retry([this, &bindings, &metrics]() -> utils::result<std::unique_ptr<query_result_impl>, utils::error> {
@@ -104,7 +107,7 @@ protected:
 
       if (attempt + 1 < config_.max_attempts) {
         std::this_thread::sleep_for(current_wait);
-        current_wait = std::min(current_wait * 2, config_.max_wait);
+        current_wait = (std::min)(current_wait * 2, config_.max_wait);
       }
     }
 
@@ -132,6 +135,7 @@ private:
   connection_pool &pool_;
   size_t connection_id_{};
   retry_config config_{};
+  utils::message_bus &bus_;
 };
 
 }
@@ -178,7 +182,7 @@ utils::result<statement, utils::error> statement_cache::acquire(const query_cont
   const auto it = cache_map_.insert({
     key,
     {statement{
-      std::make_shared<internal::statement_cache_proxy>(std::move(stmt), pool_, id)},
+      std::make_shared<internal::statement_cache_proxy>(bus_, std::move(stmt), pool_, id)},
       std::chrono::steady_clock::now(),
       usage_list_.begin()}
   }).first;