Chinaunix首页 | 论坛 | 博客

大道之行，天下为公litanhua.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

litanhua_

  • 博客访问： 87499
  • 博文数量： 19
  • 博客积分： 487
  • 博客等级： 下士
  • 技术积分： 205
  • 用 户 组： 普通用户
  • 注册时间： 2011-03-18 15:57
文章分类

全部博文（19）

文章存档

2011年（19）

我的朋友
最近访客
推荐博文
相关博文
SQLite serverlist 封装

分类： Mysql/postgreSQL

2011-03-24 11:10:46

SQLite.hpp
  1. #ifndef _SQLITE_H
  2. #define _SQLITE_H

  4. #include <stdio.h>
  5. #include <unistd.h>
  6. #include <sqlite3.h>
  7. #include <strings.h>
  8. #include <string.h>
  9. #include <iostream>
  10. #include <sstream>
  11. #include "daemon.hpp"
  12. #include "Base64.hpp"

  14. #include <map>
  15. #include <set>
  16. #include <vector>


  19. using namespace std;
  20. using namespace PWRD;
  21. using namespace PWRD::Marshal;

  23. namespace PWRD{
  24.     namespace SQL{
  25. #define CLIENT_PORT 11180
  26.         typedef struct sqlite3 * Connection;    
  27.         typedef struct sqlite3_stmt * Statement;
  28.         typedef vector<string> Vector;
  29.         typedef map<int, Vector> AddrMap;
  30.         typedef set<Vector> ResultSet;

  32.         class SQLite{
  33.             public:
  34.                 static SQLite* get_instance(const char *);
  35.                 static AddrMap & lookup();
  36.                 static ResultSet & qurey(string ip, int port);
  37.                 static int update(string ip, int port, string file, long offset = 0);
  38.                 static int record(string ip, int port, string file, string chars);
  39.                 static int config(string ip, int port, string file, string conf);
  40.                 static bool status();
  41.             private:
  42.                 SQLite();
  43.                 int connect(const char *);    
  44.                 int disconnect();
  45.                 static SQLite *instance_;
  46.                 static AddrMap addr_map_;
  47.                 static Connection conn_;
  48.                 static Statement stmt_;
  49.                 static ResultSet result_set_;
  50.                 static bool status_;
  51.                 static string dbs_;
  52.         };


  55.     };
  56. };
  57. #endif

