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

Posted 2021-07-16 AllenSquirrel

数据管理模块：

数据存储：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；

• 表的操作：

(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自增属性（只能用于整型主键字段）

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

新增：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;

测试：

数据库操作流程：

初始化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;
      }
  };
}