项目实践（一）点餐系统——数据管理模块基础操作

喜欢ヅ旅行 2022-10-06 11:48 130阅读 0赞

### 数据管理模块： ###

数据存储：mysql

*  sql语句中，每条语句都以;结尾
 *  sql语句中，不区分大小写
 *  sql语句中，数据库名称，表名称，字段名称不能直接使用sql关键字
 *  库的操作：

(1)创建数据库：create database dbname; create database if not exists dbname;（如果不存在则创建）

(2)查看所有数据库：show dtabases;

(3)选择所使用的数据库：use dbname ; select databases();

(4)删除数据库：drop database dbname；

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 1][]

*  表的操作：

(1)创建表 create table if not exists tbname（id int ,name varchar(32),sex bit(1),score decimal(4,2),birthady datetime）; 常见数据类型：in decimal（m，d）m为长度，d为小数位数 varchar（字符长度）

(2)查看所有表：show tables;

(3)查看指定表结构 desc tbname;

(4)修改表结构 alter table tbname add school varchar(32)

(5)删除表：drop table tbname

(6)字段约束： primary key 主键约束（非空且唯一） unique key 唯一约束(约束指定字段必须唯一) not null 非空约束（约束指定字段必须非空）auto\_increment自增属性（只能用于整型主键字段）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 2][]

表中数据的操作：增删改查

新增：insert myTB(id,name,sex)values(null,"wang",0);

删除 delete from tbname where id=2；

修改：update myTB set score=91.34,birthady="2019-11-07 14:15:02",address="beijing" where id=1;

查询：select\* from tbname

按指定列查询select id name sex from tbname

按序查找：select id name sex from tbname order by id desc(降序查找)

分页查询：select \*from tbname order by id desc limit 3 offset 3；

条件查询：select\* from tbname where score>90;

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 3][]

测试：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 5][]

数据库操作流程：

![2021061311575921.png][]

**初始化mysql句柄：**

**MYSQL \*mysql\_init(MYSQL \*mysql)；**  
//参数为空则动态申请句柄空间进行初始化  
//失败返回NULL  
**连接mysql服务器：**

**MYSQL \*mysql\_real\_connect(MYSQL \*mysql, const char \*host, const char \*user,const char \*passwd,const char \*db, unsigned int port,const char \*unix\_socket, unsigned long client\_flag);**  
//mysql--初始化完成的句柄  
//host---连接的mysql服务器的地址  
//user---连接的服务器的用户名  
//passwd-连接的服务器的密码  
//db ----默认选择的数据库名称  
//port---连接的服务器的端口： 默认0是3306端口  
//unix\_socket---通信管道文件或者socket文件，通常置NULL  
//client\_flag---客户端标志位，通常置0  
//返回值：成功返回句柄，失败返回NULL  
**设置当前客户端的字符集：**

**int mysql\_set\_character\_set(MYSQL \*mysql, const char \*csname)**  
//mysql--初始化完成的句柄  
//csname--字符集名称，通常："utf8"  
//返回值：成功返回0， 失败返回非0；  
**选择操作的数据库：**

**int mysql\_select\_db(MYSQL \*mysql, const char \*db)**  
//mysql--初始化完成的句柄  
//db-----要切换选择的数据库名称  
//返回值：成功返回0， 失败返回非0；

**执行sql语句**

**int mysql\_query(MYSQL \*mysql, const char \*stmt\_str)**  
//mysql--初始化完成的句柄  
//stmt\_str--要执行的sql语句  
//返回值：成功返回0， 失败返回非0；

**保存查询结果到本地**

**MYSQL\_RES \*mysql\_store\_result(MYSQL \*mysql)**  
//mysql--初始化完成的句柄  
//返回值：成功返回结果集的指针（地址）， 失败返回NULL；

特别注意：**mysql\_query和****mysql\_store\_result存在多线程安全问题，需要上锁保护**

**获取结果集中的行数和列数**

**uint64\_t mysql\_num\_rows(MYSQL\_RES \*result)；**  
//result--保存到本地的结果集地址  
//返回值：结果集中数据的条数；  
**unsigned int mysql\_num\_fields(MYSQL\_RES \*result)**  
//result--保存到本地的结果集地址  
//返回值：结果集中每一条数据的列数；

**遍历结果集**

**MYSQL\_ROW mysql\_fetch\_row(MYSQL\_RES \*result)**  
//result--保存到本地的结果集地址  
//返回值：实际上是一个char \*\*的指针，将每一条数据做成了字符串指针数组 row\[0\]-第0列 row\[1\]-第1列  
//并且这个接口会保存当前读取结果位置，每次获取的都是下一条数据

**释放结果集**

**void mysql\_free\_result(MYSQL\_RES \*result)**  
//result--保存到本地的结果集地址  
//返回值：void

**关闭连接，销毁句柄**

**void mysql\_close(MYSQL \*mysql)**

**获取sql最近一次操作失败的原因**