SQLite.cpp

 

  1. #include "SQLite.hpp"
  2. namespace PWRD{
  3.     namespace SQL{
  4.         //----------------------------------------------------------------------------

  6.         //Private

  8.         //----------------------------------------------------------------------------

  10.         AddrMap SQLite::addr_map_;
  11.         ResultSet SQLite::result_set_;
  12.         Connection SQLite::conn_;
  13.         Statement SQLite::stmt_;
  14.         string SQLite::dbs_;
  15.         SQLite * SQLite::instance_ = NULL;
  16.         bool SQLite::status_ = false;

  18.         SQLite * SQLite::get_instance(const char *db){

  20.             if(NULL == instance_){
  21.                 instance_ = new SQLite();    
  22.             }        

  24.             instance_->connect(db);

  26.             return instance_;
  27.         }

  29.         SQLite::SQLite(){
  30.         
  31.         }
  32.         
  33.         int SQLite::connect(const char * db){
  34.             dbs_ = "configure";
  35.             if(NULL == db){
  36.                 db = dbs_.c_str();            
  37.             }    

  39.             if(SQLITE_OK != sqlite3_open(db, &conn_)){
  40.                 logs.write_log(DEBUG, "Connect to sqlite3 failed");    
  41.                 status_ = false;
  42.                 return -1;
  43.             }

  45.             status_ = true;
  46.             return 1;
  47.         }
  48.         int SQLite::disconnect(){
  49.             sqlite3_close(conn_);
  50.             status_ = false;
  51.             return 1;

  53.         }

  55.         //----------------------------------------------------------------------------

  57.         //Public

  59.         //----------------------------------------------------------------------------

  61.         AddrMap & SQLite::lookup(){

  63.             //clear the map

  65.             addr_map_.erase(addr_map_.begin(), addr_map_.end());
  66.             char * sql = "select * from configs";        
  67.             char *pzTail;

  69.             if (SQLITE_OK != sqlite3_prepare(conn_, sql, strlen(sql), &stmt_, (const char **)&pzTail)){
  70.                 logs.write_log(NORMAL, "SQLite sql: %s", sql);    
  71.                 return addr_map_;
  72.             }

  74.             int row = 0, step = 0, column_size = 0;
  75.             while(1){
  76.                 switch (sqlite3_step(stmt_))
  77.                 {
  78.                     case SQLITE_ROW:
  79.                         logs.write_log(DEBUG, "SQLITE_ROW ");
  80.                         break;
  81.                     case SQLITE_BUSY:
  82.                         logs.write_log(DEBUG, "SQLITE_BUSY ");
  83.                         goto ERR;
  84.                     case SQLITE_MISUSE:
  85.                         logs.write_log(DEBUG, "SQLITE_MISUSE ");
  86.                         goto ERR;
  87.                     case SQLITE_ERROR:
  88.                         logs.write_log(DEBUG, "SQLITE_ERROR ");
  89.                         goto ERR;
  90.                     case SQLITE_DONE:
  91.                         logs.write_log(DEBUG, "SQLITE_DONE ");
  92.                         goto END;
  93.                     default:
  94.                         goto ERR;
  95.                 }


  98.                 if(0 == row){
  99.                     column_size = sqlite3_column_count(stmt_);
  100.                     logs.write_log(NORMAL, "Lookup %d columns", column_size);
  101.                 }


  104.                 const char *result;
  105.                 Vector vect;
  106.                 step = 0;
  107.                 while(step < column_size){
  108.                     result = (const char*)sqlite3_column_text(stmt_, step);
  109.                     if(NULL == result){
  110.                         vect.push_back("");        
  111.                     }
  112.                     string value(result);
  113.                     cout << result << " " ;
  114.                     vect.push_back(value);
  115.                     step++;
  116.                 }
  117.                 addr_map_[row] = vect;    
  118.                 cout << endl;
  119.                 row++;
  120.             }//while 1

  122.             if (SQLITE_OK != sqlite3_finalize(stmt_))
  123.                 goto ERR;
  124. END:
  125.             /* 释放stmt_ 必须要释放否者内存泄漏 */
  126.             if (SQLITE_OK != sqlite3_finalize(stmt_))
  127.                 goto ERR;

  129.             //disconnect();

  131.             return addr_map_;

  133. ERR:
  134.             printf("%s\n", sqlite3_errmsg(conn_));
  135.             return addr_map_;


  138.         }

  140.         ResultSet &SQLite::qurey(string ip, int port){
  141.             //clear

  143.             result_set_.erase(result_set_.begin(), result_set_.end());
  144.             logs.write_log(DEBUG, "qurey addr:%s port:%d", ip.c_str(), port);
  145.             AddrMap::iterator iter = addr_map_.begin();
  146.             for( ; iter != addr_map_.end(); iter++){
  147.                 Vector vect = iter->second;    
  148.                 Vector result;
  149.                 if( !ip.compare(vect[1]) && port == std::atoi((vect[2]).c_str())){
  150.                     result.push_back(vect[2]);    
  151.                     result.push_back(vect[3]);    
  152.                     result.push_back(vect[4]);    
  153.                     result.push_back(vect[5]);    
  154.                     result.push_back(vect[6]);    

  156.                     //insert to result_set

  158.                     result_set_.insert(result);
  159.                 }

  161.             }
  162.             return result_set_;
  163.         }

  165.         int SQLite::update(string ip, int port, string file, long offset){
  166.             string sql = "update configs set offset = ";    
  167.             stringstream ss;
  168.             string offset_str = "";
  169.             ss << offset;
  170.             ss >> offset_str;
  171.             sql += offset_str;
  172.             sql += " where ip = \"";
  173.              sql += ip;
  174.              sql += "\" and port = ";
  175.             ss.clear();
  176.             string port_str = "";
  177.             ss << port;
  178.             ss >> port_str;
  179.          sql += port_str;
  180.          sql += " and file = \"";
  181.             sql += file;
  182.             sql += "\";";

  184.             logs.write_log(DEBUG, "update str=%s|port=%d|file=%s|offset=%d|info=begin", sql.c_str(), port, file.c_str(), offset);

  186.             char *pzTail = 0;

  188.             //update

  190.             if(sqlite3_exec(conn_, sql.c_str(), 0, 0, &pzTail)){
  191.                 goto ERR;    
  192.             }

  194.             logs.write_log(DEBUG, "update str=%s|port=%d|file=%s|offset=%d|info=end", sql.c_str(), port, file.c_str(), offset);
  195.             return 1;

  197. ERR:
  198.             logs.write_log(DEBUG, "update str=%s|port=%d|file=%s|offset=%d|info=update failed:%s", sql.c_str(), port, file.c_str(), offset, sqlite3_errmsg(conn_));
  199.             return -1;

  201.         }

  203.         int SQLite::record(string ip, int port, string file, string chars){
  204.             string sql = "update configs set chars = \"";    
  205.             sql += chars;
  206.             sql += "\" where ip = \"";
  207.             sql += ip;
  208.             sql += "\" and port = ";
  209.             stringstream ss;
  210.             string port_str = "";
  211.             ss << port;
  212.             ss >> port_str;
  213.             sql += port_str;
  214.              sql += " and file = \"";
  215.             sql += file;
  216.             sql += "\";";

  218.             logs.write_log(DEBUG, "update sql=%s|port=%d|file=%s|chars=%s|info=begin", sql.c_str(), port, file.c_str(), chars.c_str());

  220.             char *pzTail = 0;//sql.c_str();


  223.             if(sqlite3_exec(conn_, sql.c_str(), 0, 0, &pzTail)){
  224.                 goto ERR;    
  225.             }

  227.             logs.write_log(DEBUG, "update sql=%s|port=%d|file=%s|chars=%s|info=end", sql.c_str(), port, file.c_str(), chars.c_str());
  228.             return 1;

  230. ERR:
  231.             logs.write_log(DEBUG, "update sql=%s|port=%d|file=%s|chars=%s|info=update failed:%s", sql.c_str(), port, file.c_str(), chars.c_str(), sqlite3_errmsg(conn_));

  233.             return -1;

  235.         }

  237.         int SQLite::config(string ip, int port, string file, string conf){
  238.             string base64_conf = Base64::encode(reinterpret_cast<const unsigned char*>(conf.c_str()), conf.length());
  239.             string sql = "update configs set conf = \"";    
  240.             sql += base64_conf;
  241.             sql += "\" where ip = \"";
  242.             sql += ip;
  243.             sql += "\" and port = ";
  244.             stringstream ss;
  245.             string port_str = "";
  246.             ss << port;
  247.             ss >> port_str;
  248.             sql += port_str;
  249.              sql += " and file = \"";
  250.             sql += file;
  251.             sql += "\";";

  253.             logs.write_log(DEBUG, "update sql=%s|port=%d|file=%s|base64_conf=%s|info=begin", sql.c_str(), port, file.c_str(), base64_conf.c_str());

  255.             char *pzTail = 0;//sql.c_str();


  258.             if(sqlite3_exec(conn_, sql.c_str(), 0, 0, &pzTail)){
  259.                 goto ERR;    
  260.             }

  262.             logs.write_log(DEBUG, "update sql=%s|port=%d|file=%s|base64_conf=%s|info=end", sql.c_str(), port, file.c_str(), base64_conf.c_str());
  263.             return 1;

  265. ERR:
  266.             logs.write_log(DEBUG, "update sql=%s|port=%d|file=%s|base64_conf=%s|info=update failed:%s", sql.c_str(), port, file.c_str(), base64_conf.c_str(), sqlite3_errmsg(conn_));

  268.             return -1;

  270.         }


  273.         bool SQLite::status(){
  274.             return status_;
  275.         }

  277.     };

  279. };
阅读(987) | 评论(0) | 转发(0) |
0

上一篇：Boost::asio 阻塞模式的UDP客户端【很简单】

下一篇：Base64 编码解码

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6