linux系统下PostgreSQL的使用

于 2024-09-09 10:14:53 发布
阅读量180 收藏 2
点赞数 1
分类专栏： linux 文章标签： linux postgresql 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011832219/article/details/142049692
版权

文章目录

前言

最近工作中使用到了pgsql,主要是使用其c++驱动完成数据库创建及增删改查等操作…

一、安装pgsql数据库

使用命令如下:

sudo apt-get install postgresql

安装完成,使用如下命令,确认数据库版本:

psql --version

二、安装c和c++驱动

使用如下命令安装c驱动:

sudo apt-get install libpq-dev

使用如下命令安装c++驱动:

sudo tar -zxvf libpqxx-6.4.8.tar.gz
cd libpqxx-6.4.8/
sudo ./configure --disable-documentation
sudo make
sudo make install

三、使用

1、头文件

头文件如下:

#ifndef POSTGREOPERATOR_H
#define POSTGREOPERATOR_H

#include <iostream>
#include <string>
#include <map>
#include <thread>

#include "pqxx/pqxx"

using namespace std;
using namespace pqxx;

struct TableField {
    string name;
    string type;
};

class PostgreOperator
{
private:
    PostgreOperator() {}
    PostgreOperator(const PostgreOperator&) = delete;
    PostgreOperator& operator=(const PostgreOperator&) = delete;
    ~PostgreOperator();

public:
    static PostgreOperator& getInstance();

    bool connect();
    void disConnect();

    bool insertOneRow(const string& tableName,const vector<string>& rowData);
    bool updateOneRow(const string& tableName, const string& conditionColumnName,
                   const string& conditionValue, const vector<string>& columnNames,
                   const vector<string>& newValues);
    void selectRows(const string& tableName, vector<vector<string>>& resultRows,
                    const vector<string>& selectedColumns,
                    const string& conditionColumnName = "",const string& conditionValue = "");
    bool deleteRows(const string& tableName, const string& conditionColumnName = "",
                      const string& conditionValue = "");

private:
    static void initTable();
    static bool createdb(const string& dbname,const string& user,const string& password);
    static bool createInitTable();

    static bool addTable(const string& tableName,const vector<TableField>& fields);
    static bool deleteTable(const string& tableName);

    static bool addFieldToTable(const string& tableName, const vector<TableField>& fields);
    static bool removeFieldFromTable(const string& tableName, const vector<string>& fieldNames);

private:
    static string m_user;
    static string m_passwd;
    static string m_dbName;
    static bool m_initTable;
    static PostgreOperator *m_instance;
    static map<string, vector<TableField>> m_tables;
    static connection* m_pConnection;
    static thread_local unique_ptr<connection> thread_local_connection_;
};

#endif // POSTGREOPERATOR_H

2、源文件

源文件如下:

#include "postgreoperator.h"

string      PostgreOperator::m_dbName;
string      PostgreOperator::m_user;
string      PostgreOperator::m_passwd;
bool        PostgreOperator::m_initTable = false;
connection* PostgreOperator::m_pConnection = nullptr;

map<string, vector<TableField>> PostgreOperator::m_tables;
PostgreOperator* PostgreOperator::m_instance = nullptr;
thread_local unique_ptr<connection> PostgreOperator::thread_local_connection_ = nullptr;

PostgreOperator& PostgreOperator::getInstance()
{
    if (!m_instance) {
        m_instance = new PostgreOperator;
        if(!m_initTable){
            initTable();
            createdb("disposaldb","tami","tami");
            createInitTable();
        }
    }

    return *m_instance;
}

PostgreOperator::~PostgreOperator()
{
    if(m_pConnection){
        m_pConnection->disconnect();
        delete m_pConnection;
        m_pConnection = nullptr;
    }
}

