28 #if !defined(MYSQLPP_QUERY_H) 
   29 #define MYSQLPP_QUERY_H 
   53 #  if defined(HAVE_STD_SLIST) || defined(HAVE_GLOBAL_SLIST) 
   60 #if !defined(DOXYGEN_IGNORE) 
   62 class MYSQLPP_EXPORT Connection;
 
   63 class MYSQLPP_EXPORT Transaction;
 
  128         #define MYSQLPP_DEFINE_INSERT_POLICY_TEMPLATES 
  130         #undef MYSQLPP_DEFINE_INSERT_POLICY_TEMPLATES 
  151         ulonglong affected_rows();
 
  167         size_t escape_string(std::string* ps, 
const char* original = 0,
 
  168                         size_t length = 0) 
const;
 
  191         size_t escape_string(
char* escaped, 
const char* original,
 
  192                         size_t length) 
const;
 
  204         const char* error() 
const;
 
  220         ulonglong insert_id();
 
  246         operator void*() 
const;
 
  255         bool operator !()
 const { 
return !
operator void*(); }
 
  283         std::string 
str() { 
return str(template_defaults); }
 
  317         bool exec() { 
return exec(str(template_defaults)); }
 
  330         bool exec(
const std::string& str);
 
  525         template <
typename Function>
 
  546         template <
typename Function>
 
  570         template <
class SSQLS, 
typename Function>
 
  573                 std::string query(
"select * from `");
 
  574                 query += ssqls.table();
 
  606         template <
class Sequence, 
typename Function>
 
  633         template <
class Sequence, 
class SSQLS, 
typename Function>
 
  634         Function 
store_if(Sequence& con, 
const SSQLS& ssqls, Function fn)
 
  636                 std::string query(
"select * from `");
 
  637                 query += ssqls.table();
 
  661         template <
class Sequence, 
typename Function>
 
  734         template <
class Sequence>
 
  737                 storein_sequence(con, str(template_defaults));
 
  753         template <
