MySQL++  3.2.5
result.h
Go to the documentation of this file.
1 
5 /***********************************************************************
6  Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
7  (c) 2004-2007 by Educational Technology Resources, Inc. Others may
8  also hold copyrights on code in this file. See the CREDITS.txt file
9  in the top directory of the distribution for details.
10 
11  This file is part of MySQL++.
12 
13  MySQL++ is free software; you can redistribute it and/or modify it
14  under the terms of the GNU Lesser General Public License as published
15  by the Free Software Foundation; either version 2.1 of the License, or
16  (at your option) any later version.
17 
18  MySQL++ is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
20  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
21  License for more details.
22 
23  You should have received a copy of the GNU Lesser General Public
24  License along with MySQL++; if not, write to the Free Software
25  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
26  USA
27 ***********************************************************************/
28 
29 #if !defined(MYSQLPP_RESULT_H)
30 #define MYSQLPP_RESULT_H
31 
32 #include "common.h"
33 
34 #include "exceptions.h"
35 #include "field.h"
36 #include "field_names.h"
37 #include "field_types.h"
38 #include "noexceptions.h"
39 #include "refcounted.h"
40 #include "row.h"
41 
42 namespace mysqlpp {
43 
44 
47 
48 class MYSQLPP_EXPORT SimpleResult
49 {
50 private:
55  typedef bool SimpleResult::*private_bool_type;
56 
57 public:
59  SimpleResult() :
60  copacetic_(false),
61  insert_id_(0),
62  rows_(0)
63  {
64  }
65 
67  SimpleResult(bool copacetic, ulonglong insert_id,
68  ulonglong rows, const std::string& info) :
69  copacetic_(copacetic),
70  insert_id_(insert_id),
71  rows_(rows),
72  info_(info)
73  {
74  }
75 
82  operator private_bool_type() const
83  {
84  return copacetic_ ? &SimpleResult::copacetic_ : 0;
85  }
86 
88  ulonglong insert_id() const { return insert_id_; }
89 
91  ulonglong rows() const { return rows_; }
92 
95  const char* info() const { return info_.c_str(); }
96 
97 private:
98  bool copacetic_;
99  ulonglong insert_id_;
100  ulonglong rows_;
101  std::string info_;
102 };
103 
104 
109 
110 class MYSQLPP_EXPORT ResultBase : public OptionalExceptions
111 {
112 public:
114  virtual ~ResultBase() { }
115 
117  const Field& fetch_field() const
118  { return fields_.at(current_field_++); }
119 
121  const Field& fetch_field(Fields::size_type i) const
122  { return fields_.at(i); }
123 
125  const Field& field(unsigned int i) const { return fields_.at(i); }
126 
128  const Fields& fields() const { return fields_; }
129 
131  const std::string& field_name(int i) const
132  { return names_->at(i); }
133 
135  const RefCountedPointer<FieldNames>& field_names() const
136  { return names_; }
137 
141  int field_num(const std::string&) const;
142 
144  const FieldTypes::value_type& field_type(int i) const
145  { return types_->at(i); }
146 
149  const RefCountedPointer<FieldTypes>& field_types() const
150  { return types_; }
151 
153  size_t num_fields() const { return fields_.size(); }
154 
156  const char* table() const
157  { return fields_.empty() ? "" : fields_[0].table(); }
158 
159 protected:
161  ResultBase() :
162  driver_(0),
163  current_field_(0)
164  {
165  }
166 
168  ResultBase(MYSQL_RES* result, DBDriver* dbd, bool te = true);
169 
171  ResultBase(const ResultBase& other) :
173  {
174  copy(other);
175  }
176 
178  ResultBase& copy(const ResultBase& other);
179 
180  DBDriver* driver_;
181  Fields fields_;
182 
185 
188 
196  mutable Fields::size_type current_field_;
197 };
198 
199 
208 
209 class MYSQLPP_EXPORT StoreQueryResult :
210  public ResultBase,
211  public std::vector<Row>
212 {
213 private:
218  typedef bool StoreQueryResult::*private_bool_type;
219 
220 public:
221  typedef std::vector<Row> list_type;
222 
224  StoreQueryResult() :
225  ResultBase(),
226  copacetic_(false)
227  {
228  }
229 
231  StoreQueryResult(MYSQL_RES* result, DBDriver* dbd, bool te = true);
232 
235  StoreQueryResult(const StoreQueryResult& other) :
236  ResultBase(),
237  std::vector<Row>(),
238  copacetic_(false)
239  {
240  copy(other);
241  }
242 
244  ~StoreQueryResult() { }
245 
247  list_type::size_type num_rows() const { return size(); }
248 
251  StoreQueryResult& operator =(const StoreQueryResult& rhs)
252  { return this != &rhs ? copy(rhs) : *this; }
253 
260  operator private_bool_type() const
261  {
262  return copacetic_ ? &StoreQueryResult::copacetic_ : 0;
263  }
264 
265 private:
268  StoreQueryResult& copy(const StoreQueryResult& other);
269 
270  bool copacetic_;
271 };
272 
273 
280 template <>
281 struct RefCountedPointerDestroyer<MYSQL_RES>
282 {
284  void operator()(MYSQL_RES* doomed) const
285  {
286  if (doomed) {
287  mysql_free_result(doomed);
288  }
289  }
290 };
291 
292 
297 
298 class MYSQLPP_EXPORT UseQueryResult : public ResultBase
299 {
300 public:
302  UseQueryResult() :
304  {
305  }
306 
308  UseQueryResult(MYSQL_RES* result, DBDriver* dbd, bool te = true);
309 
311  UseQueryResult(const UseQueryResult& other) :
312  ResultBase()
313  {
314  copy(other);
315  }
316 
318  ~UseQueryResult() { }
319 
321  UseQueryResult& operator =(const UseQueryResult& rhs)
322  { return this != &rhs ? copy(rhs) : *this; }
323 
325  const Field& fetch_field() const
326  { return fields_.at(current_field_++); }
327 
329  const Field& fetch_field(Fields::size_type i) const
330  { return fields_.at(i); }
331 
337  const unsigned long* fetch_lengths() const;
338 
346  Row fetch_row() const;
347 
354  MYSQL_ROW fetch_raw_row() const;
355 
360  void field_seek(Fields::size_type field) const
361  { current_field_ = field; }
362 
374  // it was successful:
385  operator MYSQL_RES*() const { return result_.raw(); }
386 
387 private:
389  UseQueryResult& copy(const UseQueryResult& other);
390 
401  mutable RefCountedPointer<MYSQL_RES> result_;
402 };
403 
404 
406 inline void
408 {
409  StoreQueryResult tmp = x;
410  x = y;
411  y = tmp;
412 }
413 
415 inline void
417 {
418  UseQueryResult tmp = x;
419  x = y;
420  y = tmp;
421 }
422 
423 } // end namespace mysqlpp
424 
425 #endif // !defined(MYSQLPP_RESULT_H)
field_types.h
Declares a class to hold a list of SQL field type info.
exceptions.h
Declares the MySQL++-specific exception classes.
mysqlpp::DBDriver::fetch_row
MYSQL_ROW fetch_row(MYSQL_RES *res) const
Returns the next raw C API row structure from the given result set.
Definition: dbdriver.h:342
refcounted.h
Declares the RefCountedPointer template.
mysqlpp::Row
Manages rows from a result set.
Definition: row.h:85
mysqlpp::ResultBase::ResultBase
ResultBase()
Create empty object.
Definition: result.h:183
mysqlpp::UseQueryResult
StoreQueryResult set type for "use" queries.
Definition: result.h:320
mysqlpp::UseQueryResult::fetch_raw_row
MYSQL_ROW fetch_raw_row() const
Wraps mysql_fetch_row() in MySQL C API.
Definition: result.cpp:228
mysqlpp::ResultBase
Base class for StoreQueryResult and UseQueryResult.
Definition: result.h:132
mysqlpp::UseQueryResult::fetch_row
Row fetch_row() const
Returns the next row in a "use" query's result set.
Definition: result.cpp:191
mysqlpp::RefCountedPointer::raw
T * raw()
Return the raw pointer in T* context.
Definition: refcounted.h:254
mysqlpp::StoreQueryResult
StoreQueryResult set type for "store" queries.
Definition: result.h:231
mysqlpp::DBDriver
Provides a thin abstraction layer over the underlying database client library.
Definition: dbdriver.h:79
mysqlpp::DBDriver::free_result
void free_result(MYSQL_RES *res) const
Releases memory used by a result set.
Definition: dbdriver.h:391
mysqlpp::UseQueryResult::UseQueryResult
UseQueryResult()
Default constructor.
Definition: result.h:324
mysqlpp::RefCountedPointer
Creates an object that acts as a reference-counted pointer to another object.
Definition: refcounted.h:104
mysqlpp::DBDriver::fetch_lengths
const unsigned long * fetch_lengths(MYSQL_RES *res) const
Returns the lengths of the fields in the current row from a "use" query.
Definition: dbdriver.h:352
field_names.h
Declares a class to hold a list of field names.
dbdriver.h
Declares the DBDriver class.
mysqlpp::RefCountedPointerDestroyer
Functor to call delete on the pointer you pass to it.
Definition: refcounted.h:69
mysqlpp::UseQueryResult::fetch_lengths
const unsigned long * fetch_lengths() const
Returns the lengths of the fields in the current row of the result set.
Definition: result.cpp:184
mysqlpp::Fields
std::vector< Field > Fields
The list-of-Fields type.
Definition: field.h:174
row.h
Declares the classes for holding row data from a result set.
noexceptions.h
Declares interface that allows exceptions to be optional.
field.h
Declares the Field and Fields classes.
result.h
Declares classes for holding information about SQL query results.
common.h
This file includes top-level definitions for use both internal to the library, and outside it....
mysqlpp::Field
Class to hold information about a SQL field.
Definition: field.h:67
mysqlpp::ResultBase::driver_
DBDriver * driver_
Access to DB driver; fully initted if nonzero.
Definition: result.h:202
mysqlpp::OptionalExceptions
Interface allowing a class to have optional exceptions.
Definition: noexceptions.h:92
mysqlpp::swap
void swap(StoreQueryResult &x, StoreQueryResult &y)
Swaps two StoreQueryResult objects.
Definition: result.h:429
mysqlpp::UseQueryError
Exception thrown when something goes wrong in processing a "use" query.
Definition: exceptions.h:276
mysqlpp::BadFieldName
Exception thrown when a requested named field doesn't exist.
Definition: exceptions.h:183
mysqlpp::ResultBase::copy
ResultBase & copy(const ResultBase &other)
Copy another ResultBase object's contents into this one.
Definition: result.cpp:82
mysqlpp::RefCountedPointerDestroyer::operator()
void operator()(T *doomed) const
Functor implementation.
Definition: refcounted.h:94
mysqlpp::OptionalExceptions::throw_exceptions
bool throw_exceptions() const
Returns true if exceptions are enabled.
Definition: noexceptions.h:134