bool PostgreOperator::createdb(const string& dbname,const string& user,const string& password)
{
    m_dbName = dbname;
    m_user = user;
    m_passwd = password;
    string connectStr = "dbname=postgres user=postgres password=postgres "
                        "hostaddr=127.0.0.1 port=5432";
    bool ret = false;

    try {
        connection *connection = new pqxx::connection(connectStr);

        if(connection->is_open()){
            nontransaction txn(*connection);
            string quotedDb = "'" + dbname + "'";

            if(user.compare("postgres") == 0 && password.compare("postgres") == 0){
                //cout<<"hello111 "<<"user ="<<user<<"password ="<<password<<endl;
                string checkDb = "SELECT 1 FROM pg_database WHERE datname = " + quotedDb;
                pqxx::result result_check = txn.exec(checkDb);
                if(result_check.empty()){
                    string sql = "CREATE DATABASE " + dbname + " WITH OWNER= postgres"+" ENCODING='UTF-8' ;";
                    txn.exec(sql);
                    cout << "create database "+ dbname +" with user=postgres successed!" << endl;
                }
                else{
                    cout << "database "+ dbname + " already exists!" <<endl;
                }
            }
            else{
                //cout<<"hello222 "<<"user ="<<user<<" password ="<<password<<endl;
                string quotedUser = "'" + user + "'";
                string checkUser = "SELECT 1 FROM pg_user WHERE usename = " + quotedUser;
                pqxx::result result_checkUser = txn.exec(checkUser);
                if (result_checkUser.empty()) {
                    string sql = "CREATE USER " + user + " WITH PASSWORD '" + password + "'";
                    txn.exec(sql);
                }
                else{
                    cout << "user "+ user + " already exists!" <<endl;
                }
                std::string checkDb = "SELECT 1 FROM pg_database WHERE datname = " + quotedDb;
                pqxx::result result_check = txn.exec(checkDb);
                if(result_check.empty()){
                    string dbSql = "CREATE DATABASE " + dbname + " WITH OWNER="+user+" ENCODING='UTF-8';";
                    txn.exec(dbSql);
                    cout << "create database "+ dbname +" with user="+user+" successed!" << endl;
                }
                else{
                    cout << "database "+ dbname + " already exists!" <<endl;
                }
            }

            ret = true;
        }else{
            cout<<"open database " + dbname +" with user=postgres failed!"<<endl;
            connection->disconnect();

            return ret;
        }
        delete connection;
        connection = nullptr;
    }catch (const std::exception &e) {
        cerr<<e.what()<<endl;
    }

    return ret;
}

void PostgreOperator::initTable()
{
    m_tables.clear();
    m_tables = {
        {"p_frequency", {
            {"msgId", "bigint"},
            {"sn", "bigint"},
            {"startFrequency", "bigint"},
            {"endFrequency", "bigint"},
            {"rbw", "double precision"},
            {"dataType", "smallint"},
            {"number", "integer"},
        }},
        {"d_frequency", {
            {"msgId", "bigint"},
            {"sn", "bigint"},
            {"times", "timestamp without time zone"},
            {"timems", "timestamp without time zone"},
            {"data", "smallint[]"},
        }},
        {"p_timedomain", {
             {"msgId", "bigint"},
             {"sn", "bigint"},
             {"centerFrequency", "bigint"},
             {"gain", "smallint"},
             {"timestamp", "timestamp without time zone"},
             {"frameTotal", "integer"},
             {"frameNumber", "integer"},
             {"number", "integer"},
        }},
        {"d_timedomain", {
             {"msgId", "bigint"},
             {"sn", "bigint"},
             {"times", "timestamp without time zone"},
             {"timems", "timestamp without time zone"},
             {"data", "integer[]"},
        }},
    };
}

bool PostgreOperator::createInitTable()
{
    string connectStr = "dbname="+m_dbName+" user="+m_user+" password="+m_passwd+
                        " hostaddr=127.0.0.1 port=5432";
    bool ret = false;

    try {
        m_pConnection = new pqxx::connection(connectStr);
        if(m_pConnection->is_open()){
            nontransaction txn(*m_pConnection);

            for (const auto& table : m_tables) {
                const std::string tableName = table.first;
                const std::vector<TableField>& fields = table.second;

                string quotedtable = "'" + tableName + "'";
                string checktable = "SELECT 1 FROM information_schema.tables WHERE table_name = " + quotedtable;
                //cout<<"checktable ="<<checktable<<endl;
                pqxx::result result_check = txn.exec(checktable);

                if (result_check.empty()) {
                    string quotedTableName = "\"" + tableName + "\"";
                    string createTableQuery = "CREATE TABLE " + quotedTableName + " (";
                    string idStr = "id";
                    string msgIdStr = "msgId";
                    string snStr = "sn";

                    createTableQuery += "\"" + idStr + "\" ";
                    createTableQuery += " BIGSERIAL, ";

                    for (size_t i = 0; i < fields.size(); i++) {
                        if (fields[i].name == msgIdStr || fields[i].name == snStr) {
                            createTableQuery += "\"" + fields[i].name + "\" " + " " + fields[i].type;
                            createTableQuery += " NOT NULL";
                        } else {
                            createTableQuery += "\"" + fields[i].name + "\" " + " " + fields[i].type;
                        }
                        if (i < fields.size() - 1) {
                            createTableQuery += ", ";
                        }
                    }

                    createTableQuery += ", PRIMARY KEY (\"" + idStr + "\")";
                    createTableQuery += ")";
                    //cout<<"createTableQuery ="<<createTableQuery<<endl;
                    txn.exec(createTableQuery);
                    cout << "create table " + tableName + " succeeded!" << endl;
                } else {
                    cout << "table " + tableName + " already exists!" << endl;
                }
            }

            ret = true;
        }


    } catch (const std::exception& e) {
        cerr << e.what() << endl;
    }

    return ret;
}

