Mysql++学习（五）------专用SQL结构

专用SQL结构(SSQLS) 特性可以让你很轻易的定义用来匹配SQL表的C++结构.最通俗的理解：对于SQL表中的每一个字段，SSQLS结构都有一个变量与之对应.但是，MySQL++内部也会使用SSQLS的其他方法，操作符来提供简洁的功能.

要定义SSQLSes，需要使用定义在ssqls.h中的宏，这也是MySQL++唯一没有自动加入mysql++.h的头文件.

sql_create

假如你有如下SQL表

CREATE TABLE stock (
    item CHAR(30) NOT NULL,
    num BIGINT NOT NULL,
    weight DOUBLE NOT NULL,
    price DECIMAL(6,2) NOT NULL,
    sdate DATE NOT NULL,
    description MEDIUMTEXT NULL)

你可以定义一个对应的C++结构如下

sql_create_6(stock, 1, 6,
    mysqlpp::sql_char, item,
    mysqlpp::sql_bigint, num,
    mysqlpp::sql_double, weight,
    mysqlpp::sql_decimal, price,
    mysqlpp::sql_date, sdate,
    mysqlpp::Null<mysqlpp::sql_mediumtext>, description)

stock结构声明有着相同名字的数据成员对应SQL的每一列，同时该结构还包含一些成员函数，操作符以及隐藏数据成员.

sql_create_# call调用中,字段名称前面的是C++数据类型.

有时候你必须使用MySQL++的特殊数据类型来对应数据结构，考虑description字段的类型，MySQL++的 sql_mediumtext类型就是std::string的一个等价.

通常结构如下：

sql_create_#(NAME, COMPCOUNT, SETCOUNT, TYPE1, ITEM1, ... TYPE#, ITEM#)

“#”是变量的数量，“NAME”是你希望创建的结构名称，“TYPEx”是变量类型，“ITEMx”是变量名称.

SSQLS对比和初始化

 sql_create_#添加了一些成员函数和操作来支持SSQLS对象之间的比较,COMPCOUNT数量表示用来比较的字段的个数，上面例子中为1，意味着只比较item字段，将主键放到最前面并且指定比较个数，可以很好利用这一特性.sql_create_#创建的第二个参数是SETCOUNT,如果非0，它将增加一个构建函数和一个set()成员函数，该函数接受指定参数来设置结构第N个字段的值.

sql_create_6(stock, 1, 2,
    mysqlpp::sql_char, item,
    mysqlpp::sql_bigint, num,         
    mysqlpp::sql_double, weight,  
    mysqlpp::sql_decimal, price,  
    mysqlpp::sql_date, sdate,
    mysqlpp::Null<mysqlpp::sql_mediumtext>, description)
    
stock foo("Hotdog", 52);

COMPCOUNT 和SETCOUNT 的值不可以相等，如果相等，会导致产生参数列表相同的两个构建函数.

查询数据

mysqlpp::Query query = conn.query("select item, description from stock");
vector<stock> res;
query.storein(res);

for(auto i = res.begin(); i != res.end(); i++)
{
    cout << i->item << '	' ;
    cout << i->description << endl;
}

在定义了SSQLS结构后，可以直接将查询结构放入相应容器，进行各种操作.

增加数据

//create a stock object
stock new_row(
         "Hot dog", 100, 1.5, 130, mysqlpp::sql_date("2014-11-30"), mysqlpp::null
     );
//execute a query
mysqlpp::Query query = conn.query();
query.insert(new_row);
        
cout << "Query: " << query << endl;
query.execute();

首先，创建一个要插入的SSQLS对象，然后，创建查询对象，最后执行

批量插入也很容易，只要加一个循环即可

vector<stock> lots_of_stuff;
...populate the vector somehow...
query.insert(lots_of_stuff.begin(), lots_of_stuff.end()).execute();

 MySQL对于SQL查询长度有所限制，默认最大为1M.因此，使用insert批量插入时，容器中的查询长度可能超过限制.

在这种情况下使用Query::insertfrom(),它是INSERT和execute()的组合.

mysqlpp::Query::MaxPacketInsertPolicy<> insert_policy(1000);
query.insertfrom(stock_vector.begin(), stock_vector.end(),
insert_policy);

它采用最大包策略，该例中指定一个查询最大为1000，它会自动检测查询是否超过限制，然后分割执行查询.