**const char \*mysql\_error(MYSQL \*mysql)**

**测试：**

#include<iostream>
    #include<string>
    #include<mutex>
    #include<mysql/mysql.h>
    #include<jsoncpp/json/json.h>
    
    namespace order_sys
    {
    #define mysql_server "127.0.0.1"
    #define mysql_user "root"  
    #define mysql_name "order_sys"
    
      static MYSQL* MysqlInit()
      {
        //mysql初始化
        //1初始化句柄
        MYSQL* mysql=NULL;
        mysql=mysql_init(NULL);
        if(mysql==NULL)
        {
          std::cout<<"mysql init failed\n";
        }
        //2连接服务器 
        if(mysql_real_connect(mysql,mysql_server,mysql_user,NULL,mysql_name,0,NULL,0)==NULL)
        {
          std::cout<<mysql_error(mysql)<<std::endl;
          return NULL;
        }
        //3设置字符集
        if(mysql_set_character_set(mysql,"utf8")!=0)
        {
          std::cout<<mysql_error(mysql)<<std::endl;
          return NULL;
        }
        //4选择数据库
        if(mysql_select_db(mysql, mysql_name)!=0)
        {
          std::cout<<mysql_error(mysql)<<std::endl;
          return NULL;
        }
        return mysql;
      }
      static void MysqlRelease(MYSQL * mysql)
      {
        //mysql销毁
        if(mysql!=NULL)
        {
          mysql_close(mysql);
        }
        return;
      }
      static bool MysqlQuery(MYSQL *mysql,const std::string &sql)
      {
        if(mysql_query(mysql,sql.c_str())!=0)
        {
          std::cout<<sql<<std::endl;
          std::cout<<mysql_error(mysql)<<std::endl;
          return false;
        }
        return true;
      }
    
      class TableDish{
        private:
          MYSQL* _mysql;
          std::mutex _mutex;
        public:
          TableDish()
          {
            _mysql=MysqlInit();
            if(_mysql==NULL)
            {
              exit(-1);
            }
          }
          ~TableDish()
          {
            MysqlRelease(_mysql);
            _mysql=NULL;
          }
          bool Insert(const Json::Value &dish)
          {
            //组织sql语句
    #define DISH_INSERT "insert tb_dish values(null,'%s',%d,now());"
            char str_sql[4096]={0};//初始化一块内存存放按照一定形式组织的字符串
            sprintf(str_sql,DISH_INSERT,dish["name"].asCString(),dish["price"].asInt());
            //执行sql语句
            return MysqlQuery(_mysql,str_sql);
          }
          bool Delete(int dish_id)
          {
    #define DISH_DELETE "delete from tb_dish where id=%d;"
            char str_sql[4096]={0};
            sprintf(str_sql,DISH_DELETE,dish_id);
            return MysqlQuery(_mysql,str_sql);
          }
          bool Update(const Json::Value &dish)
          {
    #define DISH_UPDATE "update tb_dish set name='%s',price=%d where id=%d;"
            char str_sql[4096]={0};
            sprintf(str_sql,DISH_UPDATE,dish["name"].asCString(),dish["price"].asInt(),dish["id"].asInt());
            return MysqlQuery(_mysql,str_sql);
          }
          bool SelectAll(Json::Value *dishes)
          {
    #define DISH_SELECT_ALL "select* from tb_dish;"
            _mutex.lock();
            bool ret=MysqlQuery(_mysql,DISH_SELECT_ALL);
            if(ret==false)
            {
              _mutex.unlock();
              return false;
            }
            MYSQL_RES *res=mysql_store_result(_mysql);
            _mutex.unlock();
            if(res==NULL)
            {
              std::cout<<"store result failed\n";
              return false;
            }
            int num=mysql_num_rows(res);
            for(int i=0;i<num;i++)
            {
              MYSQL_ROW row=mysql_fetch_row(res);
              Json::Value dish;
              dish["id"]=std::stoi(row[0]);
              dish["name"]=row[1];
              dish["price"]=std::stoi(row[2]);
              dish["ctime"]=row[3];
              dishes->append(dish);
            }
            mysql_free_result(res);
            return true;
          }
          bool SelectOne(int dish_id,Json::Value *dish)
          {
    #define DISH_SELECT_ONE "select* from tb_dish where id=%d;"
            char str_sql[4096]={0};
            sprintf(str_sql,DISH_SELECT_ONE,dish_id);
            _mutex.lock();
            bool ret=MysqlQuery(_mysql,str_sql);
            if(ret==false)
            {
              _mutex.unlock();
              return false;
            }
            MYSQL_RES *res=mysql_store_result(_mysql);
            _mutex.unlock();
            if(res==NULL)
            {
              std::cout<<"store result failed\n";
              return false;
            }
            int num=mysql_num_rows(res);
            if(num!=1)
            {
              std::cout<<"select error\n";
              mysql_free_result(res);
              return false;
            }
              MYSQL_ROW row=mysql_fetch_row(res);
              (*dish)["id"]=std::stoi(row[0]);
              (*dish)["name"]=row[1];
              (*dish)["price"]=std::stoi(row[2]);
              (*dish)["ctime"]=row[3];
          mysql_free_result(res);
          return true;
          }
      };
    
      class TableOrder{
        private:
          MYSQL* _mysql;
          std::mutex _mutex;
        public:
          TableOrder()
          {
            _mysql=MysqlInit();
            if(_mysql==NULL)
            {
              exit(-1);
            }
          }
          ~TableOrder()
          {
            MysqlRelease(_mysql);
            _mysql=NULL;
          }
    
          bool Insert(const Json::Value &order)
          {
            //组织sql语句
    #define ORDER_INSERT "insert tb_order values(null,'%s',0,now());"
            char str_sql[4096]={0};//初始化一块内存存放按照一定形式组织的字符串
            Json::FastWriter writer;
            std::string dishes=writer.write(order["dishes"]);//序列化 json转string
            sprintf(str_sql,ORDER_INSERT,dishes.c_str());
            //执行sql语句
            return MysqlQuery(_mysql,str_sql);
           }
          bool Delete(int order_id)
          {
    #define DISH_ORDER "delete from tb_order where id=%d;"
            char str_sql[4096]={0};
            sprintf(str_sql,DISH_ORDER,order_id);
            return MysqlQuery(_mysql,str_sql);
          }
          bool Update(const Json::Value &order)
          {
    #define ORDER_UPDATE "update tb_order set dishes='%s',status=%d where id=%d;"
            Json::FastWriter writer;
            std::string dishes=writer.write(order["dishes"]);//序列化  json转string
            char str_sql[4096]={0};
            sprintf(str_sql,ORDER_UPDATE,dishes.c_str(),order["status"].asInt(),order["id"].asInt());
            return MysqlQuery(_mysql,str_sql);
          }
          bool SelectAll(Json::Value *orderes)
          {
    #define ORDER_SELECT_ALL "select* from tb_order;"
            _mutex.lock();
            bool ret=MysqlQuery(_mysql,ORDER_SELECT_ALL);
            if(ret==false)
            {
              _mutex.unlock();
              return false;
            }
            MYSQL_RES *res=mysql_store_result(_mysql);
            _mutex.unlock();
            if(res==NULL)
            {
              std::cout<<"store result failed\n";
              return false;
            }
            int num=mysql_num_rows(res);
            for(int i=0;i<num;i++)
            {
              MYSQL_ROW row=mysql_fetch_row(res);
              Json::Value order;
              order["id"]=std::stoi(row[0]);
              Json::Value tmp;
              Json::Reader reader;
              reader.parse(row[1],tmp);//序列化 将json格式字符串存储为json对象
              order["dishes"]=tmp;
              order["status"]=std::stoi(row[2]);
              order["ctime"]=row[3];
              orderes->append(order);
            }
            mysql_free_result(res);
    
          }
          bool SelectOne(int order_id,Json::Value *order)
          {
    #define ORDER_SELECT_ONE "select* from tb_order where id=%d;"
            char str_sql[4096]={0};
            sprintf(str_sql,ORDER_SELECT_ONE,order_id);
            _mutex.lock();
            bool ret=MysqlQuery(_mysql,str_sql);
            if(ret==false)
            {
              _mutex.unlock();
              return false;
            }
            MYSQL_RES *res=mysql_store_result(_mysql);
            _mutex.unlock();
            if(res==NULL)
            {
              std::cout<<"store result failed\n";
              return false;
            }
            int num=mysql_num_rows(res);
            if(num!=1)
            {
              std::cout<<"select error\n";
              mysql_free_result(res);
              return false;
            }
              MYSQL_ROW row=mysql_fetch_row(res);
              (*order)["id"]=std::stoi(row[0]);
              Json::Value tmp;
              Json::Reader reader;
              reader.parse(row[1],tmp);//序列化 将json格式字符串存储为json对象
              (*order)["dishes"]=tmp;
              (*order)["status"]=std::stoi(row[2]);
              (*order)["mtime"]=row[3];
          mysql_free_result(res);
          return true;
          }
      };
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 8][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2021061719222713.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 1]: /images/20221005/0e2bf8a6546947c6afe9d6736cf95704.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 2]: /images/20221005/cbdb52845f4341f39ad27cc1fac6e6b0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 3]: /images/20221005/87a99837fc3b4c2a8871247bf9e62c2a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 4]: /images/20221005/5c6aafbcd8b44118a103c6a691bf155a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 5]: /images/20221005/b8fb447547314e819325ee1b183aab89.png
[2021061311575921.png]: /images/20221005/7cbe98cdc442450c96d6bbe13fb697c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 6]: /images/20221005/946524b71c7f4364ade5013643f947a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 7]: /images/20221005/c4fabd32da424088b4addd4a15847873.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 8]: /images/20221005/064b3c5cd309445080fca709cd48ecb7.png