bool PostgreOperator::connect()
{
    if (!thread_local_connection_) {
        std::string connectStr = "dbname=" + m_dbName + " user=" + m_user + " password=" + m_passwd
                                + " hostaddr=127.0.0.1 port=5432";
        try {
            thread_local_connection_.reset(new pqxx::connection(connectStr));

            if (thread_local_connection_->is_open()) {
                cout << "Connected to dbname=" << m_dbName << " with user=" << m_user << " succeeded!" << endl;
                return true;
            } else {
                cout << "Failed to connect to dbname=" << m_dbName << " with user=" << m_user << endl;
                return false;
            }
        } catch (const std::exception& e) {
            std::cerr << "Connection failed: " << e.what() << std::endl;
            return false;
        }
    }

    return true;
}

void PostgreOperator::disConnect()
{
    if (thread_local_connection_) {
        thread_local_connection_->disconnect();
        thread_local_connection_.reset();
    }
}

bool PostgreOperator::addFieldToTable(const string& tableName, const vector<TableField>& fields)
{
    bool ret = false;

    try {
        work txn(*m_pConnection);
        string quotedtable = "'" + tableName + "'";
        string checktable = "SELECT 1 FROM information_schema.tables WHERE table_name = " + quotedtable;
        pqxx::result result_check = txn.exec(checktable);

        if (!result_check.empty()) {
            for(const auto& field : fields){
                string columnName = "'" + field.name + "'";
                string sql = "SELECT column_name FROM information_schema.columns WHERE table_name = '" + tableName + "' AND column_name = " +columnName;
                //cout<<"select sql ="<<sql<<endl;
                pqxx::result result = txn.exec(sql);
                if(result.empty()){
                    string sql = "ALTER TABLE "+ tableName+" ADD COLUMN ";
                    sql += "\"" + field.name + "\" " + " " + field.type;
                    //cout<<"alter add sql ="<<sql<<endl;
                    txn.exec(sql);
                    cout << "addFieldToTable successfully." << endl;
                    ret = true;
                }
                else{
                    cout<<"column "+field.name+" of "+tableName+" already exists!"<<endl;
                }
            }
        }
        else{
           cout << "table " + tableName + " does not exist!" << endl;
        }
        txn.commit();
    } catch (const std::exception& e) {
        cerr << e.what() << endl;
    }

    return ret;
}

bool PostgreOperator::removeFieldFromTable(const string& tableName, const vector<string>& fieldNames)
{
    bool ret = false;

    try {
        work txn(*m_pConnection);
        string quotedtable = "'" + tableName + "'";
        string checktable = "SELECT 1 FROM information_schema.tables WHERE table_name = " + quotedtable;
        pqxx::result result_check = txn.exec(checktable);

        if (!result_check.empty()) {
            for(const auto& field : fieldNames){
                string columnName = "'" + field + "'";
                string sql = "SELECT column_name FROM information_schema.columns WHERE table_name = '" + tableName + "' AND column_name = " +columnName;
                //cout<<"select sql ="<<sql<<endl;
                pqxx::result result = txn.exec(sql);
                if(!result.empty()){
                    string sql = "ALTER TABLE "+ tableName+" DROP COLUMN ";
                    sql += "\"" + field + "\" " + " ";
                    //cout<<"alter drop sql ="<<sql<<endl;
                    txn.exec(sql);
                    cout << "removeFieldFromTable successfully." << endl;
                    ret = true;
                }
                else{
                    cout<<"column "+field+" of "+tableName+" does not exists!"<<endl;
                }
            }
        }
        else{
           cout << "table " + tableName + " does not exist!" << endl;
        }
        txn.commit();
    } catch (const std::exception& e) {
        cerr << e.what() << endl;
    }

    return ret;
}

