Formatted src/services/sqlite/helpers

tooling/pipeline/src/services/sqlite/helpers/sqlite_connection_helpers.cc

@@ -6,62 +6,62 @@
 namespace sqlite_export_service_internal {
 
 void SqliteDatabaseDeleter::operator()(sqlite3* handle) const noexcept {
-  if (handle != nullptr) {
-    sqlite3_close(handle);
-  }
+   if (handle != nullptr) {
+      sqlite3_close(handle);
+   }
 }
 
 void SqliteStatementDeleter::operator()(
     sqlite3_stmt* statement) const noexcept {
-  if (statement != nullptr) {
-    sqlite3_finalize(statement);
-  }
+   if (statement != nullptr) {
+      sqlite3_finalize(statement);
+   }
 }
 
 void ThrowSqliteError(sqlite3* db_handle, std::string_view action) {
-  const std::string message =
-      db_handle != nullptr ? sqlite3_errmsg(db_handle) : "unknown SQLite error";
-  throw std::runtime_error(std::format("{}: {}", action, message));
+   const std::string message = db_handle != nullptr ? sqlite3_errmsg(db_handle)
+                                                    : "unknown SQLite error";
+   throw std::runtime_error(std::format("{}: {}", action, message));
 }
 
 SqliteDatabaseHandle OpenDatabase(const std::filesystem::path& path) {
-  sqlite3* raw_handle = nullptr;
-  const int result = sqlite3_open(path.string().c_str(), &raw_handle);
+   sqlite3* raw_handle = nullptr;
+   const int result = sqlite3_open(path.string().c_str(), &raw_handle);
 
-  SqliteDatabaseHandle handle(raw_handle);
-  if (result != SQLITE_OK) {
-    const std::string message = raw_handle != nullptr
-                                    ? sqlite3_errmsg(raw_handle)
-                                    : "unknown SQLite error";
-    throw std::runtime_error("Failed to open SQLite export database: " +
-                             message);
-  }
+   SqliteDatabaseHandle handle(raw_handle);
+   if (result != SQLITE_OK) {
+      const std::string message = raw_handle != nullptr
+                                      ? sqlite3_errmsg(raw_handle)
+                                      : "unknown SQLite error";
+      throw std::runtime_error("Failed to open SQLite export database: " +
+                               message);
+   }
 
-  return handle;
+   return handle;
 }
 
 void ExecSql(const SqliteDatabaseHandle& db_handle, std::string_view sql,
              const char* action) {
-  char* error_message = nullptr;
-  const std::string sql_text(sql);
-  const int result = sqlite3_exec(db_handle.get(), sql_text.c_str(), nullptr,
-                                  nullptr, &error_message);
-  if (result != SQLITE_OK) {
-    const std::string message = error_message != nullptr
-                                    ? error_message
-                                    : sqlite3_errmsg(db_handle.get());
-    sqlite3_free(error_message);
-    throw std::runtime_error(std::format("{}: {}", action, message));
-  }
+   char* error_message = nullptr;
+   const std::string sql_text(sql);
+   const int result = sqlite3_exec(db_handle.get(), sql_text.c_str(), nullptr,
+                                   nullptr, &error_message);
+   if (result != SQLITE_OK) {
+      const std::string message = error_message != nullptr
+                                      ? error_message
+                                      : sqlite3_errmsg(db_handle.get());
+      sqlite3_free(error_message);
+      throw std::runtime_error(std::format("{}: {}", action, message));
+   }
 }
 
 void RollbackTransactionNoThrow(
     const SqliteDatabaseHandle& db_handle) noexcept {
-  if (!db_handle) {
-    return;
-  }
+   if (!db_handle) {
+      return;
+   }
 
-  sqlite3_exec(db_handle.get(), "ROLLBACK;", nullptr, nullptr, nullptr);
+   sqlite3_exec(db_handle.get(), "ROLLBACK;", nullptr, nullptr, nullptr);
 }
 
 }  // namespace sqlite_export_service_internal

tooling/pipeline/src/services/sqlite/helpers/sqlite_statement_helpers.cc

