session progress

source/orm/sql/error_code.cpp

@@ -8,37 +8,37 @@ const char * sql_category_impl::name() const noexcept {
 
 std::string sql_category_impl::message(const int ev) const {
   switch (static_cast<error_code>(ev)) {
-    case error_code::OK:
+    case error_code::Ok:
       return "OK";
-    case error_code::INVALID_QUERY:
+    case error_code::InvalidQuery:
       return "Invalid query";
-    case error_code::UNKNOWN_TABLE:
+    case error_code::UnknownTable:
       return "Unknown table";
-    case error_code::UNKNOWN_COLUMN:
+    case error_code::UnknownColumn:
       return "Unknown column";
-    case error_code::BIND_FAILED:
+    case error_code::BindFailed:
       return "Bind failed";
-    case error_code::EXECUTE_FAILED:
+    case error_code::ExecuteFailed:
       return "Execute failed";
-    case error_code::FETCH_FAILED:
+    case error_code::FetchFailed:
       return "Fetch failed";
-    case error_code::PREPARE_FAILED:
+    case error_code::PrepareFailed:
       return "Prepare failed";
-    case error_code::DESCRIBE_FAILED:
+    case error_code::DescribeFailed:
       return "Describe failed";
-    case error_code::TABLE_EXISTS_FAILED:
+    case error_code::TableExistsFailed:
       return "Table exists failed";
-    case error_code::RETRIEVE_DATA_FAILED:
+    case error_code::RetrieveDataFailed:
       return "Retrieve data failed";
-    case error_code::SEQUENCE_EXISTS_FAILED:
+    case error_code::SequenceExistsFailed:
       return "Sequence exists failed";
-    case error_code::RESET_FAILED:
+    case error_code::ResetFailed:
       return "Reset failed";
-    case error_code::OPEN_ERROR:
+    case error_code::OpenError:
       return "Open failed";
-    case error_code::CLOSE_ERROR:
+    case error_code::CloseError:
       return "Close failed";
-    case error_code::FAILURE:
+    case error_code::Failure:
       return "Failure";
     default:
       return "Unknown error";

source/orm/sql/statement_cache.cpp

@@ -41,7 +41,7 @@ public:
         const auto now = std::chrono::steady_clock::now();
         bus_.publish(statement_lock_failed_event{query, now, now - metrics.lock_attempt_start});
         return utils::failure(utils::error{
-          error_code::STATEMENT_LOCKED,
+          error_code::StatementLocked,
           "Failed to execute statement because it is already in use"
         });
       }
@@ -51,7 +51,7 @@ public:
       auto guard = statement_guard(*this);
       if (const auto conn = pool_.acquire(connection_id_); !conn.valid()) {
         return utils::failure(utils::error{
-          error_code::EXECUTE_FAILED,
+          error_code::ExecuteFailed,
           "Failed to execute statement because couldn't lock connection"
         });
       }
@@ -75,14 +75,14 @@ public:
       if (!try_lock()) {
         ++metrics.lock_attempts;
         return utils::failure(utils::error{
-          error_code::STATEMENT_LOCKED,
+          error_code::StatementLocked,
           "Failed to execute statement because it is already in use"
         });
       }
       auto guard = statement_guard(*this);
       if (const auto conn = pool_.acquire(connection_id_); !conn.valid()) {
         return utils::failure(utils::error{
-          error_code::EXECUTE_FAILED,
+          error_code::ExecuteFailed,
           "Failed to execute statement because couldn't lock connection"
         });
       }
@@ -104,7 +104,7 @@ protected:
 
     for (size_t attempt = 0; attempt < config_.max_attempts; ++attempt) {
       if (auto result = func(); result.is_ok() ||
-                                result.err().ec() != error_code::STATEMENT_LOCKED) {
+                                result.err().ec() != error_code::StatementLocked) {
         return result;
       }
 
@@ -115,7 +115,7 @@ protected:
     }
 
     return utils::failure(utils::error{
-      error_code::STATEMENT_LOCKED,
+      error_code::StatementLocked,
       "Failed to execute statement because it is already in use"
     });
   }
@@ -167,7 +167,7 @@ utils::result<statement, utils::error> statement_cache::acquire(const query_cont
     const auto conn = pool_.acquire();
     auto result = conn->perform_prepare(ctx);
     if (!result) {
-      return utils::failure(utils::error{error_code::PREPARE_FAILED, std::string("Failed to prepare")});
+      return utils::failure(utils::error{error_code::PrepareFailed, std::string("Failed to prepare")});
     }
     id = conn.id().value();
     stmt = result.release();