query.h

Go to the documentation of this file.

/***********************************************************************
 Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
 (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
 also hold copyrights on code in this file.  See the CREDITS.txt file
 in the top directory of the distribution for details.

 This file is part of MySQL++.

 MySQL++ is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published
 by the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 MySQL++ is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with MySQL++; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
 USA
***********************************************************************/

#if !defined(MYSQLPP_QUERY_H)
#define MYSQLPP_QUERY_H

#include "common.h"

#include "noexceptions.h"
#include "qparms.h"
#include "querydef.h"
#include "result.h"
#include "row.h"
#include "stadapter.h"

#include <deque>
#include <iomanip>
#include <list>
#include <map>
#include <set>
#include <vector>

#ifdef HAVE_EXT_SLIST
#  include <ext/slist>
#else
#  if defined(HAVE_STD_SLIST) || defined(HAVE_GLOBAL_SLIST)
#      include <slist>
#  endif
#endif

namespace mysqlpp {

#if !defined(DOXYGEN_IGNORE)
// Make Doxygen ignore this
class MYSQLPP_EXPORT Connection;
#endif


class MYSQLPP_EXPORT Query :
                public std::ostream,
                public OptionalExceptions
{
public:
        Query(Connection* c, bool te = true, const char* qstr = 0);

        Query(const Query& q);

        ulonglong affected_rows();

        size_t escape_string(std::string* ps, const char* original = 0,
                        size_t length = 0) const;

        size_t escape_string(char* escaped, const char* original,
                        size_t length) const;

        int errnum() const;

        const char* error() const;

        std::string info();

        ulonglong insert_id();

        Query& operator=(const Query& rhs);

        operator void*() const;

        void parse();

        void reset();

        std::string str() { return str(template_defaults); }

        std::string str(const SQLTypeAdapter& arg0)
                        { return str(SQLQueryParms() << arg0); }

        std::string str(SQLQueryParms& p);

        bool exec() { return exec(str(template_defaults)); }

        bool exec(const std::string& str);

        SimpleResult execute() { return execute(str(template_defaults)); }

        SimpleResult execute(SQLQueryParms& p);

        SimpleResult execute(const SQLTypeAdapter& str);

        SimpleResult execute(const char* str, size_t len);

        UseQueryResult use() { return use(str(template_defaults)); }

        UseQueryResult use(SQLQueryParms& p);

        UseQueryResult use(const SQLTypeAdapter& str);

        UseQueryResult use(const char* str, size_t len);

        StoreQueryResult store() { return store(str(template_defaults)); }

        StoreQueryResult store(SQLQueryParms& p);

        StoreQueryResult store(const SQLTypeAdapter& str);

        StoreQueryResult store(const char* str, size_t len);

        template <typename Function>
        Function for_each(const SQLTypeAdapter& query, Function fn)
        {       
                mysqlpp::UseQueryResult res = use(query);
                if (res) {
                        mysqlpp::NoExceptions ne(res);
                        while (mysqlpp::Row row = res.fetch_row()) {
                                fn(row);
                        }
                }

                return fn;
        }

        template <typename Function>
        Function for_each(Function fn)
        {       
                mysqlpp::UseQueryResult res = use();
                if (res) {
                        mysqlpp::NoExceptions ne(res);
                        while (mysqlpp::Row row = res.fetch_row()) {
                                fn(row);
                        }
                }

                return fn;
        }

        template <class SSQLS, typename Function>
        Function for_each(const SSQLS& ssqls, Function fn)
        {       
                std::string query("select * from ");
                query += ssqls.table();
                mysqlpp::UseQueryResult res = use(query);
                if (res) {
                        mysqlpp::NoExceptions ne(res);
                        while (mysqlpp::Row row = res.fetch_row()) {
                                fn(row);
                        }
                }

                return fn;
        }

        template <class Sequence, typename Function>
        Function store_if(Sequence& con, const SQLTypeAdapter& query, Function fn)
        {       
                mysqlpp::UseQueryResult res = use(query);
                if (res) {
                        mysqlpp::NoExceptions ne(res);
                        while (mysqlpp::Row row = res.fetch_row()) {
                                if (fn(row)) {
                                        con.push_back(row);
                                }
                        }
                }

                return fn;
        }

        template <class Sequence, class SSQLS, typename Function>
        Function store_if(Sequence& con, const SSQLS& ssqls, Function fn)
        {       
                std::string query("select * from ");
                query += ssqls.table();
                mysqlpp::UseQueryResult res = use(query);
                if (res) {
                        mysqlpp::NoExceptions ne(res);
                        while (mysqlpp::Row row = res.fetch_row()) {
                                if (fn(row)) {
                                        con.push_back(row);
                                }
                        }
                }

                return fn;
        }

        template <class Sequence, typename Function>
        Function store_if(Sequence& con, Function fn)
        {       
                mysqlpp::UseQueryResult res = use();
                if (res) {
                        mysqlpp::NoExceptions ne(res);
                        while (mysqlpp::Row row = res.fetch_row()) {
                                if (fn(row)) {
                                        con.push_back(row);
                                }
                        }
                }

                return fn;
        }

        StoreQueryResult store_next();

        bool more_results();

        template <class Sequence>
        void storein_sequence(Sequence& con)
        {
                storein_sequence(con, str(template_defaults));
        }

        template <class Sequence>
        void storein_sequence(Sequence& con, const SQLTypeAdapter& s)
        {
                UseQueryResult result = use(s);
                while (1) {
                        MYSQL_ROW d = result.fetch_raw_row();
                        if (!d)
                                break;
                        Row row(d, &result, result.fetch_lengths(),
                                        throw_exceptions());
                        if (!row)
                                break;
                        con.push_back(typename Sequence::value_type(row));
                }
        }

        template <class Seq>
        void storein_sequence(Seq& con, SQLQueryParms& p)
        {
                storein_sequence(con, str(p));
        }

        template <class Set>
        void storein_set(Set& con)
        {
                storein_set(con, str(template_defaults));
        }

        template <class Set>
        void storein_set(Set& con, const SQLTypeAdapter& s)
        {
                UseQueryResult result = use(s);
                while (1) {
                        MYSQL_ROW d = result.fetch_raw_row();
                        if (!d)
                                return;
                        Row row(d, &result, result.fetch_lengths(),
                                        throw_exceptions());
                        if (!row)
                                break;
                        con.insert(typename Set::value_type(row));
                }
        }

        template <class Set>
        void storein_set(Set& con, SQLQueryParms& p)
        {
                storein_set(con, str(p));
        }

        template <class Container>
        void storein(Container& con)
        {
                storein(con, str(template_defaults));
        }

        template <class T>
        void storein(T& con, SQLQueryParms& p)
        {
                storein(con, str(p));
        }

        template <class T>
        void storein(std::vector<T>& con, const SQLTypeAdapter& s)
        {
                storein_sequence(con, s);
        }

        template <class T>
        void storein(std::deque<T>& con, const SQLTypeAdapter& s)
        {
                storein_sequence(con, s);
        }

        template <class T>
        void storein(std::list<T>& con, const SQLTypeAdapter& s)
        {
                storein_sequence(con, s);
        }

#if defined(HAVE_EXT_SLIST)
        template <class T>
        void storein(__gnu_cxx::slist<T>& con, const SQLTypeAdapter& s)
        {
                storein_sequence(con, s);
        }
#elif defined(HAVE_GLOBAL_SLIST)
        template <class T>
        void storein(slist<T>& con, const SQLTypeAdapter& s)
        {
                storein_sequence(con, s);
        }
#elif defined(HAVE_STD_SLIST)
        template <class T>
        void storein(std::slist<T>& con, const SQLTypeAdapter& s)
        {
                storein_sequence(con, s);
        }
#endif

        template <class T>
        void storein(std::set<T>& con, const SQLTypeAdapter& s)
        {
                storein_set(con, s);
        }

        template <class T>
        void storein(std::multiset<T>& con, const SQLTypeAdapter& s)
        {
                storein_set(con, s);
        }

        template <class T>
        Query& update(const T& o, const T& n)
        {
                reset();

                // Cast required for VC++ 2003 due to error in overloaded operator
                // lookup logic.  For an explanation of the problem, see:
                // http://groups-beta.google.com/group/microsoft.public.vc.stl/browse_thread/thread/9a68d84644e64f15
                MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
                                "UPDATE " << o.table() << " SET " << n.equal_list() <<
                                " WHERE " << o.equal_list(" AND ", sql_use_compare);
                return *this;
        }

        template <class T>
        Query& insert(const T& v)
        {
                reset();

                MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
                                "INSERT INTO " << v.table() << " (" <<
                                v.field_list() << ") VALUES (" <<
                                v.value_list() << ')';
                return *this;
        }

        template <class Iter>
        Query& insert(Iter first, Iter last)
        {
                reset();
                if (first == last) {
                        return *this;   // empty set!
                }
                
                MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
                                "INSERT INTO " << first->table() << " (" <<
                                first->field_list() << ") VALUES (" <<
                                first->value_list() << ')';

                Iter it = first + 1;
                while (it != last) {
                        MYSQLPP_QUERY_THISPTR << ",(" << it->value_list() << ')';
                        ++it;
                }

                return *this;
        }

        template <class T>
        Query& replace(const T& v)
        {
                reset();

                MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
                                "REPLACE INTO " << v.table() << " (" <<
                                v.field_list() << ") VALUES (" << v.value_list() << ')';
                return *this;
        }

#if !defined(DOXYGEN_IGNORE)
        // Declare the remaining overloads.  These are hidden down here partly
        // to keep the above code clear, but also so that we may hide them
        // from Doxygen, which gets confused by macro instantiations that look
        // like method declarations.
        mysql_query_define0(std::string, str)
        mysql_query_define0(SimpleResult, execute)
        mysql_query_define0(StoreQueryResult, store)
        mysql_query_define0(UseQueryResult, use)
        mysql_query_define1(storein_sequence)
        mysql_query_define1(storein_set)
        mysql_query_define1(storein)
#endif // !defined(DOXYGEN_IGNORE)

        SQLQueryParms template_defaults;

private:
        friend class SQLQueryParms;

        Connection* conn_;

        bool copacetic_;

        std::vector<SQLParseElement> parse_elems_;

        std::vector<std::string> parsed_names_;

        std::map<std::string, short int> parsed_nums_;

        std::stringbuf sbuffer_;

        void proc(SQLQueryParms& p);

        SQLTypeAdapter* pprepare(char option, SQLTypeAdapter& S, bool replace = true);
};


inline std::ostream& operator <<(std::ostream& os, Query& q)
{
        return os << q.str();
}


} // end namespace mysqlpp

#endif // !defined(MYSQLPP_QUERY_H)

---