energy_storage/src/database/DaoEntity.cpp

#include "DaoEntity.h"
//#include "PvInstance.h"
//#include "spdlogger.h"

MysqlOption DaoEntity::option_;

DaoEntity::DaoEntity(string tb_name)
{
    //MysqlOptions opts;
    //opts.host = "localhost";
    //opts.user = "root";
    //opts.password = "123456";
    //opts.port = 3306;
    //opts.dbname = "pvb";
    db_ = make_shared<MysqlClient>(DaoEntity::option_);
    if (!db_->isConnected())
    {
        //Global::data().status_msg = "数据库连接异常！";
        //PvInstance::send_user_event(nullptr, EUserEvent::ALARM_DB, "数据库连接异常！");
    }
    tableName_ = tb_name;
}

DaoEntity::~DaoEntity()
{
    db_ = nullptr;
}

MysqlOption& DaoEntity::mysqlOption()
{
    return DaoEntity::option_;
}
void DaoEntity::setOption(std::string host, int port, std::string user, std::string pwd, std::string dbname)
{
    option_.host = host;
    option_.port = port;
    option_.user = user;
    option_.password = pwd;
    option_.dbname = dbname;
}

std::shared_ptr<DaoEntity> DaoEntity::create(string tb_name)
{
    std::shared_ptr<DaoEntity> dao = std::make_shared<DaoEntity>(tb_name);
    return (dao->isConnected() ? dao : nullptr);
}

bool DaoEntity::execOnce(string sql)
{
    auto db = make_shared<MysqlClient>(DaoEntity::option_);
    return db->exec(sql);
}

bool DaoEntity::execOnce(string sql, vector<Fields>& result)
{
    auto db = make_shared<MysqlClient>(DaoEntity::option_);
    return db->exec(sql, result);
}

void DaoEntity::setTableName(string tb_name)
{
    tableName_ = tb_name;
}

bool DaoEntity::isConnected()
{
    return db_->isConnected();
}

bool DaoEntity::exec(string sql)
{
    return db_->exec(sql);
}

bool DaoEntity::exec(string sql, vector<Fields>& result)
{
    return db_->exec(sql, result);
}

bool DaoEntity::insertFields(Fields& fields)
{
    string sql = fields.get_insert_sql(tableName_);
    return this->db_->exec(sql);
}

bool DaoEntity::insertFields(vector<Fields>& vec_fields)
{
    //"insert into TABLE () values ()";
    string sql = "insert into " + tableName_;
    bool first = true;
    string keys;
    string values;

    for (auto& field : vec_fields)
    {
        keys = "";
        values = "";
        for (auto& item : field.fields())
        {
            const string& k = item.first;
            const string& v = item.second;
            if (first)
            {
                if (!keys.empty())
                {
                    keys += ",";
                }
                keys += k;
            }
            if (!values.empty())
            {
                values += ",";
            }
            values += ("'" + v + "'");
        }
        if (first)
        {
            sql += (" (" + keys + ")");
            sql += (" values (" + values + ")");
            first = !first;
        }
        else
        {
            sql += (",(" + values + ")");
        }
    }
    sql += ";";
    return this->db_->exec(sql);
}

bool DaoEntity::duplicateUpdate(Fields& fields, const vector<string>& keys)
{
    //insert into device_attr(device_id, attr_id, attr_val) values('26', 'model', '型号1') on duplicate key update attr_val='型号1';
    string s_key;
    string s_val;
    for (auto& item : fields.fields())
    {
        if (!s_key.empty())
        {
            s_key += ","; s_val += ",";
        }
        s_key += (item.first);
        s_val += ("'" + item.second + "'");
    }
    string s_data;
    for (auto& k : keys)
    {
        if (!s_data.empty())
        {
            s_data += ",";
        }
        s_data += (k + "='" + fields.value(k) + "'");
    }
    string sql = "INSERT INTO " + tableName_ + "(" + s_key + ") VALUES (" + s_val + ") ON duplicate KEY UPDATE " + s_data;
    return this->db_->exec(sql);
}

//void DaoEntity::queryFields(const string& condition, DaoPageinfo& pageinfo, vector<map<string, string>>& result)
//{
//	this->query_by_page(condition, pageinfo, [&](map<string, string>& row) mutable {
//		result.push_back(row);
//	});
//}


bool DaoEntity::queryFields(string keys, const string& sql_c, vector<Fields>& result)
{
    ostringstream oss;
    oss << "SELECT " + keys + " FROM " << tableName_ << (" " + sql_c) << "; ";
    return this->db_->exec(oss.str(), result);
}

bool DaoEntity::queryFields(string keys, const string& sql_c, PageInfo& page, vector<Fields>& result)
{
    ostringstream oss;
    oss << "SELECT count(1) total FROM `" << tableName_ << "` " << sql_c << ";";

    vector<Fields> res_total;
    if (!this->db_->exec(oss.str().c_str(), res_total))
    {
        return false;
    }

    if (res_total.size() <= 0)
    {
        page.total = 0;
        return true;
    }
    page.total = res_total[0].getInt("total");
    if (page.total <= 0)
    {
        return true;
    }

    oss.str("");
    if (page.index <= 0)
    {
        page.index = 1;
    }
    int start = (page.index - 1) * page.size;
    oss << "SELECT " << keys << " FROM `" << tableName_ << "` " << sql_c << " LIMIT " << start << "," << page.size << ";";
    return this->db_->exec(oss.str().c_str(), result);
}

bool DaoEntity::updateFields(Fields& fields, const string& sql_c)
{
    string sql = fields.get_update_sql(tableName_, sql_c);
    std::cout << sql;
    if (sql_c.empty())
    {
        //Spdlogger::error("[DB] update condition is empty, not exec, sql={}", sql);
        return false;
    }
    return this->db_->exec(sql.c_str());
}

bool DaoEntity::updateFields(Fields& fields, vector<string> vec_keys, const string& sql_c)
{
    string sql = fields.get_update_sql(tableName_, vec_keys, sql_c);
    if (sql_c.empty())
    {
        //Spdlogger::error("[DB] update condition is empty, not exec, sql={}", sql);
        return false;
    }
    return this->db_->exec(sql.c_str());
}