MySQL++ Reference Manual

Main Page Namespace List Class Hierarchy Compound List File List Namespace Members Compound Members File Members

# mysqlpp Namespace Reference

## Compounds
class | BadConversion
| Exception thrown when a bad type conversion is attempted. More...
class | BadFieldName
| Exception thrown when a requested named field doesn't exist. More...
class | BadNullConversion
| Exception thrown when you attempt to convert a SQL null to an incompatible type. More...
class | BadOption
| Exception thrown when you pass an unrecognized option to Connection::set_option(). More...
class | BadParamCount
| Exception thrown when not enough query parameters are provided. More...
class | BadQuery
| Exception thrown when MySQL encounters a problem while processing your query. More...
class | BasicLock
| Trivial Lock subclass, using a boolean variable as the lock flag. More...
class | ColData_Tmpl
| Template for string data that can convert itself to any standard C data type. More...
class | Connection
| Manages the connection to the MySQL database. More...
class | ConnectionFailed
| Exception thrown when there is a problem establishing the database server connection. It's also thrown if Connection::shutdown() fails. More...
class | const_string
| Wrapper for `const char*` to make it behave in a way more useful to MySQL++. More...
class | const_subscript_container
| A base class that one derives from to become a random access container, which can be accessed with subscript notation. More...
struct | cstr_equal_to
| Function object that returns true if one const char* is equal to another. More...
struct | cstr_greater
| Function object that returns true if one const char* is lexically "greater than" another. More...
struct | cstr_greater_equal
| Function object that returns true if one const char* is lexically "greater than or equal to" another. More...
struct | cstr_less
| Function object that returns true if one const char* is lexically "less than" another. More...
struct | cstr_less_equal
| Function object that returns true if one const char* is lexically "less than or equal to" another. More...
struct | cstr_not_equal_to
| Function object that returns true if one const char* is not equal to another. More...
struct | Date
| C++ form of MySQL's DATE type. More...
struct | DateTime
| C++ form of MySQL's DATETIME type. More...
class | DBSelectionFailed
| Exception thrown when the program tries to select a new database and the server refuses for some reason. More...
struct | DTbase
| Base class template for MySQL++ date and time classes. More...
class | EndOfResults
| Exception thrown when ResUse::fetch_row() walks off the end of a use-query's result set. More...
class | EndOfResultSets
| Exception thrown when Query::store_next() walks off the end of a use-query's multi result sets. More...
struct | equal_list_b
| Same as equal_list_ba, plus the option to have some elements of the equals clause suppressed. More...
struct | equal_list_ba
| Holds two lists of items, typically used to construct a SQL "equals clause". More...
class | Exception
| Base class for all MySQL++ custom exceptions. More...
class | FieldNames
| Holds a list of SQL field names. More...
class | Fields
| A container similar to `std::vector` for holding mysqlpp::Field records. More...
class | FieldTypes
| A vector of SQL field types. More...
class | Lock
| Abstract base class for lock implementation, used by Lockable. More...
class | Lockable
| Interface allowing a class to declare itself as "lockable". More...
class | LockFailed
| Exception thrown when a Lockable object fails. More...
class | mysql_type_info
| Holds basic type information for ColData. More...
class | MysqlCmp
| Template for making function objects that can compare something against a Row element. More...
class | MysqlCmpCStr
| const char* specialization of MysqlCmp More...
struct | OptionInfo
class | NoExceptions
| Disable exceptions in an object derived from OptionalExceptions. More...
class | Null
| Class for holding data from a SQL column with the NULL attribute. More...
class | null_type
| The type of the global mysqlpp::null object. More...
struct | NullisBlank
| Class for objects that define SQL null as a blank C string. More...
struct | NullisNull
| Class for objects that define SQL null in terms of MySQL++'s null_type. More...
struct | NullisZero
| Class for objects that define SQL null as 0. More...
class | ObjectNotInitialized
| Exception thrown when you try to use an object that isn't completely initialized. More...
class | OptionalExceptions
| Interface allowing a class to have optional exceptions. More...
class | Query
| A class for building and executing SQL queries. More...
class | ResNSel
| Holds the information on the success of queries that don't return any results. More...
class | Result
| This class manages SQL result sets. More...
class | ResUse
| A basic result set class, for use with "use" queries. More...
class | Row
| Manages rows from a result set. More...
class | scoped_var_set
| Sets a variable to a given value temporarily. More...
class | Set
| A special std::set derivative for holding MySQL data sets. More...
struct | SQLParseElement
| Used within Query to hold elements for parameterized queries. More...
class | SQLQueryParms
| This class holds the parameter values for filling template queries. More...
class | SQLString
| A specialized `std::string` that will convert from any valid MySQL type. More...
class | subscript_iterator
| Iterator that can be subscripted. More...
struct | Time
| C++ form of MySQL's TIME type. More...
class | tiny_int
| Class for holding an SQL `tiny_int` object. More...
struct | value_list_b
| Same as value_list_ba, plus the option to have some elements of the list suppressed. More...
struct | value_list_ba
| Holds a list of items, typically used to construct a SQL "value list". More...
## Typedefs
typedef ColData_Tmpl< const_string > | ColData
| The type that is returned by constant rows.
typedef ColData_Tmpl< std::string > | MutableColData
| The type that is returned by mutable rows.
typedef std::binary_function< const char *, const char *, bool > | bin_char_pred
| Base class for the other predicate types defined in compare.h.
typedef MYSQL_FIELD | Field
| Alias for MYSQL_FIELD.
typedef const char | cchar
| Contraction for 'const char*'.
typedef unsigned int | uint
| Contraction for 'unsigned int'.
## Enumerations
enum | sql_cmp_type
| Used to disambiguate overloads of equal_list() in SSQLSes.
enum | quote_type0 { quote }
enum | quote_only_type0 { quote_only }
enum | quote_double_only_type0 { quote_double_only }
enum | escape_type0
enum | do_nothing_type0 { do_nothing }
enum | ignore_type0 { ignore }
enum | query_reset
| Used for indicating whether a query object should auto-reset.
## Functions
template<class BinaryPred, class CmpType> MysqlCmp< BinaryPred, CmpType > | mysql_cmp (uint i, const BinaryPred &func, const CmpType &cmp2)
| Template for function objects that compare any two objects, as long as they can be converted to SQLString.
template<class BinaryPred> MysqlCmpCStr< BinaryPred > | mysql_cmp_cstr (uint i, const BinaryPred &func, const char *cmp2)
| Template for function objects that compare any two things that can be converted to `const char*`.
std::ostream & | operator<< (std::ostream &o, const const_string &str)
| Inserts a const_string into a C++ stream.
int | compare (const const_string &lhs, const const_string &rhs)
| Calls lhs.compare(), passing rhs.
bool | operator== (const_string &lhs, const_string &rhs)
| Returns true if lhs is the same as rhs.
bool | operator!= (const_string &lhs, const_string &rhs)
| Returns true if lhs is not the same as rhs.
bool | operator< (const_string &lhs, const_string &rhs)
| Returns true if lhs is lexically less than rhs.
bool | operator<= (const_string &lhs, const_string &rhs)
| Returns true if lhs is lexically less or equal to rhs.
bool | operator> (const_string &lhs, const_string &rhs)
| Returns true if lhs is lexically greater than rhs.
bool | operator>= (const_string &lhs, const_string &rhs)
| Returns true if lhs is lexically greater than or equal to rhs.
std::ostream & | operator<< (std::ostream &os, const Date &d)
| Inserts a Date object into a C++ stream.
std::ostream & | operator<< (std::ostream &os, const Time &t)
| Inserts a Time object into a C++ stream in a MySQL-compatible format.
std::ostream & | operator<< (std::ostream &os, const DateTime &dt)
| Inserts a DateTime object into a C++ stream in a MySQL-compatible format.
SQLQueryParms & | operator<< (quote_type2 p, SQLString &in)
| Inserts a SQLString into a stream, quoted and escaped.
template<> ostream & | operator<< (quote_type1 o, const string &in)
| Inserts a C++ string into a stream, quoted and escaped.
template<> ostream & | operator<< (quote_type1 o, const char *const &in)
| Inserts a C string into a stream, quoted and escaped.
template<class Str> ostream & | _manip (quote_type1 o, const ColData_Tmpl< Str > &in)
| Utility function used by operator<<(quote_type1, ColData).
template<> ostream & | operator<< (quote_type1 o, const ColData_Tmpl< string > &in)
| Inserts a ColData into a stream, quoted and escaped.
template<> ostream & | operator<< (quote_type1 o, const ColData_Tmpl< const_string > &in)
| Inserts a ColData with const string into a stream, quoted and escaped.
ostream & | operator<< (ostream &o, const ColData_Tmpl< string > &in)
| Inserts a ColData into a stream.
ostream & | operator<< (ostream &o, const ColData_Tmpl< const_string > &in)
| Inserts a ColData with const string into a stream.
Query & | operator<< (Query &o, const ColData_Tmpl< string > &in)
| Insert a ColData into a SQLQuery.
Query & | operator<< (Query &o, const ColData_Tmpl< const_string > &in)
| Insert a ColData with const string into a SQLQuery.
SQLQueryParms & | operator<< (quote_only_type2 p, SQLString &in)
| Inserts a SQLString into a stream, quoting it unless it's data that needs no quoting.
template<> ostream & | operator<< (quote_only_type1 o, const ColData_Tmpl< string > &in)
| Inserts a ColData into a stream, quoted.
template<> ostream & | operator<< (quote_only_type1 o, const ColData_Tmpl< const_string > &in)
| Inserts a ColData with const string into a stream, quoted.
SQLQueryParms & | operator<< (quote_double_only_type2 p, SQLString &in)
| Inserts a SQLString into a stream, double-quoting it (") unless it's data that needs no quoting.
template<> ostream & | operator<< (quote_double_only_type1 o, const ColData_Tmpl< string > &in)
| Inserts a ColData into a stream, double-quoted (").
template<> ostream & | operator<< (quote_double_only_type1 o, const ColData_Tmpl< const_string > &in)
| Inserts a ColData with const string into a stream, double-quoted (").
SQLQueryParms & | operator<< (escape_type2 p, SQLString &in)
| Inserts a SQLString into a stream, escaping special SQL characters.
template<> std::ostream & | operator<< (escape_type1 o, const std::string &in)
| Inserts a C++ string into a stream, escaping special SQL characters.
template<> ostream & | operator<< (escape_type1 o, const char *const &in)
| Inserts a C string into a stream, escaping special SQL characters.
template<class Str> ostream & | _manip (escape_type1 o, const ColData_Tmpl< Str > &in)
| Utility function used by operator<<(escape_type1, ColData).
template<> std::ostream & | operator<< (escape_type1 o, const ColData_Tmpl< std::string > &in)
| Inserts a ColData into a stream, escaping special SQL characters.
template<> std::ostream & | operator<< (escape_type1 o, const ColData_Tmpl< const_string > &in)
| Inserts a ColData with const string into a stream, escaping special SQL characters.
SQLQueryParms & | operator<< (do_nothing_type2 p, SQLString &in)
| Inserts a SQLString into a stream, with no escaping or quoting.
SQLQueryParms & | operator<< (ignore_type2 p, SQLString &in)
| Inserts a SQLString into a stream, with no escaping or quoting, and without marking the string as having been "processed".
template<class T> std::ostream & | operator<< (escape_type1 o, const T &in)
| Inserts any type T into a stream that has an operator<< defined for it.
template<> MYSQLPP_EXPORT std::ostream & | operator<< (escape_type1 o, char *const &in)
| Inserts a C string into a stream, escaping special SQL characters.
template<class Container> std::ostream & | operator<< (std::ostream &s, const Set< Container > &d)
| Inserts a Set object into a C++ stream.
template<class Type, class Behavior> std::ostream & | operator<< (std::ostream &o, const Null< Type, Behavior > &n)
| Inserts null-able data into a C++ stream if it is not actually null. Otherwise, insert something appropriate for null data.
void | swap (ResUse &x, ResUse &y)
| Swaps two ResUse objects.
void | swap (Result &x, Result &y)
| Swaps two Result objects.
template<class Strng, class T> Strng | stream2string (const T &object)
| Converts a stream-able object to any type that can be initialized from an `std::string`.
void | strip (std::string &s)
| Strips blanks at left and right ends.
void | escape_string (std::string &s)
| C++ equivalent of mysql_escape_string().
MYSQLPP_EXPORT void | str_to_upr (std::string &s)
| Changes case of string to upper.
MYSQLPP_EXPORT void | str_to_lwr (std::string &s)
| Changes case of string to lower.
MYSQLPP_EXPORT void | strip_all_blanks (std::string &s)
| Removes all blanks.
MYSQLPP_EXPORT void | strip_all_non_num (std::string &s)
| Removes all non-numerics.
bool | operator== (const mysql_type_info &a, const mysql_type_info &b)
| Returns true if two mysql_type_info objects are equal.
bool | operator!= (const mysql_type_info &a, const mysql_type_info &b)
| Returns true if two mysql_type_info objects are not equal.
bool | operator== (const std::type_info &a, const mysql_type_info &b)
| Returns true if a given mysql_type_info object is equal to a given C++ type_info object.
bool | operator!= (const std::type_info &a, const mysql_type_info &b)
| Returns true if a given mysql_type_info object is not equal to a given C++ type_info object.
bool | operator== (const mysql_type_info &a, const std::type_info &b)
| Returns true if a given mysql_type_info object is equal to a given C++ type_info object.
bool | operator!= (const mysql_type_info &a, const std::type_info &b)
| Returns true if a given mysql_type_info object is not equal to a given C++ type_info object.
void | create_vector (size_t size, std::vector< bool > &v, bool t0, bool t1, bool t2, bool t3, bool t4, bool t5, bool t6, bool t7, bool t8, bool t9, bool ta, bool tb, bool tc)
| Create a vector of bool with the given arguments as values.
template<class Container> void | create_vector (const Container &c, std::vector< bool > &v, std::string s0, std::string s1, std::string s2, std::string s3, std::string s4, std::string s5, std::string s6, std::string s7, std::string s8, std::string s9, std::string sa, std::string sb, std::string sc)
| Create a vector of bool using a list of named fields.
template<class Seq1, class Seq2, class Manip> std::ostream & | operator<< (std::ostream &o, const equal_list_ba< Seq1, Seq2, Manip > &el)
| Inserts an equal_list_ba into an std::ostream.
template<class Seq1, class Seq2, class Manip> std::ostream & | operator<< (std::ostream &o, const equal_list_b< Seq1, Seq2, Manip > &el)
| Same as operator<< for equal_list_ba, plus the option to suppress insertion of some list items in the stream.
template<class Seq, class Manip> std::ostream & | operator<< (std::ostream &o, const value_list_ba< Seq, Manip > &cl)
| Inserts a value_list_ba into an std::ostream.
template<class Seq, class Manip> std::ostream & | operator<< (std::ostream &o, const value_list_b< Seq, Manip > &cl)
| Same as operator<< for value_list_ba, plus the option to suppress insertion of some list items in the stream.
template<class Seq> value_list_ba< Seq, do_nothing_type0 > | value_list (const Seq &s, const char *d=",")
| Constructs a value_list_ba.
template<class Seq, class Manip> value_list_ba< Seq, Manip > | value_list (const Seq &s, const char *d, Manip m)
| Constructs a value_list_ba.
template<class Seq, class Manip> value_list_b< Seq, Manip > | value_list (const Seq &s, const char *d, Manip m, const std::vector< bool > &vb)
| Constructs a value_list_b (sparse value list).
template<class Seq, class Manip> value_list_b< Seq, Manip > | value_list (const Seq &s, const char *d, Manip m, bool t0, bool t1=false, bool t2=false, bool t3=false, bool t4=false, bool t5=false, bool t6=false, bool t7=false, bool t8=false, bool t9=false, bool ta=false, bool tb=false, bool tc=false)
| Constructs a value_list_b (sparse value list).
template<class Seq> value_list_b< Seq, do_nothing_type0 > | value_list (const Seq &s, const char *d, bool t0, bool t1=false, bool t2=false, bool t3=false, bool t4=false, bool t5=false, bool t6=false, bool t7=false, bool t8=false, bool t9=false, bool ta=false, bool tb=false, bool tc=false)
| Constructs a sparse value list.
template<class Seq> value_list_b< Seq, do_nothing_type0 > | value_list (const Seq &s, bool t0, bool t1=false, bool t2=false, bool t3=false, bool t4=false, bool t5=false, bool t6=false, bool t7=false, bool t8=false, bool t9=false, bool ta=false, bool tb=false, bool tc=false)
| Constructs a sparse value list.
template<class Seq1, class Seq2> equal_list_ba< Seq1, Seq2, do_nothing_type0 > | equal_list (const Seq1 &s1, const Seq2 &s2, const char *d=",", const char *e="=")
| Constructs an equal_list_ba.
template<class Seq1, class Seq2, class Manip> equal_list_ba< Seq1, Seq2, Manip > | equal_list (const Seq1 &s1, const Seq2 &s2, const char *d, const char *e, Manip m)
| Constructs an equal_list_ba.
template<class Seq1, class Seq2, class Manip> equal_list_b< Seq1, Seq2, Manip > | equal_list (const Seq1 &s1, const Seq2 &s2, const char *d, const char *e, Manip m, const std::vector< bool > &vb)
| Constructs a equal_list_b (sparse equal list).
template<class Seq1, class Seq2, class Manip> equal_list_b< Seq1, Seq2, Manip > | equal_list (const Seq1 &s1, const Seq2 &s2, const char *d, const char *e, Manip m, bool t0, bool t1=false, bool t2=false, bool t3=false, bool t4=false, bool t5=false, bool t6=false, bool t7=false, bool t8=false, bool t9=false, bool ta=false, bool tb=false, bool tc=false)
| Constructs a equal_list_b (sparse equal list).
template<class Seq1, class Seq2> equal_list_b< Seq1, Seq2, do_nothing_type0 > | equal_list (const Seq1 &s1, const Seq2 &s2, const char *d, const char *e, bool t0, bool t1=false, bool t2=false, bool t3=false, bool t4=false, bool t5=false, bool t6=false, bool t7=false, bool t8=false, bool t9=false, bool ta=false, bool tb=false, bool tc=false)
| Constructs a equal_list_b (sparse equal list).
template<class Seq1, class Seq2> equal_list_b< Seq1, Seq2, do_nothing_type0 > | equal_list (const Seq1 &s1, const Seq2 &s2, const char *d, bool t0, bool t1=false, bool t2=false, bool t3=false, bool t4=false, bool t5=false, bool t6=false, bool t7=false, bool t8=false, bool t9=false, bool ta=false, bool tb=false, bool tc=false)
| Constructs a equal_list_b (sparse equal list).
template<class Seq1, class Seq2> equal_list_b< Seq1, Seq2, do_nothing_type0 > | equal_list (const Seq1 &s1, const Seq2 &s2, bool t0, bool t1=false, bool t2=false, bool t3=false, bool t4=false, bool t5=false, bool t6=false, bool t7=false, bool t8=false, bool t9=false, bool ta=false, bool tb=false, bool tc=false)
| Constructs a equal_list_b (sparse equal list).
## Variables
const bool | use_exceptions = true
| Alias for 'true', to make code requesting exceptions more readable.
bool | dont_quote_auto = false
| Set to true if you want to suppress automatic quoting.
const null_type | null = null_type()
| Global 'null' instance. Use wherever you need a SQL null. (As opposed to a C++ language null pointer or null character.).

## Detailed Description

All global symbols in MySQL++ are in namespace mysqlpp. This is needed because many symbols are rather generic (e.g. Row, Query...), so there is a serious danger of conflicts.

## Enumeration Type Documentation

enum mysqlpp::do_nothing_type0

  | The 'do_nothing' manipulator. Does exactly what it says: nothing. Used as a dummy manipulator when you are required to use some manipulator but don't want anything to be done to the following item. When used with SQLQueryParms it will make sure that it does not get formatted in any way, overriding any setting set by the template query. Enumeration values:
  do_nothing | insert into a std::ostream to override manipulation of next item

enum mysqlpp::escape_type0

| The 'escape' manipulator. Calls mysql_escape_string() in the MySQL C API on the following argument to prevent any special SQL characters from being interpreted.

enum mysqlpp::ignore_type0

  | The 'ignore' manipulator. Only valid when used with SQLQueryParms. It's a dummy manipulator like the do_nothing manipulator, except that it will not override formatting set by the template query. It is simply ignored. Enumeration values:
  ignore | insert into a std::ostream as a dummy manipulator

enum mysqlpp::quote_double_only_type0

  | The 'double_quote_only' manipulator. Similar to quote_only manipulator, except that it uses double quotes instead of single quotes. Enumeration values:
  quote_double_only | insert into a std::ostream to double-quote next item

enum mysqlpp::quote_only_type0

  | The 'quote_only' manipulator. Similar to quote manipulator, except that it doesn't escape special SQL characters. Enumeration values:
  quote_only | insert into a std::ostream to single-quote next item

enum mysqlpp::quote_type0

  | The standard 'quote' manipulator. Insert this into a stream to put single quotes around the next item in the stream, and escape characters within it that are 'special' in SQL. This is the most generally useful of the manipulators. Enumeration values:
  quote | insert into a std::ostream to single-quote and escape next item

## Function Documentation

template<class Container>
void mysqlpp::create_vector | ( | const Container & | c,
|  | std::vector< bool > & | v,
|  | std::string | s0,
|  | std::string | s1,
|  | std::string | s2,
|  | std::string | s3,
|  | std::string | s4,
|  | std::string | s5,
|  | std::string | s6,
|  | std::string | s7,
|  | std::string | s8,
|  | std::string | s9,
|  | std::string | sa,
|  | std::string | sb,
|  | std::string | sc
| ) |

| Create a vector of bool using a list of named fields. This function is used with the ResUse and Result containers, which have a field_num() member function that maps a field name to its position number. So for each named field, we set the bool in the vector at the corresponding position to true. This function is used within the library to build the vector used in calling the vector form of Row::equal_list(), Row::value_list(), and Row::field_list(). See the "Harnessing SSQLS Internals" section of the user manual to see that feature at work.

void mysqlpp::create_vector | ( | size_t | size,
|  | std::vector< bool > & | v,
|  | bool | t0,
|  | bool | t1 = false,
|  | bool | t2 = false,
|  | bool | t3 = false,
|  | bool | t4 = false,
|  | bool | t5 = false,
|  | bool | t6 = false,
|  | bool | t7 = false,
|  | bool | t8 = false,
|  | bool | t9 = false,
|  | bool | ta = false,
|  | bool | tb = false,
|  | bool | tc = false
| ) |

| Create a vector of bool with the given arguments as values. This function takes up to 13 bools, with the size parameter controlling the actual number of parameters we pay attention to. This function is used within the library to build the vector used in calling the vector form of Row::equal_list(), Row::value_list(), and Row::field_list(). See the "Harnessing SSQLS Internals" section of the user manual to see that feature at work.

template<class Seq1, class Seq2>
equal_list_b<Seq1, Seq2, do_nothing_type0> equal_list | ( | const Seq1 & | s1,
|  | const Seq2 & | s2,
|  | bool | t0,
|  | bool | t1 = false,
|  | bool | t2 = false,
|  | bool | t3 = false,
|  | bool | t4 = false,
|  | bool | t5 = false,
|  | bool | t6 = false,
|  | bool | t7 = false,
|  | bool | t8 = false,
|  | bool | t9 = false,
|  | bool | ta = false,
|  | bool | tb = false,
|  | bool | tc = false
| ) |

| Constructs a equal_list_b (sparse equal list). Same as equal_list(Seq&, Seq&, const char*, bool, bool...) except that it doesn't take the const char* argument. It uses a comma for the delimiter. This form is useful for building simple equals lists, where no manipulators are necessary, and the default delimiter and equals symbol are suitable.

template<class Seq1, class Seq2>
equal_list_b<Seq1, Seq2, do_nothing_type0> equal_list | ( | const Seq1 & | s1,
|  | const Seq2 & | s2,
|  | const char * | d,
|  | bool | t0,
|  | bool | t1 = false,
|  | bool | t2 = false,
|  | bool | t3 = false,
|  | bool | t4 = false,
|  | bool | t5 = false,
|  | bool | t6 = false,
|  | bool | t7 = false,
|  | bool | t8 = false,
|  | bool | t9 = false,
|  | bool | ta = false,
|  | bool | tb = false,
|  | bool | tc = false
| ) |

| Constructs a equal_list_b (sparse equal list). Same as equal_list(Seq&, Seq&, const char*, const char*, bool, bool...) except that it doesn't take the second const char* argument. It uses " = " for the equals symbol.

template<class Seq1, class Seq2>
equal_list_b<Seq1, Seq2, do_nothing_type0> equal_list | ( | const Seq1 & | s1,
|  | const Seq2 & | s2,
|  | const char * | d,
|  | const char * | e,
|  | bool | t0,
|  | bool | t1 = false,
|  | bool | t2 = false,
|  | bool | t3 = false,
|  | bool | t4 = false,
|  | bool | t5 = false,
|  | bool | t6 = false,
|  | bool | t7 = false,
|  | bool | t8 = false,
|  | bool | t9 = false,
|  | bool | ta = false,
|  | bool | tb = false,
|  | bool | tc = false
| ) |

| Constructs a equal_list_b (sparse equal list). Same as equal_list(Seq&, Seq&, const char*, const char*, Manip, bool, bool...) except that it doesn't take the Manip argument. It uses the do_nothing manipulator instead, meaning that none of the elements are escaped when being inserted into a stream.

template<class Seq1, class Seq2, class Manip>
equal_list_b<Seq1, Seq2, Manip> equal_list | ( | const Seq1 & | s1,
|  | const Seq2 & | s2,
|  | const char * | d,
|  | const char * | e,
|  | Manip | m,
|  | bool | t0,
|  | bool | t1 = false,
|  | bool | t2 = false,
|  | bool | t3 = false,
|  | bool | t4 = false,
|  | bool | t5 = false,
|  | bool | t6 = false,
|  | bool | t7 = false,
|  | bool | t8 = false,
|  | bool | t9 = false,
|  | bool | ta = false,
|  | bool | tb = false,
|  | bool | tc = false
| ) |

| Constructs a equal_list_b (sparse equal list). Same as equal_list(Seq&, Seq&, const char*, const char*, Manip, vector<bool>&) except that it takes boolean parameters instead of a list of bools.

template<class Seq1, class Seq2, class Manip>
equal_list_b<Seq1, Seq2, Manip> equal_list | ( | const Seq1 & | s1,
|  | const Seq2 & | s2,
|  | const char * | d,
|  | const char * | e,
|  | Manip | m,
|  | const std::vector< bool > & | vb
| ) |

| Constructs a equal_list_b (sparse equal list). Same as equal_list(Seq&, Seq&, const char*, const char*, Manip) except that you can pass a vector of bools. For each true item in that list, operator<< adds the corresponding item is put in the equal list. This lets you pass in sequences when you don't want all of the elements to be inserted into a stream.

template<class Seq1, class Seq2, class Manip>
equal_list_ba<Seq1, Seq2, Manip> equal_list | ( | const Seq1 & | s1,
|  | const Seq2 & | s2,
|  | const char * | d,
|  | const char * | e,
|  | Manip | m
| ) |

| Constructs an equal_list_ba. Same as equal_list(Seq&, Seq&, const char*, const char*) except that it also lets you specify the manipulator. Use this version if the data must be escaped or quoted when being inserted into a stream.

template<class Seq1, class Seq2>
equal_list_ba<Seq1, Seq2, do_nothing_type0> equal_list | ( | const Seq1 & | s1,
|  | const Seq2 & | s2,
|  | const char * | d = ",",
|  | const char * | e = " = "
| ) |

  | Constructs an equal_list_ba. This function returns an equal list that uses the 'do_nothing' manipulator. That is, the items are not quoted or escaped in any way when inserted into a stream. See equal_list(Seq, Seq, const char*, const char*, Manip) if you need a different manipulator. The idea is for both lists to be of equal length because corresponding elements from each list are handled as pairs, but if one list is shorter than the other, the generated list will have that many elements. Parameters:
  s1 | items on the left side of the equals sign when the equal list is inserted into a stream
  s2 | items on the right side of the equals sign
  d | delimiter operator<< should place between pairs
  e | what operator<< should place between items in each pair; by default, an equals sign, as that is the primary use for this mechanism.

template<class BinaryPred, class CmpType>
MysqlCmp<BinaryPred, CmpType> mysql_cmp | ( | uint | i,
|  | const BinaryPred & | func,
|  | const CmpType & | cmp2
| ) |

  | Template for function objects that compare any two objects, as long as they can be converted to SQLString. This is a more generic form of mysql_cmp_cstr(), and is therefore less efficient. Use this form only when necessary. Parameters:
  i | field index number
  func | one of the functors in compare.h, or any compatible functor
  cmp2 | what to compare to

template<class BinaryPred>
MysqlCmpCStr<BinaryPred> mysql_cmp_cstr | ( | uint | i,
|  | const BinaryPred & | func,
|  | const char * | cmp2
| ) |

  | Template for function objects that compare any two things that can be converted to `const char*`. Parameters:
  i | field index number
  func | one of cstr_equal_to, cstr_not_equal_to, cstr_less, cstr_less_equal, cstr_less_equal, or cstr_less_equal.
  cmp2 | what to compare to
See also: mysql_cmp()

template<class Seq, class Manip>
std::ostream& operator<< | ( | std::ostream & | o,
|  | const value_list_b< Seq, Manip > & | cl
| ) |

| Same as operator<< for value_list_ba, plus the option to suppress insertion of some list items in the stream. See value_list_b's documentation for examples of how this works.

template<class Seq, class Manip>
std::ostream& operator<< | ( | std::ostream & | o,
|  | const value_list_ba< Seq, Manip > & | cl
| ) |

| Inserts a value_list_ba into an std::ostream. Given a list (a, b) and a delimiter D, this operator will insert "aDb" into the stream. See value_list_ba's documentation for concrete examples. See also: value_list()

template<class Seq1, class Seq2, class Manip>
std::ostream& operator<< | ( | std::ostream & | o,
|  | const equal_list_b< Seq1, Seq2, Manip > & | el
| ) |

| Same as operator<< for equal_list_ba, plus the option to suppress insertion of some list items in the stream. See equal_list_b's documentation for examples of how this works.

template<class Seq1, class Seq2, class Manip>
std::ostream& operator<< | ( | std::ostream & | o,
|  | const equal_list_ba< Seq1, Seq2, Manip > & | el
| ) |

| Inserts an equal_list_ba into an std::ostream. Given two lists (a, b) and (c, d), a delimiter D, and an equals symbol E, this operator will insert "aEcDbEd" into the stream. See equal_list_ba's documentation for concrete examples. See also: equal_list()

template<>
MYSQLPP_EXPORT std::ostream& operator<< | ( | escape_type1 | o,
|  | char *const & | in
| ) | `[inline]`

| Inserts a C string into a stream, escaping special SQL characters. This version exists solely to handle constness problems. We force everything to the completely-const version: operator<<(escape_type1, const char* const&).

template<class T>
std::ostream& operator<< | ( | escape_type1 | o,
|  | const T & | in
| ) | `[inline]`

| Inserts any type T into a stream that has an operator<< defined for it. Does not actually escape that data! Use one of the other forms of operator<< for the escape manipulator if you need escaping. This template exists to catch cases like inserting an `int` after the escape manipulator: you don't actually want escaping in this instance.

template<>
MYSQLPP_EXPORT std::ostream & mysqlpp::operator<< | ( | escape_type1 | o,
|  | const ColData_Tmpl< const_string > & | in
| ) |

| Inserts a ColData with const string into a stream, escaping special SQL characters. Because ColData was designed to contain MySQL type data, we may choose not to escape the data, if it is not needed.

template<>
MYSQLPP_EXPORT std::ostream & mysqlpp::operator<< | ( | escape_type1 | o,
|  | const ColData_Tmpl< std::string > & | in
| ) |

| Inserts a ColData into a stream, escaping special SQL characters. Because ColData was designed to contain MySQL type data, we may choose not to escape the data, if it is not needed.

template<>
MYSQLPP_EXPORT std::ostream & mysqlpp::operator<< | ( | escape_type1 | o,
|  | const char *const & | in
| ) |

| Inserts a C string into a stream, escaping special SQL characters. Because C's type system lacks the information we need to second- guess this manipulator, we always run the escaping algorithm on the data, even if it's not needed.

template<>
MYSQLPP_EXPORT std::ostream & mysqlpp::operator<< | ( | escape_type1 | o,
|  | const std::string & | in
| ) |

| Inserts a C++ string into a stream, escaping special SQL characters. Because std::string lacks the type information we need, the string is always escaped, even if it doesn't need it.

MYSQLPP_EXPORT SQLQueryParms & mysqlpp::operator<< | ( | escape_type2 | p,
|  | SQLString & | in
| ) |

| Inserts a SQLString into a stream, escaping special SQL characters. We actually only do the escaping if in.is_string is set but in.dont_escape is not. If that is not the case, we insert the string data directly.

template<>
ostream& operator<< | ( | quote_double_only_type1 | o,
|  | const ColData_Tmpl< const_string > & | in
| ) |

| Inserts a ColData with const string into a stream, double-quoted ("). Because ColData was designed to contain MySQL type data, we may choose not to actually quote the data, if it is not needed.

template<>
ostream& operator<< | ( | quote_double_only_type1 | o,
|  | const ColData_Tmpl< string > & | in
| ) |

| Inserts a ColData into a stream, double-quoted ("). Because ColData was designed to contain MySQL type data, we may choose not to actually quote the data, if it is not needed.

SQLQueryParms& operator<< | ( | quote_double_only_type2 | p,
|  | SQLString & | in
| ) |

| Inserts a SQLString into a stream, double-quoting it (") unless it's data that needs no quoting. We make the decision to quote the data based on the in.is_string flag. You can set it yourself, but SQLString's ctors should set it correctly for you.

template<>
ostream& operator<< | ( | quote_only_type1 | o,
|  | const ColData_Tmpl< const_string > & | in
| ) |

| Inserts a ColData with const string into a stream, quoted. Because ColData was designed to contain MySQL type data, we may choose not to actually quote the data, if it is not needed.

template<>
ostream& operator<< | ( | quote_only_type1 | o,
|  | const ColData_Tmpl< string > & | in
| ) |

| Inserts a ColData into a stream, quoted. Because ColData was designed to contain MySQL type data, we may choose not to actually quote the data, if it is not needed.

SQLQueryParms& operator<< | ( | quote_only_type2 | p,
|  | SQLString & | in
| ) |

| Inserts a SQLString into a stream, quoting it unless it's data that needs no quoting. We make the decision to quote the data based on the in.is_string flag. You can set it yourself, but SQLString's ctors should set it correctly for you.

Query& operator<< | ( | Query & | o,
|  | const ColData_Tmpl< const_string > & | in
| ) |

| Insert a ColData with const string into a SQLQuery. This operator appears to be a workaround for a weakness in one compiler's implementation of the C++ type system. See Wishlist for current plan on what to do about this.

Query& operator<< | ( | Query & | o,
|  | const ColData_Tmpl< string > & | in
| ) |

| Insert a ColData into a SQLQuery. This operator appears to be a workaround for a weakness in one compiler's implementation of the C++ type system. See Wishlist for current plan on what to do about this.

ostream& operator<< | ( | ostream & | o,
|  | const ColData_Tmpl< const_string > & | in
| ) |

| Inserts a ColData with const string into a stream. Because ColData was designed to contain MySQL type data, this operator has the information needed to choose to quote and/or escape the data as it is inserted into the stream, even if you don't use any of the quoting or escaping manipulators.

ostream& operator<< | ( | ostream & | o,
|  | const ColData_Tmpl< string > & | in
| ) |

| Inserts a ColData into a stream. Because ColData was designed to contain MySQL type data, this operator has the information needed to choose to quote and/or escape the data as it is inserted into the stream, even if you don't use any of the quoting or escaping manipulators.

template<>
ostream& operator<< | ( | quote_type1 | o,
|  | const ColData_Tmpl< const_string > & | in
| ) |

| Inserts a ColData with const string into a stream, quoted and escaped. Because ColData was designed to contain MySQL type data, we may choose not to actually quote or escape the data, if it is not needed.

template<>
ostream& operator<< | ( | quote_type1 | o,
|  | const ColData_Tmpl< string > & | in
| ) |

| Inserts a ColData into a stream, quoted and escaped. Because ColData was designed to contain MySQL type data, we may choose not to actually quote or escape the data, if it is not needed.

template<>
ostream& operator<< | ( | quote_type1 | o,
|  | const char *const & | in
| ) |

| Inserts a C string into a stream, quoted and escaped. Because C strings lack the type information we need, the string is both quoted and escaped, always.

template<>
ostream& operator<< | ( | quote_type1 | o,
|  | const string & | in
| ) |

| Inserts a C++ string into a stream, quoted and escaped. Because std::string lacks the type information we need, the string is both quoted and escaped, always.

SQLQueryParms& operator<< | ( | quote_type2 | p,
|  | SQLString & | in
| ) |

| Inserts a SQLString into a stream, quoted and escaped. If in.is_string is set and in.dont_escape is not set, the string is quoted and escaped. If both in.is_string and in.dont_escape are set, the string is quoted but not escaped. If in.is_string is not set, the data is inserted as-is. This is the case when you initialize SQLString with one of the constructors taking an integral type, for instance.

MYSQLPP_EXPORT std::ostream & mysqlpp::operator<< | ( | std::ostream & | os,
|  | const DateTime & | dt
| ) |

  | Inserts a DateTime object into a C++ stream in a MySQL-compatible format. The date and time are inserted into the stream, in that order, with a space between them. Parameters:
  os | stream to insert date and time into
  dt | date/time object to insert into stream

MYSQLPP_EXPORT std::ostream & mysqlpp::operator<< | ( | std::ostream & | os,
|  | const Time & | t
| ) |

  | Inserts a Time object into a C++ stream in a MySQL-compatible format. The format is HH:MM:SS, zero-padded. Parameters:
  os | stream to insert time into
  t | time to insert into stream

MYSQLPP_EXPORT std::ostream & mysqlpp::operator<< | ( | std::ostream & | os,
|  | const Date & | d
| ) |

  | Inserts a Date object into a C++ stream. The format is YYYY-MM-DD, zero-padded. Parameters:
  os | stream to insert date into
  d | date to insert into stream

template<class Strng, class T>
Strng stream2string | ( | const T & | object | ) |

| Converts a stream-able object to any type that can be initialized from an `std::string`. This adapter takes any object that has an `out_stream()` member function and converts it to a string type. An example of such a type within the library is mysqlpp::Date.

template<class Seq>
value_list_b<Seq, do_nothing_type0> value_list | ( | const Seq & | s,
|  | bool | t0,
|  | bool | t1 = false,
|  | bool | t2 = false,
|  | bool | t3 = false,
|  | bool | t4 = false,
|  | bool | t5 = false,
|  | bool | t6 = false,
|  | bool | t7 = false,
|  | bool | t8 = false,
|  | bool | t9 = false,
|  | bool | ta = false,
|  | bool | tb = false,
|  | bool | tc = false
| ) |

| Constructs a sparse value list. Same as value_list(Seq&, const char*, Manip, bool, bool...) but without the Manip or delimiter parameters. We use the do_nothing manipulator, meaning that the value list items are neither escaped nor quoted when being inserted into a stream. The delimiter is a comma. This form is suitable for lists of simple data, such as integers.

template<class Seq>
value_list_b<Seq, do_nothing_type0> value_list | ( | const Seq & | s,
|  | const char * | d,
|  | bool | t0,
|  | bool | t1 = false,
|  | bool | t2 = false,
|  | bool | t3 = false,
|  | bool | t4 = false,
|  | bool | t5 = false,
|  | bool | t6 = false,
|  | bool | t7 = false,
|  | bool | t8 = false,
|  | bool | t9 = false,
|  | bool | ta = false,
|  | bool | tb = false,
|  | bool | tc = false
| ) |

| Constructs a sparse value list. Same as value_list(Seq&, const char*, Manip, bool, bool...) but without the Manip parameter. We use the do_nothing manipulator, meaning that the value list items are neither escaped nor quoted when being inserted into a stream.

template<class Seq, class Manip>
value_list_b<Seq, Manip> value_list | ( | const Seq & | s,
|  | const char * | d,
|  | Manip | m,
|  | bool | t0,
|  | bool | t1 = false,
|  | bool | t2 = false,
|  | bool | t3 = false,
|  | bool | t4 = false,
|  | bool | t5 = false,
|  | bool | t6 = false,
|  | bool | t7 = false,
|  | bool | t8 = false,
|  | bool | t9 = false,
|  | bool | ta = false,
|  | bool | tb = false,
|  | bool | tc = false
| ) |

| Constructs a value_list_b (sparse value list). Same as value_list(Seq&, const char*, Manip, const vector<bool>&), except that it takes the bools as arguments instead of wrapped up in a vector object.

template<class Seq, class Manip>
value_list_b<Seq, Manip> value_list | ( | const Seq & | s,
|  | const char * | d,
|  | Manip | m,
|  | const std::vector< bool > & | vb
| ) | `[inline]`

  | Constructs a value_list_b (sparse value list). Parameters:
  s | an STL sequence of items in the value list
  d | delimiter operator<< should place between items
  m | manipulator to use when inserting items into a stream
  vb | for each item in this vector that is true, the corresponding item in the value list is inserted into a stream; the others are suppressed

template<class Seq, class Manip>
value_list_ba<Seq, Manip> value_list | ( | const Seq & | s,
|  | const char * | d,
|  | Manip | m
| ) |

  | Constructs a value_list_ba. Parameters:
  s | an STL sequence of items in the value list
  d | delimiter operator<< should place between items
  m | manipulator to use when inserting items into a stream

template<class Seq>
value_list_ba<Seq, do_nothing_type0> value_list | ( | const Seq & | s,
|  | const char * | d = ","
| ) |

  | Constructs a value_list_ba. This function returns a value list that uses the 'do_nothing' manipulator. That is, the items are not quoted or escaped in any way. See value_list(Seq, const char*, Manip) if you need to specify a manipulator. Parameters:
  s | an STL sequence of items in the value list
  d | delimiter operator<< should place between items

## Variable Documentation

bool mysqlpp::dont_quote_auto = false

| Set to true if you want to suppress automatic quoting. Works only for ColData inserted into C++ streams.