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

mysqlpp Namespace Reference


Classes

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...

struct  Connection::OptionInfo
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  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  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...

class  Transaction
 Helper object for creating exception-safe SQL transactions. 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_stringColData
 The type that is returned by constant rows.

typedef ColData_Tmpl< std::string > MutableColData
 The type that is returned by mutable rows.

typedef MYSQL_FIELD Field
 Alias for MYSQL_FIELD.


Enumerations

enum  quote_type0 { quote }
enum  quote_only_type0 { quote_only }
enum  quote_double_only_type0 { quote_double_only }
enum  escape_type0 { escape }
enum  do_nothing_type0 { do_nothing }
enum  ignore_type0 { ignore }
enum  query_reset { DONT_RESET, RESET_QUERY }
 Used for indicating whether a query object should auto-reset.


Functions

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.

SQLQueryParmsoperator<< (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.

Queryoperator<< (Query &o, const ColData_Tmpl< string > &in)
 Insert a ColData into a SQLQuery.

Queryoperator<< (Query &o, const ColData_Tmpl< const_string > &in)
 Insert a ColData with const string into a SQLQuery.

SQLQueryParmsoperator<< (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.

SQLQueryParmsoperator<< (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 (").

SQLQueryParmsoperator<< (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.

SQLQueryParmsoperator<< (do_nothing_type2 p, SQLString &in)
 Inserts a SQLString into a stream, with no escaping or quoting.

SQLQueryParmsoperator<< (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<> std::ostream & operator<< (escape_type1 o, char *const &in)
 Inserts a C string into a stream, escaping special SQL characters.

std::ostream & operator<< (escape_type1 o, char in[])
 Inserts an array of char 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.

unsigned int get_library_version ()
 Get the current MySQL++ library version number.

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().

void str_to_upr (std::string &s)
 Changes case of string to upper.

void str_to_lwr (std::string &s)
 Changes case of string to lower.

void strip_all_blanks (std::string &s)
 Removes all blanks.

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_type0value_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_type0value_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_type0value_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

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.

MYSQLPP_EXPORT unsigned int mysqlpp::get_library_version  ) 
 

Get the current MySQL++ library version number.

MySQL++ version number that the program is actually linked to, encoded by MYSQLPP_VERSION macro. Compare this value to the MYSQLPP_HEADER_VERSION constant in order to ensure that your program is using header files from the same version of MySQL++ as the actual library you're linking to.

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<>
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.


Generated on Wed Jul 11 15:35:03 2007 for MySQL++ by doxygen 1.3.5