bool PostgreOperator::addTable(const string& tableName, const vector<TableField>& fields)
{
    bool ret = false;
    work txn(*m_pConnection);

    string quotedtable = "'" + tableName + "'";
    string checktable = "SELECT 1 FROM information_schema.tables WHERE table_name = " + quotedtable;
    //cout<<"checktable ="<<checktable<<endl;
    pqxx::result result_check = txn.exec(checktable);

    if (result_check.empty()) {
        string quotedTableName = "\"" + tableName + "\"";
        string createTableQuery = "CREATE TABLE " + quotedTableName + " (";
        string idStr = "id";
        string msgIdStr = "msgId";
        string snStr = "sn";

        createTableQuery += "\"" + idStr + "\" ";
        createTableQuery += " BIGSERIAL, ";
        createTableQuery += "\"" + msgIdStr + "\" ";
        createTableQuery += " bigint NOT NULL, ";
        createTableQuery += "\"" + snStr + "\" ";
        createTableQuery += " bigint NOT NULL, ";

        if(!fields.empty()){
            for (size_t i = 0; i < fields.size(); i++) {
                createTableQuery += "\"" + fields[i].name + "\" " + " " + fields[i].type;
                if (i < fields.size() - 1) {
                    createTableQuery += ", ";
                }
            }
            createTableQuery += ", PRIMARY KEY (\"" + idStr + "\")";
        }
        else{
            createTableQuery += " PRIMARY KEY (\"" + idStr + "\")";
        }
        createTableQuery += ")";
        txn.exec(createTableQuery);
        txn.commit();
        //cout<<"createTableQuery ="<<createTableQuery<<endl;
        cout << "create table " + tableName + " succeeded!" << endl;

        m_tables[tableName] = fields;

//        for (const auto& table : m_tables) {
//            const string tableName = table.first;
//            cout<<"tablename ="<<tableName<<endl;

//            const vector<TableField>& fields = table.second;
//            for(const auto& field : fields){
//                cout<<"name="<<field.name<<"type ="<<field.type;
//            }
//            cout<<endl;
//        }

        ret = true;
    } else {
        cout << "table " + tableName + " already exists!" << endl;
    }

    return ret;
}

bool PostgreOperator::deleteTable(const string& tableName)
{
    bool ret = false;

    try {
        string sql = "DROP TABLE IF EXISTS " + tableName;
        pqxx::work txn(*m_pConnection);
        txn.exec(sql);

        if(!m_tables.empty()){
            auto it = m_tables.find(tableName);
            if (it != m_tables.end()) {
                m_tables.erase(it);
                //cout << "Table '" << tableName << "' deleted from m_tables successfully." << endl;
                ret = true;
            } else {
                cout << "Table '" << tableName << "' not found from m_tables." << endl;
            }
        }
        txn.commit();
    } catch (const std::exception& e) {
        cerr << e.what() << endl;
    }

    return ret;
}

bool PostgreOperator::insertOneRow(const string& tableName,const vector<string>& rowData)
{
    bool ret = false;
    pqxx::work txn(*thread_local_connection_);

    try {
        std::string sql = "INSERT INTO " + tableName + " (";

        for (const auto& table : m_tables) {
            const std::string tableNameStr = table.first;
            const std::vector<TableField>& fields = table.second;

            if(tableNameStr == tableName){
                for (size_t i = 0; i < fields.size(); i++) {
                    sql += "\"" + fields[i].name + "\" ";

                    if (i != fields.size() - 1) {
                        sql += ",";
                    }
                }
            }
        }
        sql += ") VALUES (";
        for (size_t i = 0; i < rowData.size(); i++) {
            sql += "'" + rowData[i] + "'";

            if (i != rowData.size() - 1) {
                sql += ",";
            }
        }

        sql += ")";
        //cout<<"insert sql ="<<sql<<endl;

        txn.exec(sql);
        txn.commit();

        ret = true;
    } catch (const std::exception &e) {
        cerr<<e.what()<<endl;
        txn.abort();
    }

    return ret;
}

