sql_query1.hh
上传用户:clovervx
上传日期:2010-03-30
资源大小:787k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. #ifndef __sql_query_1_hh
  2. #define __sql_query_1_hh
  3. #include <strstream>
  4. #include <vector>
  5. #include <map>
  6. using namespace std;
  7. #include "define_short.h"
  8. #include "sql_query0.hh"
  9. #include "sql_string1.hh"
  10. class Query;
  11. class SQLQuery;
  12. //! with_class = SQLQuery
  13. //: Exception thrown when not enough parameters are provided
  14. // Thrown when not enough parameters are provided for a 
  15. // template query.
  16. struct SQLQueryNEParms {
  17.   SQLQueryNEParms(const char *c) : error(c) {}
  18.   const char* error; //:
  19. };
  20. //: This class holds the parameter values for filling template queries. 
  21. // It is a subclass of a vector of *SQLStrings*.
  22. class SQLQueryParms : public vector<SQLString> {
  23.   friend Query;
  24. private:
  25.   typedef const SQLString&      ss;
  26.   SQLQuery                 *parent;
  27. public:
  28.   SQLQueryParms () : parent(NULL) {} 
  29.   SQLQueryParms (SQLQuery *p) : parent(p) {}
  30.   bool  bound() {return parent;}
  31.   void               clear() {erase(begin(),end());} //: Clears the list
  32.   SQLString &operator [] (size_type n) {
  33.     if (n >= size()) insert(end(),(n+1) - size(), "");
  34.     return vector<SQLString>::operator [] (n);
  35.   } //: Access element number n
  36.   const SQLString &operator [] (size_type n) const 
  37.     {return vector<SQLString>::operator [] (n);}     
  38.   //: Access element number n
  39.   SQLString &operator [] (const char *str); 
  40.   //: Access the value of the element with a key of str.
  41.   const SQLString &operator [] (const char *str) const; 
  42.   //: Access the value of the element with a key of str.
  43.   SQLQueryParms &operator << (const SQLString &str)
  44.     {push_back(str);return *this;}  //: Adds an element to the list
  45.   SQLQueryParms &operator += (const SQLString &str)
  46.     {push_back(str);return *this;}  //: Adds an element to the list
  47.   SQLQueryParms operator + (const SQLQueryParms &other) const;
  48.   //!dummy: void set (ss a, [ss b] ,... , [ss l]);
  49.   //: Set the elements.
  50.   // Sets element 0 to a, element 1 to b, etc. May specify up to a dozen elements
  51.   void set (ss a)
  52.     {clear(); *this << a;}
  53.   void set (ss a, ss b)
  54.     {clear(); *this << a << b;}
  55.   void set (ss a, ss b, ss c)
  56.     {clear(); *this << a << b << c;}
  57.   void set (ss a, ss b, ss c, ss d)
  58.     {clear(); *this << a << b << c << d;}
  59.   void set (ss a, ss b, ss c, ss d, ss e)
  60.     {clear(); *this << a << b << c << d << e;}
  61.   void set (ss a, ss b, ss c, ss d, ss e, ss f)
  62.     {clear(); *this << a << b << c << d << e << f;}
  63.   void set (ss a, ss b, ss c, ss d, ss e, ss f, ss g)
  64.     {clear(); *this << a << b << c << d << e << f << g;}
  65.   void set (ss a, ss b, ss c, ss d, ss e, ss f, ss g, ss h)
  66.     {clear(); *this << a << b << c << d << e << f << g << h;}
  67.   void set (ss a, ss b, ss c, ss d, ss e, ss f, ss g, ss h, ss i)
  68.     {clear(); *this << a << b << c << d << e << f << g << h << i;}
  69.   void set (ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h,ss i,ss j)
  70.     {clear(); *this <<a <<b <<c <<d <<e <<f <<g <<h <<i <<j;}
  71.   void set (ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h,ss i,ss j,ss k)
  72.     {clear(); *this <<a <<b <<c <<d <<e <<f <<g <<h <<i <<j <<k;}
  73.   void set (ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h,ss i,ss j,ss k,ss l)
  74.     {clear(); *this <<a <<b <<c <<d <<e <<f <<g <<h <<i <<j <<k <<l;}
  75. };
  76. //:
  77. enum query_reset {DONT_RESET, RESET_QUERY};
  78. struct SQLParseElement {
  79.   SQLParseElement(string b, char o, char n) : before(b),option(o),num(n) {}
  80.   string before;
  81.   char   option;
  82.   char   num;
  83. };
  84. //! with_class = Query
  85. //: The "pure" query class 
  86. // This is the "pure" query class. It is used to form queries to send
  87. // to the *Connection* object. The *Query* class can be used if you
  88. // wish to also be able to execute the queries without having to send
  89. // them to the *Connection* object.
  90. //
  91. // This class is subclassed from *strstream*. This means that you can
  92. // write to it like a stream to avoid having to piece parts together
  93. // by creating you own *strstream* or by using *sprintf*. Although you
  94. // can read from query because it is a stream this is _not_
  95. // recommended. I can not guarantee the predictability of the class if
  96. // you do and will offer no help if you run into problems when you do
  97. // this. However, fell free to use any of the stream methods to write
  98. // to it. Just make sure that the write buffer points to the end of
  99. // your query before you try to use any of the *SQLQuery* specific
  100. // methods except for *error()* and *success()*.
  101. class SQLQuery : public strstream { 
  102.   friend SQLQueryParms; 
  103. private:
  104.   char* preview_char();
  105. protected:
  106.   bool    Success;
  107.   char*   errmsg;
  108.   vector<SQLParseElement> parsed;
  109.   vector<string>          parsed_names;
  110.   map<string,int>         parsed_nums;
  111.   typedef  const SQLString&  ss;
  112.   typedef  SQLQueryParms  parms;
  113.   void     proc(parms &p);
  114. public:
  115.   SQLQuery(): Success(false), errmsg(NULL), def(this) {} //:
  116.   SQLQuery(const SQLQuery &q); //:
  117.   SQLQuery& operator = (const SQLQuery &q); //:
  118.   SQLQueryParms def; //: The default template parameters set. 
  119.   void     parse();  
  120.   string   error () const {return errmsg;}
  121.   bool     success() const {return Success;}
  122.   operator bool () {return success();}
  123.   bool operator !    () {return !success();}
  124.   //!dummy: string str (query_reset r = DONT_RESET);
  125.   //: Returns the full query string.
  126.   // Returns the full query string, replacing it with the default
  127.   // template parameters if necessary. *query_reset* can either be
  128.   // DONT_RESET or RESET_QUERY. If it is set the RESET_QUERY then
  129.   // reset() is called after it has finished returning the query. If
  130.   // there is not enough  parameters then it will return a
  131.   // empty string and *success()* would be false.
  132.   //!dummy: string str (const SQLString &parm0, ...,const SQLString &parm11);
  133.   //: Like str(query_reset) but sets the parameters.
  134.   // Like str(query_reset) but sets query parameters 0 to (up to)
  135.   // 11. To parm0, parm1 etc. This is archived by overloaded methods
  136.   // and templates and not the ...
  137.   //
  138.   // It will combine this with def. If any of the required parameters
  139.   // are null it will produce an error and return an empty string.
  140.   //!dummy: string str(const SQLQueryParms & p, query_reset r = DONT_RESET);
  141.   //: Like *str(query_reset)* but sets the parameter.
  142.   // Like *query(query_reset res)* but sets the parameters based on
  143.   // combining p and def.
  144.   //
  145.   // If any of the required parameters are null it will produce an
  146.   // error and return an empty string.
  147.   void     reset (); //: Resets the query. 
  148.   // This means erasing the string and the default template parameters. 
  149.   template <class T> SQLQuery& update(const T &o, const T &n) {
  150.     reset();
  151.     *this << "UPDATE " << o.table() << " SET " << n.equal_list() 
  152.           << " WHERE " << o.equal_list(" AND ", sql_use_compare);
  153.     return *this;
  154.   } //:
  155.   template <class T> SQLQuery& insert(const T &v) {
  156.     reset();
  157.     *this << "INSERT INTO " << v.table() << " (" << v.field_list()
  158.           << ") VALUES (" << v.value_list() << ")";
  159.     return *this;
  160.   } //:
  161.   template <class T> SQLQuery& replace(const T &v) {
  162.     reset();
  163.     *this << "REPLACE INTO " << v.table() << " (" << v.field_list()
  164.           << ") VALUES (" << v.value_list() << ")";
  165.     return *this;
  166.   } //:
  167.   mysql_query_define_const1(string,str)
  168. };  
  169. #endif