还有两个策略类：MaxPacketInsertPolicy和RowCountInsertPolicy，它们都提供了在查询长度在一定范围类的策略方法，如果不适用，也可以研究下lib/insertpolicy.*，然后自己写策略类.策略类本质都是些类模板.

修改数据

//execute a query
mysqlpp::Query query = conn.query("select * from stock ");
query << "where item = " << mysqlpp::quote << "abc";
//get query result in a storeResult
mysqlpp::StoreQueryResult res = query.store();
if(res)
{
        stock row = res[0];
        stock orig_row = row;
        row.item = "hamburger";
        query.update(orig_row, row);
        cout << "Query : " << query <<endl;
        query.execute();
}

首先取出要修改的记录，然后修改相应字段，再用新字段代替原字段，执行替换操作.

用关联容器来存放SSQLS

//execute a query
mysqlpp::Query query = conn.query("select * from stock ");
//get query result in a storeResult
set<stock> res;
query.storein(res);
if(res.size())
{
       for(auto i = res.begin(); i != res.end(); ++i)
       {
            cout << i->item.c_str() << '	' << i->num << '	' << i->price << endl;
       }
}

改变表名

默认情况下，数据库表和SSQLS结构拥有相同的表名称.你也可以用如下方法全局修改查询中使用的表名.

stock::table("MyStockData");

也可以修改每个实例中的表名

stock s;
s.instance_table("AlternateTable");

在多个模块中使用SSQLS

// File my_ssqls.h:
#if !defined(EXPAND_MY_SSQLS_STATICS)
#   define MYSQLPP_SSQLS_NO_STATICS
#endif
sql_create_X(Y, Z....) // the SSQLS definition

// File foo.cpp, a mere user of the SSQLS:
#include "my_ssqls.h"

// File my_ssqls.cpp, which owns the SSQLS:
#define EXPAND_MY_SSQLS_STATICS
#include "my_ssqls.h"

利用SSQLS的内部构件

sql_create宏为每个SSQLS定义了一些有用的方法，这些方法大多用于库内部，以下伪码展示了一些用法.

// Basic form
template <class Manip>   
stock_value_list<Manip> value_list(cchar *d = ",",
  Manip m = mysqlpp::quote) const;  

template <class Manip>   
stock_field_list<Manip> field_list(cchar *d = ",",   
  Manip m = mysqlpp::do_nothing) const;  

template <class Manip>   
stock_equal_list<Manip> equal_list(cchar *d = ",",
  cchar *e = " = ", Manip m = mysqlpp::quote) const;  


// Boolean argument form
template <class Manip>
stock_cus_value_list<Manip> value_list([cchar *d, [Manip m,] ]   
  bool i1, bool i2 = false, ... , bool i5 = false) const;  

// List form  
template <class Manip>
stock_cus_value_list<Manip> value_list([cchar *d, [Manip m,] ]  
  stock_enum i1, stock_enum i2 = stock_NULL, ...,
  stock_enum i5 = stock_NULL) const;  

// Vector form  
template <class Manip>
stock_cus_value_list<Manip> value_list([cchar *d, [Manip m,] ]  
  vector<bool> *i) const;  

...Plus the obvious equivalents for field_list() and equal_list()

下面例子演示通过查询的一条记录来构建一个查询

在C++和SQL中使用不同的字段名称

sql_create_complete_5(stock, 1, 5,   
    mysqlpp::sql_char, m_sItem, "item",
    mysqlpp::sql_bigint, m_nNum, "num",
    mysqlpp::sql_double, m_fWeight, "weight",
    mysqlpp::sql_decimal, m_fPrice, "price",
    mysqlpp::sql_date, m_Date, "sdate")

继承自一个SSQLS

sql_create_2(
  Base, 1, 2,
  mysqlpp::sql_varchar, a,
  mysqlpp::sql_int, b
);

class Derived : public Base
{
public:
  // default constructor[14]
  Derived() :
  Base()
  {
  }

  // for-comparison constructor[15]
  Derived(const mysqlpp::sql_varchar& _a) :
  Base(_a)
  {
  }

  // full creation constructor
  Derived(const mysqlpp::sql_varchar& _a, const mysqlpp::sql_int& _b) :
  Base(_a, _b)
  {
  }

  // population constructor[16]
  Derived(const mysqlpp::Row& row) :
  Base(row)
  {
  }

  // functionality added to the SSQLS through inheritance
  bool do_something_interesting(int data);
};