class Sequence>
 
  758                                 MYSQL_ROW d = result.fetch_raw_row();
 
  760                                 Row row(d, &result, result.fetch_lengths(),
 
  763                                 con.push_back(
typename Sequence::value_type(row));
 
  766                 else if (!result_empty()) {
 
  774                         if (throw_exceptions()) {
 
  795                 storein_sequence(con, str(p));
 
  808                 storein_set(con, str(template_defaults));
 
  829                                 MYSQL_ROW d = result.fetch_raw_row();
 
  831                                 Row row(d, &result, result.fetch_lengths(),
 
  834                                 con.insert(
typename Set::value_type(row));
 
  837                 else if (!result_empty()) {
 
  845                         if (throw_exceptions()) {
 
  866                 storein_set(con, str(p));
 
  887         template <
class Container>
 
  890                 storein(con, str(template_defaults));
 
  902                 storein(con, str(p));
 
  909                 storein_sequence(con, s);
 
  916                 storein_sequence(con, s);
 
  923                 storein_sequence(con, s);
 
  926 #if defined(HAVE_EXT_SLIST) 
  932                 storein_sequence(con, s);
 
  934 #elif defined(HAVE_GLOBAL_SLIST) 
  942         void storein(slist<T>& con, 
const SQLTypeAdapter& s)
 
  944                 storein_sequence(con, s);
 
  946 #elif defined(HAVE_STD_SLIST) 
  953         void storein(std::slist<T>& con, 
const SQLTypeAdapter& s)
 
  955                 storein_sequence(con, s);
 
  991                 MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
 
  992                                 "UPDATE `" << o.table() << 
"` SET " << n.equal_list() <<
 
  993                                 " WHERE " << o.equal_list(
" AND ", sql_use_compare);
 
 1010                 MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
 
 1011                                 "INSERT INTO `" << v.table() << 
"` (" <<
 
 1012                                 v.field_list() << 
") VALUES (" <<
 
 1013                                 v.value_list() << 
')';
 
 1030         template <
class Iter>
 
 1035                 if (first != last) {
 
 1038                         MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
 
 1039                                         "INSERT INTO `" << first->table() << 
"` (" <<
 
 1040                                         first->field_list() << 
") VALUES (" <<
 
 1041                                         first->value_list() << 
')';
 
 1047                         while (++it != last) {
 
 1048                                 MYSQLPP_QUERY_THISPTR << 
",(" << it->value_list() << 
')';
 
 1067         template <
class Iter, 
class InsertPolicy>
 
 1070                 bool success = 
true;
 
 1075                 if (first == last) {
 
 1079                 typename InsertPolicy::access_controller ac(*conn_);
 
 1081                 for (Iter it = first; it != last; ++it) {
 
 1082                         if (policy.can_add(
int(tellp()), *it)) {
 
 1084                                         MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
 
 1085                                                 "INSERT INTO `" << it->table() << 
"` (" <<
 
 1086                                                 it->field_list() << 
") VALUES (";
 
 1089                                         MYSQLPP_QUERY_THISPTR << 
",(";
 
 1092                                 MYSQLPP_QUERY_THISPTR << it->value_list() << 
')';
 
 1108                                 if (policy.can_add(
int(tellp()), *it)) {
 
 1109                                         MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
 
 1110                                                 "INSERT INTO `" << it->table() << 
"` (" <<
 
 1111                                                 it->field_list() << 
") VALUES (" <<
 
 1112                                                 it->value_list() << 
')';
 
 1118                                         if (throw_exceptions()) {
 
 1129                 if (success && !empty && !exec()) {
 
 1155         template <
class Iter, 
class InsertPolicy>
 
 1158                 bool success = 
true;
 
 1163                 if (first == last) {
 
 1167                 typename InsertPolicy::access_controller ac(*conn_);
 
 1169                 for (Iter it = first; it != last; ++it) {
 
 1170                         if (policy.can_add(
int(tellp()), *it)) {
 
 1172                                         MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
 
 1173                                                 "REPLACE INTO `" << it->table() << 
"` (" <<
 
 1174                                                 it->field_list() << 
") VALUES (";
 
 1177                                         MYSQLPP_QUERY_THISPTR << 
",(";
 
 1180                                 MYSQLPP_QUERY_THISPTR << it->value_list() << 
')';
 
 1196                                 if (policy.can_add(
int(tellp()), *it)) {
 
 1197                                         MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
 
 1198                                                 "REPLACE INTO `" << it->table() << 
"` (" <<
 
 1199                                                 it->field_list() << 
") VALUES (" <<
 
 1200                                                 it->value_list() << 
')';
 
 1206                                         if (throw_exceptions()) {
 
 1217                 if (success && !empty && !exec()) {
 
 1245                 MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
 
 1246                                 "REPLACE INTO `" << v.table() << 
"` (" <<
 
 1247                                 v.field_list() << 
") VALUES (" << v.value_list() << 
')';
 
 1265         template <
class Iter>
 
 1269                 if (first != last) {
 
 1272                         MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
 
 1273                                         "REPLACE INTO " << first->table() << 
" (" <<
 
 1274                                         first->field_list() << 
") VALUES (" <<
 
 1275                                         first->value_list() << 
')';
 
 1281                         while (++it != last) {
 
 1282                                 MYSQLPP_QUERY_THISPTR << 
",(" << it->value_list() << 
')';
 
 1289 #if !defined(DOXYGEN_IGNORE) 
 1294         mysql_query_define0(std::string, str)
 
 1298         mysql_query_define1(storein_sequence)
 
 1299         mysql_query_define1(storein_set)
 
 1300         mysql_query_define1(storein)
 
 1301 #endif // !defined(DOXYGEN_IGNORE) 
 1318         std::vector<SQLParseElement> parse_elems_;
 
 1322         std::vector<std::string> parsed_names_;
 
 1325         std::map<std::string, short int> parsed_nums_;
 
 1328         std::stringbuf sbuffer_;
 
 1340 inline std::ostream& operator <<(std::ostream& os, 
Query& q)
 
 1342         return os << q.
str();
 
 1348 #endif // !defined(MYSQLPP_QUERY_H) 
StoreQueryResult set type for "store" queries. 
Definition: result.h:209
Declares the SQLTypeAdapter class. 
A special std::set derivative for holding MySQL data sets. 
Definition: myset.h:71
void storein(std::deque< T > &con, const SQLTypeAdapter &s)
Specialization of storein_sequence() for std::deque. 
Definition: query.h:914
Declares the template query parameter-related stuff. 
std::string str()
Get built query as a C++ string. 
Definition: query.h:283
Function store_if(Sequence &con, const SSQLS &ssqls, Function fn)
Pulls every row in a table, conditionally storing each one in a container. 
Definition: query.h:634
void storein(std::multiset< T > &con, const SQLTypeAdapter &s)
Specialization of storein_set() for std::multiset. 
Definition: query.h:968
void storein(std::list< T > &con, const SQLTypeAdapter &s)
Specialization of storein_sequence() for std::list. 
Definition: query.h:921
void storein(std::set< T > &con, const SQLTypeAdapter &s)
Specialization of storein_set() for std::set. 
Definition: query.h:961
Declares the InsertPolicy classes. 
Function for_each(const SQLTypeAdapter &query, Function fn)
Execute a query, and call a functor for each returned row. 
Definition: query.h:526
Holds information about the result of queries that don't return rows. 
Definition: result.h:48
Function for_each(Function fn)
Execute the query, and call a functor for each returned row. 
Definition: query.h:547
Manages the connection to the database server. 
Definition: connection.h:59
void storein_set(Set &con)
Execute a query, storing the result set in an STL associative container. 
Definition: query.h:806
Defines a class for building quoted and escaped SQL text. 
StoreQueryResult set type for "use" queries. 
Definition: result.h:298
Query & insertfrom(Iter first, Iter last, InsertPolicy &policy)
Insert multiple new rows using an insert policy to control how the INSERT statements are created usin...
Definition: query.h:1068
Function store_if(Sequence &con, Function fn)
Execute the query, conditionally storing each row in a container. 
Definition: query.h:662
Declares classes for holding information about SQL query results. 
Disable exceptions in an object derived from OptionalExceptions. 
Definition: noexceptions.h:119
std::string str(const SQLTypeAdapter &arg0)
Get built query as a C++ string with template query parameter substitution. 
Definition: query.h:298
void storein(std::vector< T > &con, const SQLTypeAdapter &s)
Specialization of storein_sequence() for std::vector. 
Definition: query.h:907
void storein_set(Set &con, const SQLTypeAdapter &s)
Executes a query, storing the result rows in an STL set-associative container. 
Definition: query.h:825
void storein_sequence(Sequence &con, const SQLTypeAdapter &s)
Executes a query, storing the result rows in an STL sequence container. 
Definition: query.h:754
void storein_sequence(Sequence &con)
Execute a query, storing the result set in an STL sequence container. 
Definition: query.h:735
void storein(T &con, SQLQueryParms &p)
Store template query results into a container. 
Definition: query.h:900
Manages rows from a result set. 
Definition: row.h:63
Declares the MySQL++-specific exception classes. 
Query & replace(const T &v)
Insert new row unless there is an existing row that matches on a unique index, in which case we repla...
Definition: query.h:1241
Interface allowing a class to have optional exceptions. 
Definition: noexceptions.h:71
bool exec()
Execute a built-up query. 
Definition: query.h:317
Function for_each(const SSQLS &ssqls, Function fn)
Run a functor for every row in a table. 
Definition: query.h:571
Function store_if(Sequence &con, const SQLTypeAdapter &query, Function fn)
Execute a query, conditionally storing each row in a container. 
Definition: query.h:607
Query & replacefrom(Iter first, Iter last, InsertPolicy &policy)
Replace multiple new rows using an insert policy to control how the REPLACE statements are created us...
Definition: query.h:1156
void storein_set(Set &con, SQLQueryParms &p)
Execute template query using given parameters, storing the results in a set type container. 
Definition: query.h:864
SQLQueryParms template_defaults
The default template parameters. 
Definition: query.h:1306
Exception thrown when an insert policy is too strict to create a valid INSERT statement. 
Definition: exceptions.h:456
Query & insert(Iter first, Iter last)
Insert multiple new rows. 
Definition: query.h:1031
Query & replace(Iter first, Iter last)
Insert multiple new rows, or replace existing ones if there are existing rows that match on key field...
Definition: query.h:1266
void storein(Container &con)
Execute a query, and store the entire result set in an STL container. 
Definition: query.h:888
Query & update(const T &o, const T &n)
Replace an existing row's data with new data. 
Definition: query.h:984
Declares the classes for holding row data from a result set. 
This file includes top-level definitions for use both internal to the library, and outside it...
Query & insert(const T &v)
Insert a new row. 
Definition: query.h:1006
This class holds the parameter values for filling template queries. 
Definition: qparms.h:48
Exception thrown when something goes wrong in processing a "use" query. 
Definition: exceptions.h:254
Converts many different data types to strings suitable for use in SQL queries. 
Definition: stadapter.h:73
void storein_sequence(Seq &con, SQLQueryParms &p)
Execute template query using given parameters, storing the results in a sequence type container...
Definition: query.h:793
A class for building and executing SQL queries. 
Definition: query.h:121
Declares the Transaction class. 
Declares interface that allows exceptions to be optional. 
Row fetch_row() const 
Returns the next row in a "use" query's result set. 
Definition: result.cpp:166