src/zm_db.h

Rama master · réplica de lectura del repositorio original.

//
// ZoneMinder Core Interfaces, $Date$, $Revision$
// Copyright (C) 2001-2008 Philip Coombes
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//

#ifndef ZM_DB_H
#define ZM_DB_H

#include <condition_variable>
#include <cstdint>
#include <mutex>
// MYSQLCLIENT_INCLUDE_DIR (CMakeLists.txt) is on the include path: the headers'
// directory is include/mysql for libmysqlclient and include/mariadb for libmariadb.
#include <mysql.h>
#include <mysqld_error.h>
#include <queue>
#include <string>
#include <thread>
#include <utility>
#include <unistd.h>

// How many times a query that lost a lock race is re-run before being
// abandoned. Bounds the stall described on zmDbContentionBackoff.
constexpr int kMaxDbContentionRetries = 5;

// How long to wait before retry number `attempt`, or 0 once the budget above is
// spent and the caller should give up. Jittered, so two sessions that deadlocked
// against each other do not wake together and repeat it.
//
// The caller sleeps this while holding db_mutex, which stops every other
// database user in the process, so the schedule is deliberately short: roughly
// 3 seconds across the whole budget.
useconds_t zmDbContentionBackoff(int attempt);

class zmDbQueue {
 private:
  // The flag marks rows the logger queued (inserts into Logs).
  std::queue<std::pair<std::string, bool>> mQueue;
  std::thread             mThread;
  std::mutex              mMutex;
  std::condition_variable mCondition;
  bool                    mTerminate;
 public:
  zmDbQueue();
  ~zmDbQueue();
  void push(std::string &&sql, bool log_row = false);
  void process();
  void stop();
};

class zmDbRow {
 private:
  MYSQL_RES *result_set;
  MYSQL_ROW row;
 public:
  zmDbRow() : result_set(nullptr), row(nullptr) { };
  MYSQL_RES *fetch(const std::string &query);
  zmDbRow(MYSQL_RES *, MYSQL_ROW *row);
  ~zmDbRow();

  MYSQL_ROW mysql_row() const { return row; };

  char *operator[](unsigned int index) const {
    return row[index];
  }
};

extern MYSQL dbconn;
extern std::mutex db_mutex;
extern zmDbQueue  dbQueue;
extern unsigned long db_thread_id;

extern bool zmDbConnected;

bool zmDbConnect();
void zmDbClose();
int zmDbDo(const std::string &query);
uint64_t zmDbDoInsert(const std::string &query);
int zmDbDoUpdate(const std::string &query);

MYSQL_RES * zmDbFetch(const std::string &query);
zmDbRow *zmDbFetchOne(const std::string &query);

std::string zmDbEscapeString(const std::string& to_escape);

#endif // ZM_DB_H