@@ -13,87 +13,87 @@ namespace sqlite_export_service_internal {
 SqliteStatementHandle PrepareStatement(const SqliteDatabaseHandle& db_handle,
                                        std::string_view sql,
                                        const char* action) {
-  sqlite3_stmt* raw_statement = nullptr;
-  const std::string sql_text(sql);
-  const int result = sqlite3_prepare_v2(db_handle.get(), sql_text.c_str(), -1,
-                                        &raw_statement, nullptr);
-  SqliteStatementHandle statement(raw_statement);
-  if (result != SQLITE_OK) {
-    ThrowSqliteError(db_handle.get(), action);
-  }
+   sqlite3_stmt* raw_statement = nullptr;
+   const std::string sql_text(sql);
+   const int result = sqlite3_prepare_v2(db_handle.get(), sql_text.c_str(), -1,
+                                         &raw_statement, nullptr);
+   SqliteStatementHandle statement(raw_statement);
+   if (result != SQLITE_OK) {
+      ThrowSqliteError(db_handle.get(), action);
+   }
 
-  return statement;
+   return statement;
 }
 
 void ResetStatement(SqliteStatementHandle& statement) {
-  if (statement != nullptr) {
-    sqlite3_reset(statement.get());
-    sqlite3_clear_bindings(statement.get());
-  }
+   if (statement != nullptr) {
+      sqlite3_reset(statement.get());
+      sqlite3_clear_bindings(statement.get());
+   }
 }
 
 void Bind(const SqliteStatementHandle& statement,
           const BoundParam<std::string_view>& param) {
-  const auto byte_count = param.value.size();
-  if (byte_count > static_cast<std::size_t>(std::numeric_limits<int>::max())) {
-    ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
-  }
+   const auto byte_count = param.value.size();
+   if (byte_count > static_cast<std::size_t>(std::numeric_limits<int>::max())) {
+      ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
+   }
 
-  auto delete_char_array = [](void* data) noexcept {
-    // NOLINT(cppcoreguidelines-owning-memory)
-    delete[] static_cast<char*>(data);
-  };
+   auto delete_char_array = [](void* data) noexcept {
+      // NOLINT(cppcoreguidelines-owning-memory)
+      delete[] static_cast<char*>(data);
+   };
 
-  // NOLINT(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays)
-  auto buffer = std::make_unique<char[]>(byte_count + 1);
-  std::memcpy(buffer.get(), param.value.data(), byte_count);
-  buffer[byte_count] = '\0';
+   // NOLINT(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays)
+   auto buffer = std::make_unique<char[]>(byte_count + 1);
+   std::memcpy(buffer.get(), param.value.data(), byte_count);
+   buffer[byte_count] = '\0';
 
-  char* raw_buffer = buffer.release();
+   char* raw_buffer = buffer.release();
 
-  if (sqlite3_bind_text(statement.get(), param.index, raw_buffer,
-                        static_cast<int>(byte_count),
-                        delete_char_array) != SQLITE_OK) {
-    delete_char_array(raw_buffer);
-    ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
-  }
+   if (sqlite3_bind_text(statement.get(), param.index, raw_buffer,
+                         static_cast<int>(byte_count),
+                         delete_char_array) != SQLITE_OK) {
+      delete_char_array(raw_buffer);
+      ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
+   }
 }
 
 void Bind(const SqliteStatementHandle& statement,
           const BoundParam<double>& param) {
-  if (sqlite3_bind_double(statement.get(), param.index, param.value) !=
-      SQLITE_OK) {
-    ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
-  }
+   if (sqlite3_bind_double(statement.get(), param.index, param.value) !=
+       SQLITE_OK) {
+      ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
+   }
 }
 
 void Bind(const SqliteStatementHandle& statement,
           const BoundParam<sqlite3_int64>& param) {
-  if (sqlite3_bind_int64(statement.get(), param.index, param.value) !=
-      SQLITE_OK) {
-    ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
-  }
+   if (sqlite3_bind_int64(statement.get(), param.index, param.value) !=
+       SQLITE_OK) {
+      ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
+   }
 }
 
 void StepStatement(const SqliteDatabaseHandle& db_handle,
                    const SqliteStatementHandle& statement,
                    std::string_view action) {
-  if (sqlite3_step(statement.get()) != SQLITE_DONE) {
-    ThrowSqliteError(db_handle.get(), action);
-  }
+   if (sqlite3_step(statement.get()) != SQLITE_DONE) {
+      ThrowSqliteError(db_handle.get(), action);
+   }
 }
 
 sqlite3_int64 LastInsertRowId(const SqliteDatabaseHandle& db_handle) {
-  return sqlite3_last_insert_rowid(db_handle.get());
+   return sqlite3_last_insert_rowid(db_handle.get());
 }
 
 std::string SerializeVector(const std::vector<std::string>& str_vec) {
-  boost::json::array array;
-  array.reserve(str_vec.size());
-  for (const auto& s : str_vec) {
-    array.emplace_back(s);
-  }
-  return boost::json::serialize(array);
+   boost::json::array array;
+   array.reserve(str_vec.size());
+   for (const auto& s : str_vec) {
+      array.emplace_back(s);
+   }
+   return boost::json::serialize(array);
 }
 
 }  // namespace sqlite_export_service_internal