bool PostgreOperator::updateOneRow(const string& tableName, const string& conditionColumnName,
               const string& conditionValue, const vector<string>& columnNames,
               const vector<string>& newValues)
{
    bool ret = false;

    try {
        pqxx::work txn(*thread_local_connection_);

        std::string sql = "UPDATE " + tableName + " SET ";

        for (size_t i = 0; i < columnNames.size(); i++) {
            string columnName = "\"" + columnNames[i] + "\" ";
            sql += columnName + " = '" + newValues[i] + "'";

            if (i != columnNames.size() - 1) {
                sql += ",";
            }
        }

        string conditionName = "\"" + conditionColumnName + "\" ";
        sql += " WHERE " + conditionName + " = '" + conditionValue + "'";
        txn.exec(sql);
        txn.commit();

        cout << "Data updated successfully." << endl;
        ret = true;
    } catch (const std::exception &e) {
        cerr << e.what() << endl;
    }

    return ret;
}

void PostgreOperator::selectRows(const string& tableName, vector<vector<string>>& resultRows, const vector<string>& selectedColumns,
                                 const string& conditionColumnName,const string& conditionValue)
{
    try {
        pqxx::work txn(*thread_local_connection_);

        string sql;// = "SELECT * FROM " + tableName;
        if (!selectedColumns.empty()) {
            sql = "SELECT ";
            for (size_t i = 0; i < selectedColumns.size(); ++i) {
                sql += "\"" + selectedColumns[i] + "\"";
                if (i < selectedColumns.size() - 1)
                    sql += ",";
            }
            sql += " FROM " + tableName;
        } else {
            sql = "SELECT * FROM " + tableName;
        }

        if(!conditionColumnName.empty() && !conditionValue.empty()) {
            string conditionName = "\"" + conditionColumnName + "\" ";
            sql += " WHERE " + conditionName + " = '" + conditionValue + "'";
        }

        pqxx::result result = txn.exec(sql);
        for (const auto& row : result) {
            vector<string> record;
            for (const auto& field : row) {
                //cout << field.name() << ": " << field.c_str() << "     ";
                record.push_back(field.c_str());
            }
            resultRows.push_back(record);
            //cout << endl;
        }

        txn.commit();

        cout << "Data select successfully." << endl;
    } catch (const std::exception &e) {
        cerr << e.what() << endl;
    }
}

bool PostgreOperator::deleteRows(const string& tableName, const string& conditionColumnName,
                                   const string& conditionValue)
{
    bool ret = false;
    pqxx::work txn(*thread_local_connection_);

    try {
        string sql = "DELETE FROM " + tableName;
        if(!conditionColumnName.empty() && !conditionValue.empty()) {
            string conditionName = "\"" + conditionColumnName + "\" ";
            sql += " WHERE " + conditionName + " = '" + conditionValue + "'";
        }
        cout<<"deleterows sql = "<<sql<<endl;
        txn.exec(sql);
        txn.commit();

        cout << "Data delete successfully." << endl;

        ret = true;
    } catch (const std::exception &e) {
        cerr << e.what() << endl;

        txn.abort();
    }

    return ret;
}

3、main文件

#include <chrono>
#include <iostream>
#include <thread>

#include "postgreoperator.h"

void insertfun(int id,PostgreOperator &operatorInstance) {
    if (!operatorInstance.connect()) {
        std::cerr << "Thread " << id << " failed to connect to the database." << std::endl;
        return;
    }
    string tableName = "p_frequency";

    for(int i = 0;i<500;i++){
        vector<string> data = {"12345", "10086", "0", "2000000", "0.1", "1", "10"};
        operatorInstance.insertOneRow(tableName, data);
    }

    for(int i = 500;i<1000;i++){
        vector<string> data = {"67890", "10086", "0", "2000000", "0.1", "1", "10"};
        operatorInstance.insertOneRow(tableName, data);
    }
}

