00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #ifndef MYSQLPP_RESULT_H
00029 #define MYSQLPP_RESULT_H
00030
00031 #include "common.h"
00032
00033 #include "exceptions.h"
00034 #include "fields.h"
00035 #include "field_names.h"
00036 #include "field_types.h"
00037 #include "noexceptions.h"
00038 #include "resiter.h"
00039 #include "row.h"
00040
00041 #include <map>
00042 #include <set>
00043 #include <string>
00044
00045 namespace mysqlpp {
00046
00047 #if !defined(DOXYGEN_IGNORE)
00048
00049 class MYSQLPP_EXPORT Connection;
00050 #endif
00051
00061
00062 class MYSQLPP_EXPORT ResUse : public OptionalExceptions
00063 {
00064 public:
00066 ResUse() :
00067 OptionalExceptions(),
00068 conn_(0),
00069 result_(0),
00070 initialized_(false),
00071 names_(0),
00072 types_(0),
00073 fields_(this)
00074 {
00075 }
00076
00078 ResUse(MYSQL_RES* result, Connection* c = 0, bool te = true);
00079
00081 ResUse(const ResUse& other) :
00082 OptionalExceptions(),
00083 initialized_(false)
00084 {
00085 copy(other);
00086 other.result_ = 0;
00087 }
00088
00090 virtual ~ResUse();
00091
00093 ResUse& operator =(const ResUse& other);
00094
00096 MYSQL_RES* raw_result()
00097 {
00098 return result_;
00099 }
00100
00105 Row fetch_row()
00106 {
00107 if (!result_) {
00108 if (throw_exceptions()) {
00109 throw BadQuery("Results not fetched");
00110 }
00111 else {
00112 return Row();
00113 }
00114 }
00115 MYSQL_ROW row = mysql_fetch_row(result_);
00116 unsigned long* length = mysql_fetch_lengths(result_);
00117 if (!row || !length) {
00118 if (throw_exceptions()) {
00119 throw EndOfResults();
00120 }
00121 else {
00122 return Row();
00123 }
00124 }
00125 return Row(row, this, length, throw_exceptions());
00126 }
00127
00129 unsigned long *fetch_lengths() const
00130 {
00131 return mysql_fetch_lengths(result_);
00132 }
00133
00135 Field& fetch_field() const
00136 {
00137 return *mysql_fetch_field(result_);
00138 }
00139
00141 void field_seek(int field)
00142 {
00143 mysql_field_seek(result_, field);
00144 }
00145
00147 int num_fields() const
00148 {
00149 return mysql_num_fields(result_);
00150 }
00151
00153 void parent_leaving()
00154 {
00155 conn_ = 0;
00156 }
00157
00163 void purge()
00164 {
00165 if (result_) {
00166 mysql_free_result(result_);
00167 result_ = 0;
00168 }
00169
00170 delete names_;
00171 names_ = 0;
00172
00173 delete types_;
00174 types_ = 0;
00175
00176 table_.erase();
00177 }
00178
00192 operator bool() const
00193 {
00194 return result_;
00195 }
00196
00198 unsigned int columns() const
00199 {
00200 return num_fields();
00201 }
00202
00204 std::string& table()
00205 {
00206 return table_;
00207 }
00208
00212 const std::string& table() const
00213 {
00214 return table_;
00215 }
00216
00220 int field_num(const std::string&) const;
00221
00225 std::string& field_name(int);
00226
00228 const std::string& field_name(int) const;
00229
00231 FieldNames& field_names();
00232
00234 const FieldNames& field_names() const;
00235
00238 void reset_field_names();
00239
00241 mysql_type_info& field_type(int i);
00242
00244 const mysql_type_info& field_type(int) const;
00245
00248 FieldTypes& field_types();
00249
00252 const FieldTypes& field_types() const;
00253
00255 void reset_field_types();
00256
00258 int names(const std::string & s) const { return field_num(s); }
00259
00261 std::string& names(int i) { return field_name(i); }
00262
00264 const std::string& names(int i) const { return field_name(i); }
00265
00267 FieldNames& names() { return field_names(); }
00268
00270 const FieldNames& names() const { return field_names(); }
00271
00273 void reset_names() { reset_field_names(); }
00274
00276 mysql_type_info& types(int i) { return field_type(i); }
00277
00279 const mysql_type_info& types(int i) const { return field_type(i); }
00280
00282 FieldTypes& types() { return field_types(); }
00283
00285 const FieldTypes& types() const { return field_types(); }
00286
00288 void reset_types() { reset_field_types(); }
00289
00291 const Fields& fields() const { return fields_; }
00292
00294 const Field& fields(unsigned int i) const { return fields_.at(i); }
00295
00301 bool operator ==(const ResUse& other) const
00302 {
00303 return result_ == other.result_;
00304 }
00305
00308 bool operator !=(const ResUse& other) const
00309 {
00310 return result_ != other.result_;
00311 }
00312
00313 protected:
00314 Connection* conn_;
00315 mutable MYSQL_RES* result_;
00316 bool initialized_;
00317 mutable FieldNames* names_;
00318 mutable FieldTypes* types_;
00319 Fields fields_;
00320 std::string table_;
00321
00325 void copy(const ResUse& other);
00326 };
00327
00328
00340
00341 class MYSQLPP_EXPORT Result : public ResUse,
00342 public const_subscript_container<Result, Row, const Row>
00343 {
00344 public:
00346 Result()
00347 {
00348 }
00349
00351 Result(MYSQL_RES* result, bool te = true) :
00352 ResUse(result, 0, te)
00353 {
00354 }
00355
00357 Result(const Result& other) :
00358 ResUse(other),
00359 const_subscript_container<Result, Row, const Row>()
00360 {
00361 conn_ = 0;
00362 }
00363
00365 virtual ~Result() { }
00366
00372 const Row fetch_row() const
00373 {
00374 if (!result_) {
00375 if (throw_exceptions()) {
00376 throw BadQuery("Results not fetched");
00377 }
00378 else {
00379 return Row();
00380 }
00381 }
00382 MYSQL_ROW row = mysql_fetch_row(result_);
00383 unsigned long* length = mysql_fetch_lengths(result_);
00384 if (!row || !length) {
00385 if (throw_exceptions()) {
00386 throw EndOfResults();
00387 }
00388 else {
00389 return Row();
00390 }
00391 }
00392 return Row(row, this, length, throw_exceptions());
00393 }
00394
00396 my_ulonglong num_rows() const
00397 {
00398 if (initialized_)
00399 return mysql_num_rows(result_);
00400 else
00401 return 0;
00402 }
00403
00405 void data_seek(uint offset) const
00406 {
00407 mysql_data_seek(result_, offset);
00408 }
00409
00411 size_type size() const
00412 {
00413 return size_type(num_rows());
00414 }
00415
00417 size_type rows() const
00418 {
00419 return size_type(num_rows());
00420 }
00421
00423 const Row at(size_type i) const
00424 {
00425 data_seek(i);
00426 return fetch_row();
00427 }
00428 };
00429
00430
00432 inline void swap(ResUse& x, ResUse& y)
00433 {
00434 ResUse tmp = x;
00435 x = y;
00436 y = tmp;
00437 }
00438
00440 inline void swap(Result& x, Result& y)
00441 {
00442 Result tmp = x;
00443 x = y;
00444 y = tmp;
00445 }
00446
00449 class MYSQLPP_EXPORT ResNSel
00450 {
00451 public:
00452 bool success;
00453 my_ulonglong insert_id;
00454 my_ulonglong rows;
00455 std::string info;
00456
00457 ResNSel() :
00458 success(false)
00459 {
00460 }
00461
00463 ResNSel(Connection* q);
00464
00466 operator bool() { return success; }
00467 };
00468
00469
00470 }
00471
00472 #endif