2025-09-19 13:47:10 +03:00 | | | //+------------------------------------------------------------------+
|
| | | //| Storage.mqh |
|
| | | //| Copyright 2024, Yuriy Bykov |
|
| | | //| https://www.mql5.com/ru/users/antekov |
|
| | | //+------------------------------------------------------------------+
|
| | | #property copyright "Copyright 2024, Yuriy Bykov"
|
| | | #property link "https://www.mql5.com/ru/users/antekov"
|
| | | #property version "1.01"
|
| | |
|
| | | #include "Database.mqh"
|
| | | #include "../Base/Factorable.mqh"
|
| | | #include "../Virtual/VirtualOrder.mqh"
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| Класс для работы с базой данных эксперта в виде |
|
| | | //| хранилища Key-Value для свойств и виртуальных позиций |
|
| | | //+------------------------------------------------------------------+
|
| | | class CStorage {
|
| | | protected:
|
| | | static bool s_res; // Результат всех операций чтения/записи базы данных
|
| | | public:
|
| | | // Подключение к базе данных эксперта
|
| | | static bool Connect(string p_fileName);
|
| | |
|
| | | // Закрытие подключения к базе данных
|
| | | static void Close();
|
| | |
|
| | | // Очистка данных
|
| | | static void Clear();
|
| | |
|
| | | // Сохранение виртуального ордера/позиции
|
| | | static void Set(int i, CVirtualOrder* order);
|
| | |
|
| | | // Сохранение одного значения произвольного простого типа
|
| | | template<typename T>
|
| | | static void Set(string key, const T &value);
|
| | |
|
| | | // Сохранение массива значений произвольного простого типа
|
| | | template<typename T>
|
| | | static void Set(string key, const T &values[]);
|
| | |
|
| | | // Получение значения в виде строки по заданному ключу
|
| | | static string Get(string key);
|
| | |
|
| | | // Получение массива виртуальных ордеров/позиций по заданному хешу стратегии
|
| | | static bool Get(string key, CVirtualOrder* &orders[]);
|
| | |
|
| | | // Получение значения по заданному ключу в переменную произвольного простого типа
|
| | | template<typename T>
|
| | | static bool Get(string key, T &value);
|
| | |
|
| | | // Получение массива значений простого типа по заданному ключу в переменную
|
| | | template<typename T>
|
| | | static bool CStorage::Get(string key, T &values[]);
|
| | |
|
| | | static bool CStorage::GetSymbols(string &symbols[]);
|
| | |
|
| | | // Результат операций
|
| | | static bool Res() {
|
| | | return s_res;
|
| | | }
|
| | | };
|
| | |
|
| | | // Результат всех операций чтения/записи базы данных
|
| | | bool CStorage::s_res = true;
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| Подключение к базе данных эксперта |
|
| | | //+------------------------------------------------------------------+
|
| | | bool CStorage::Connect(string p_fileName) {
|
| | | // Подключаемся к базе данных эксперта
|
| | | if(DB::Connect(p_fileName, DB_TYPE_ADV)) {
|
| | | // Устанавливаем, что пока ошибок нет
|
| | | s_res = true;
|
| | |
|
| | | // Начинаем транзакцию
|
| | | DatabaseTransactionBegin(DB::Id());
|
| | |
|
| | | return true;
|
| | | }
|
| | | return false;
|
| | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| Закрытие подключения к базе данных |
|
| | | //+------------------------------------------------------------------+
|
| | | void CStorage::Close() {
|
| | | // Если ошибок нет, то
|
| | | if(s_res) {
|
| | | // Подтверждаем транзакцию
|
| | | DatabaseTransactionCommit(DB::Id());
|
| | | } else {
|
| | | // Иначе транзакцию отменяем
|
| | | DatabaseTransactionRollback(DB::Id());
|
| | | }
|
| | |
|
| | | // Закрываем соединение с базой данных
|
| | | DB::Close();
|
| | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| Очистка данных |
|
| | | //+------------------------------------------------------------------+
|
| | | void CStorage::Clear() {
|
| | | string query = "DELETE FROM storage;\n"
|
| | | "DELETE FROM storage_orders;";
|
| | |
|
| | | DB::Execute(query);
|
| | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| Сохранение виртуального ордера/позиции |
|
| | | //+------------------------------------------------------------------+
|
| | | void CStorage::Set(int i, CVirtualOrder* order) {
|
| | | VirtualOrderStruct o; // Структура для информации о виртуальной позиции
|
| | | order.Save(o); // Наполняем её
|
| | |
|
| | | // Экранируем кавычки в комментарии
|
| | | StringReplace(o.comment, "'", "\\'");
|
| | |
|
| | | // Запрос на сохранение
|
| | | string query = StringFormat("REPLACE INTO storage_orders VALUES("
|
| | | "'%s',%d,%I64u,"
|
| | | "'%s',%.2f,%d,%I64d,%f,%f,%f,%I64d,%f,%I64d,'%s',%f);",
|
| | | order.Strategy().Hash(), i, o.ticket,
|
| | | o.symbol, o.lot, o.type,
|
| | | o.openTime, o.openPrice,
|
| | | o.stopLoss, o.takeProfit,
|
| | | o.closeTime, o.closePrice,
|
| | | o.expiration, o.comment,
|
| | | o.point);
|
| | |
|
| | | // Выполняем запрос
|
| | | s_res &= DatabaseExecute(DB::Id(), query);
|
| | |
|
| | | if(!s_res) {
|
| | | // Сообщаем об ошибке при необходимости
|
| | | PrintFormat(__FUNCTION__" | ERROR: Execution failed in DB [adv], query:\n"
|
| | | "%s\n"
|
| | | "error code = %d",
|
| | | query, GetLastError());
|
| | | }
|
| | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| Сохранение одного значения произвольного простого типа |
|
| | | //+------------------------------------------------------------------+
|
| | | template<typename T>
|
| | | void CStorage::Set(string key, const T &value) {
|
| | | // Экранируем символы одинарных кавычек (пока не можно не использовать)
|
| | | // StringReplace(key, "'", "\\'");
|
| | | // StringReplace(value, "'", "\\'");
|
| | |
|
| | | // Запрос на сохранение значения
|
| | | string query = StringFormat("REPLACE INTO storage(key, value) VALUES('%s', '%s');",
|
| | | key, (string) value);
|
| | |
|
| | | // Выполняем запрос
|
| | | s_res &= DatabaseExecute(DB::Id(), query);
|
| | |
|
| | | if(!s_res) {
|
| | | // Сообщаем об ошибке при необходимости
|
| | | PrintFormat(__FUNCTION__" | ERROR: Execution failed in DB [adv], query:\n"
|
| | | "%s\n"
|
| | | "error code = %d",
|
| | | query, GetLastError());
|
| | | }
|
| | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| Сохранение массива значений произвольного простого типа |
|
| | | //+------------------------------------------------------------------+
|
| | | template<typename T>
|
| | | void CStorage::Set(string key, const T &values[]) {
|
| | | string value = "";
|
| | |
|
| | | // Соединяем все значения из массива в одну строку через запятую
|
| | | JOIN(values, value, ",");
|
| | |
|
| | | // Сохраняем строку с заданным ключом
|
| | | Set(key, value);
|
| | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| Получение значения в виде строки по заданному ключу |
|
| | | //+------------------------------------------------------------------+
|
| | | string CStorage::Get(string key) {
|
| | | string value = NULL; // Возвращаемое значение
|
| | |
|
| | | // Запрос на получение значения
|
| | | string query = StringFormat("SELECT value FROM storage WHERE key='%s'", key);
|
| | |
|
| | | // Выполняем запрос
|
| | | int request = DatabasePrepare(DB::Id(), query);
|
| | |
|
| | | // Если нет ошибки
|
| | | if(request != INVALID_HANDLE) {
|
| | | // Читаем данные из первой строки результата
|
| | | DatabaseRead(request);
|
| | |
|
| | | if(!DatabaseColumnText(request, 0, value)) {
|
| | | s_res = false;
|
| | | // Сообщаем об ошибке при необходимости
|
| | | PrintFormat(__FUNCTION__" | ERROR: Reading row in DB [adv] for request \n%s\n"
|
| | | "failed with code %d",
|
| | | query, GetLastError());
|
| | | }
|
| | | } else {
|
| | | s_res = false;
|
| | | // Сообщаем об ошибке при необходимости
|
| | | PrintFormat(__FUNCTION__" | ERROR: Request in DB [adv] \n%s\nfailed with code %d",
|
| | | query, GetLastError());
|
| | | }
|
| | |
|
| | | return value;
|
| | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| Получение значения по заданному ключу в переменную |
|
| | | //| произвольного простого типа |
|
| | | //+------------------------------------------------------------------+
|
| | | template<typename T>
|
| | | bool CStorage::Get(string key, T &value) {
|
| | | // Получаем значение в виде строки
|
| | | string res = Get(key);
|
| | |
|
| | | // Если значение получено
|
| | | if(res != NULL) {
|
| | | // Приводим его к типу Т и присваиваем целевой переменной
|
| | | value = (T) res;
|
| | | return true;
|
| | | }
|
| | | return false;
|
| | | }
|
| | |
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| Получение массива значений произвольного простого типа |
|
| | | //+------------------------------------------------------------------+
|
| | | template<typename T>
|
| | | bool CStorage::Get(string key, T &values[]) {
|
| | | string params = Get(key);
|
| | | int n = ArraySize(values);
|
| | |
|
| | | if(params != NULL) {
|
| | | string parts[];
|
| | | StringSplit(params, ',', parts);
|
| | |
|
| | | FOREACH(parts) {
|
| | | if(i < n) {
|
| | | values[i] = (T) parts[i];
|
| | | } else {
|
| | | APPEND(values, (T) parts[i]);
|
| | | }
|
| | | }
|
| | | return true;
|
| | | }
|
| | | return false;
|
| | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| Получение массива виртуальных ордеров/позиций |
|
| | | //| по заданному хешу стратегии |
|
| | | //+------------------------------------------------------------------+
|
| | | bool CStorage::Get(string key, CVirtualOrder* &orders[]) {
|
| | | // Запрос на получение данных о виртуальных позициях
|
| | | string query = StringFormat("SELECT * FROM storage_orders "
|
| | | " WHERE strategy_hash = '%s' "
|
| | | " ORDER BY strategy_index ASC;",
|
| | | key);
|
| | |
|
| | | // Выполняем запрос
|
| | | int request = DatabasePrepare(DB::Id(), query);
|
| | |
|
| | | // Если нет ошибки
|
| | | if(request != INVALID_HANDLE) {
|
| | | // Структура для информации о виртуальной позиции
|
| | | VirtualOrderStruct row;
|
| | |
|
| | | // Читаем построчно данные из результата запроса
|
| | | while(DatabaseReadBind(request, row)) {
|
| | | orders[row.strategyIndex].Load(row);
|
| | | }
|
| | | } else {
|
| | | // Запоминаем ошибку и сообщаем об ней при необходимости
|
| | | s_res = false;
|
| | | PrintFormat(__FUNCTION__" | ERROR: Execution failed in DB [adv], query:\n"
|
| | | "%s\n"
|
| | | "error code = %d",
|
| | | query, GetLastError());
|
| | | }
|
| | |
|
| | | return s_res;
|
| | | }
|
| | |
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| Получение массива символоав виртуальных ордеров/позиций |
|
| | | //+------------------------------------------------------------------+
|
| | | bool CStorage::GetSymbols(string &symbols[]) {
|
| | | // Запрос на получение данных о виртуальных позициях
|
| | | string query = StringFormat("SELECT symbol FROM storage_orders "
|
| | | " WHERE symbol <> ''"
|
| | | " GROUP BY symbol", "");
|
| | |
|
| | | // Выполняем запрос
|
| | | int request = DatabasePrepare(DB::Id(), query);
|
| | |
|
| | | // Если нет ошибки
|
| | | if(request != INVALID_HANDLE) {
|
| | | // Структура для информации о виртуальной позиции
|
| | | string symbol;
|
| | |
|
| | | // Читаем построчно данные из результата запроса
|
| | | while(DatabaseRead(request)) {
|
| | | s_res &= DatabaseColumnText(request, 0, symbol);
|
| | | APPEND(symbols, symbol);
|
| | | }
|
| | | } else {
|
| | | // Запоминаем ошибку и сообщаем об ней при необходимости
|
| | | s_res = false;
|
| | | PrintFormat(__FUNCTION__" | ERROR: Execution failed in DB [adv], query:\n"
|
| | | "%s\n"
|
| | | "error code = %d",
|
| | | query, GetLastError());
|
| | | }
|
| | |
|
| | | return s_res;
|
| | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|