void deletefun(int id,PostgreOperator &operatorInstance)
{
    if (!operatorInstance.connect()) {
        std::cerr << "Thread " << id << " failed to connect to the database." << std::endl;
        return;
    }
    string tableName = "p_frequency";
    string conditionColumnName = "msgId";
    string conditionValue = "12345";

    operatorInstance.deleteRows(tableName, conditionColumnName, conditionValue);
}

int main(int argc, char *argv[])
{
    PostgreOperator& operatorInstance = PostgreOperator::getInstance();
    // 创建并启动多个线程
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(insertfun, i,std::ref(operatorInstance));
    }

    // 等待所有线程完成
    for (auto& thread : threads) {
        thread.join();
    }

#if 0
    std::thread t1(deletefun, 5, std::ref(operatorInstance));
    t1.join();

#endif

    return 1;
}

4、编译

命令如下:

g++ -pthread --std=c++11 -o demo.out main.cpp postgreoperator.cpp -lpqxx -lpq
敲代码的雪糕
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
linux操作系统下离线安装postgresql数据库
10-17
在Linux操作系统下，离线安装PostgreSQL数据库是一个常见的需求，特别是在没有互联网连接或者网络环境受限的服务器上。本文将详细讲解如何在Ubuntu和统信UOS操作系统中进行PostgreSQL的离线安装步骤。 首先，安装前...
Linux下的postgresql10数据库安装包
11-13
本安装包是针对Linux系统的PostgreSQL 10.8版本，它提供了在Linux环境下部署数据库服务所需的所有组件。 在安装PostgreSQL 10.8之前，你需要确保你的Linux系统满足以下先决条件： 1. **操作系统兼容性**：确认你的...
postgresql的linux系统安装
02-21
在Linux系统上安装PostgreSQL是一种常见的任务，尤其对于IT运维人员和数据库管理员而言。PostgreSQL是一种开源的对象关系型数据库管理系统（DBMS），以其强大的功能、稳定性及安全性而受到广泛赞誉。下面将详细介绍...
Linux centos7 postgresql12 离线安装包
08-09
在Linux CentOS7系统中安装PostgreSQL 12数据库是一个常见的任务，特别是在没有互联网连接或网络环境受限的情况下，离线安装包成为了唯一的选择。本指南将详细介绍如何使用离线安装包在CentOS7上安装PostgreSQL 12。...
Linux下PostgreSQL安装部署详细步骤
11-06
在Linux环境下部署PostgreSQL数据库是一项基础且重要的任务，尤其对于那些需要处理...这是一个涉及多步骤且需要注意细节的过程，但遵循以上步骤，你将能顺利地在Linux系统上建立一个功能完备的PostgreSQL数据库实例。
Linux 进程控制
2302_77289177的博客
09-08 864
Linux 进程控制
高效诊断Linux性能问题
Tiger93的博客
09-08 217
诊断Linux性能问题
Linux【5】远程管理
m0_68339197的博客
09-04 295
shutdown -r 重启。
＜Linux＞ 基础IO
prodigy623的博客
09-06 864
详解Linux基础IO：文件系统调用接口与C库文件函数的关系、重定向、数据缓冲区、文件系统、动静态库
Linux：vim编辑器的基本使用
2401_86544677的博客
09-04 763
当然，也可以直接删除。vim可以直接用键盘上的光标来上下左右移动，但正规的vim是用小写英文字母「h」、「j」、「k」、「i」，分别控制光标左、下、上、右移一格。」键，再输入您想寻找的字符，如果第一次找的关键字不是您想要的，可以一直 按「n」会往前寻找到您要的关键字为止。「#」:「#」号表示一个数字，在冒号后输入一个数字，再按回车键就会跳到该行了，如输入数字15， 再回车，就会跳到文章的第15行。「/关键字」: 先按「/」键，再输入您想寻找的字符，如果第一次找的关键字不是您想要的，可以一直按。
Linux之MySQL主从复制
2302_79087378的博客
09-08 979
MySQL的主从复制（）是一种数据复制解决方案，将主数据库的DDL（数据定义语言）和DML（数据操纵语言）操作通过二进制日志传到从库服务器中，然后在从库上对这些日志重新执行（也叫重做），从而是的从库和主库的数据保存同步。MySQL支持将数据从一个MySQL服务器（主服务器）复制到一个或多个其他MySQL服务器（从服务器），从库同时也可以作为其他从服务器的主库，实现链状复制。MySQL主从复制的优点主要包含以下三个方面：主库出现问题，可以快速切换到从库提供服务；实现读写分离，降低主库的访问压力；
Linux 下 C/C++ 程序编译的过程
Teminator_的博客
09-08 2208
本文将介绍如何将 C/C++ 语言编写的程序转换成为处理器能够执行的二进制代码的过程，包括四个步骤：预处理（）编译（）汇编（）链接（在此之前，首先来看一下 GCC 工具链。
【Linux修行路】线程安全和死锁
m0_68662723的博客
09-06 1090
今天的分享到这里就结束啦！如果觉得文章还不错的话，可以三连支持一下，您的支持就是我前进的动力！
C/C++ 获取 linux 的所有 USB声卡ID及其信息
lijian2017的博客
09-04 1109
popen()在 Linux 下，要获取 USB 声卡的 ID 和名称信息，通常你需要结合多个系统命令和接口，因为 C/C++ 标准库本身并不直接提供这样的功能。下面我将给出一个大致的方向，展示如何通过执行系统命令或使用 Linux 特有的库来实现这一目标。
【Linux】Linux 可重入函数
最新发布
2403_86785171的博客
09-08 689
简单来说，可重入函数是线程安全的函数。当函数正在执行时，如果它被其他线程或中断再次调用，它能够正确处理这种情况。不使用静态或全局变量，或仅使用局部变量。不依赖非线程安全的库函数，如malloc或strtok。不修改输入参数。如果函数需要访问共享资源，则必须使用同步机制（如锁或信号量）来避免竞态条件。
Linux 删除虚拟环境命令
lft_happiness的博客
09-05 373
linux 查看虚拟环境 删除虚拟环境
Linux xargs命令
菜鸟记录
09-08 606
⏹Linux xargs命令
Linux中的wc -l 和 ls -l 命令
qq_37397652的博客
09-05 1097
此行表示一个名为的目录，它的权限为drwxr-xr-x（所有者拥有全部权限，同组用户和其他用户仅有读和执行权限）。这个目录的所有者是lindsey，所属组是staff，目录的大小为96字节，最后修改时间是9月5日 11:45。wc -l：统计文件或输入流中的行数。ls -l：以长格式列出目录内容，显示详细的文件和目录信息。
算法题汇总
yolo
09-04 1190
算法汇总 环形链表 https://leetcode.cn/problems/linked-list-cycle/ 反转链表 https://leetcode.cn/problems/reverse-linked-list/28 环形链表 II https://leetcode.cn/problems/linked-list-cycle-ii/ 快乐数 https://leetcode.cn/problems/happy-number/ 反转链表 II https:/
pgsql linux常用指令
03-29
Pgsql是一种开源的关系型数据库管理系统，常用于在Linux系统上进行数据库操作。以下是一些常用的Pgsql Linux指令： 1. psql：用于连接和操作Pgsql数据库的命令行工具。可以使用以下命令连接到数据库： ``` psql -U username -d database_name ``` 其中，`-U`参数指定用户名，`-d`参数指定要连接的数据库名。 2. createdb：用于创建新的数据库。可以使用以下命令创建数据库： ``` createdb -U username database_name ``` 其中，`-U`参数指定用户名，`database_name`为要创建的数据库名。 3. dropdb：用于删除数据库。可以使用以下命令删除数据库： ``` dropdb -U username database_name ``` 其中，`-U`参数指定用户名，`database_name`为要删除的数据库名。 4. pg_dump：用于备份数据库。可以使用以下命令备份数据库： ``` pg_dump -U username -d database_name -f backup_file.sql ``` 其中，`-U`参数指定用户名，`-d`参数指定要备份的数据库名，`-f`参数指定备份文件名。 5. psql -f：用于执行SQL脚本文件。可以使用以下命令执行SQL脚本： ``` psql -U username -d database_name -f script_file.sql ``` 其中，`-U`参数指定用户名，`-d`参数指定要执行脚本的数据库名，`-f`参数指定脚本文件名。 6. pg_ctl：用于启动、停止和重启Pgsql服务。可以使用以下命令控制Pgsql服务： ``` pg_ctl start|stop|restart -D /path/to/data_directory ``` 其中，`start`表示启动服务，`stop`表示停止服务，`restart`表示重启服务，`-D`参数指定数据目录的路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

敲代码的雪糕

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值