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

result.h

Go to the documentation of this file.
00001 
00002 
00003 
00004 /***********************************************************************
00005  Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
00006  MySQL AB, and (c) 2004, 2005 by Educational Technology Resources, Inc.
00007  Others may also hold copyrights on code in this file.  See the CREDITS
00008  file in the top directory of the distribution for details.
00009 
00010  This file is part of MySQL++.
00011 
00012  MySQL++ is free software; you can redistribute it and/or modify it
00013  under the terms of the GNU Lesser General Public License as published
00014  by the Free Software Foundation; either version 2.1 of the License, or
00015  (at your option) any later version.
00016 
00017  MySQL++ is distributed in the hope that it will be useful, but WITHOUT
00018  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
00019  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
00020  License for more details.
00021 
00022  You should have received a copy of the GNU Lesser General Public
00023  License along with MySQL++; if not, write to the Free Software
00024  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
00025  USA
00026 ***********************************************************************/
00027 
00028 #ifndef MYSQLPP_RESULT_H
00029 #define MYSQLPP_RESULT_H
00030 
00031 #include "defs.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 <mysql.h>
00042 
00043 #include <map>
00044 #include <set>
00045 #include <string>
00046 
00047 namespace mysqlpp {
00048 
00049 class Connection;
00050 
00060 
00061 class ResUse : public OptionalExceptions
00062 {
00063 public:
00065         ResUse() :
00066         OptionalExceptions(),
00067         conn_(0),
00068         result_(0),
00069         initialized_(false),
00070         names_(0),
00071         types_(0),
00072         fields_(this)
00073         {
00074         }
00075         
00077         MYSQLPP_EXPORT ResUse(MYSQL_RES* result, Connection* c = 0, bool te = true);
00078         
00080         ResUse(const ResUse& other) :
00081         OptionalExceptions(),
00082         initialized_(false)
00083         {
00084                 copy(other);
00085         }
00086         
00088         MYSQLPP_EXPORT virtual ~ResUse();
00089 
00091         ResUse& operator =(const ResUse& other);
00092 
00094         MYSQL_RES* raw_result()
00095         {
00096                 return result_;
00097         }
00098 
00103         Row fetch_row()
00104         {
00105                 if (!result_) {
00106                         if (throw_exceptions()) {
00107                                 throw BadQuery("Results not fetched");
00108                         }
00109                         else {
00110                                 return Row();
00111                         }
00112                 }
00113                 MYSQL_ROW row = mysql_fetch_row(result_);
00114                 unsigned long* length = mysql_fetch_lengths(result_);
00115                 if (!row || !length) {
00116                         if (throw_exceptions()) {
00117                                 throw EndOfResults();
00118                         }
00119                         else {
00120                                 return Row();
00121                         }
00122                 }
00123                 return Row(row, this, length, throw_exceptions());
00124         }
00125 
00127         unsigned long *fetch_lengths() const
00128         {
00129                 return mysql_fetch_lengths(result_);
00130         }
00131 
00133         Field& fetch_field() const
00134         {
00135                 return *mysql_fetch_field(result_);
00136         }
00137 
00139         void field_seek(int field)
00140         {
00141                 mysql_field_seek(result_, field);
00142         }
00143 
00145         int num_fields() const
00146         {
00147                 return mysql_num_fields(result_);
00148         }
00149         
00151         void parent_leaving()
00152         {
00153                 conn_ = 0;
00154         }
00155 
00161         void purge()
00162         {
00163                 if (result_) {
00164                         mysql_free_result(result_);
00165                         result_ = 0;
00166                 }
00167 
00168                 delete names_;
00169                 names_ = 0;
00170 
00171                 delete types_;
00172                 types_ = 0;
00173 
00174                 table_.erase();
00175         }
00176 
00190         operator bool() const
00191         {
00192                 return result_;
00193         }
00194         
00196         unsigned int columns() const
00197         {
00198                 return num_fields();
00199         }
00200 
00202         std::string& table()
00203         {
00204                 return table_;
00205         }
00206 
00210         const std::string& table() const
00211         {
00212                 return table_;
00213         }
00214 
00218         MYSQLPP_EXPORT inline int field_num(const std::string&) const;
00219 
00223         MYSQLPP_EXPORT inline std::string& field_name(int);
00224 
00226         MYSQLPP_EXPORT inline const std::string& field_name(int) const;
00227 
00229         MYSQLPP_EXPORT inline FieldNames& field_names();
00230 
00232         MYSQLPP_EXPORT inline const FieldNames& field_names() const;
00233 
00236         MYSQLPP_EXPORT inline void reset_field_names();
00237 
00239         MYSQLPP_EXPORT inline mysql_type_info& field_type(int i);
00240 
00242         MYSQLPP_EXPORT inline const mysql_type_info& field_type(int) const;
00243 
00246         MYSQLPP_EXPORT inline FieldTypes& field_types();
00247 
00250         MYSQLPP_EXPORT inline const FieldTypes& field_types() const;
00251 
00253         MYSQLPP_EXPORT inline void reset_field_types();
00254 
00256         MYSQLPP_EXPORT inline int names(const std::string & s) const;
00257 
00259         MYSQLPP_EXPORT inline std::string& names(int i);
00260 
00262         MYSQLPP_EXPORT inline const std::string& names(int i) const;
00263 
00265         MYSQLPP_EXPORT inline FieldNames& names();
00266 
00268         MYSQLPP_EXPORT inline const FieldNames& names() const;
00269 
00271         MYSQLPP_EXPORT inline void reset_names();
00272 
00274         MYSQLPP_EXPORT inline mysql_type_info& types(int i);
00275 
00277         MYSQLPP_EXPORT inline const mysql_type_info& types(int i) const;
00278 
00280         MYSQLPP_EXPORT inline FieldTypes& types();
00281 
00283         MYSQLPP_EXPORT inline const FieldTypes& types() const;
00284 
00286         MYSQLPP_EXPORT inline void reset_types();
00287 
00289         const Fields& fields() const
00290         {
00291                 return fields_;
00292         }
00293 
00295         const Field& fields(unsigned int i) const
00296         {
00297                 return fields_.at(i);
00298         }
00299         
00305         bool operator ==(const ResUse& other) const
00306         {
00307                 return result_ == other.result_;
00308         }
00309         
00312         bool operator !=(const ResUse& other) const
00313         {
00314                 return result_ != other.result_;
00315         }
00316 
00317 protected:
00318         Connection* conn_;                      
00319         mutable MYSQL_RES* result_;     
00320         bool initialized_;                      
00321         mutable FieldNames* names_;     
00322         mutable FieldTypes* types_;     
00323         Fields fields_;                         
00324         std::string table_;                     
00325 
00329         MYSQLPP_EXPORT void copy(const ResUse& other);
00330 };
00331 
00332 
00344 
00345 class Result : public ResUse,
00346                 public const_subscript_container<Result, Row, const Row>
00347 {
00348 public:
00350         Result()
00351         {
00352         }
00353         
00355         Result(MYSQL_RES* result, bool te = true) :
00356         ResUse(result, 0, te)
00357         {
00358         }
00359 
00361         Result(const Result& other) :
00362         ResUse(other),
00363         const_subscript_container<Result, Row, const Row>() // no copying here
00364         {
00365                 conn_ = 0;
00366         }
00367 
00369         virtual ~Result() { }
00370 
00376         const Row fetch_row() const
00377         {
00378                 if (!result_) {
00379                         if (throw_exceptions()) {
00380                                 throw BadQuery("Results not fetched");
00381                         }
00382                         else {
00383                                 return Row();
00384                         }
00385                 }
00386                 MYSQL_ROW row = mysql_fetch_row(result_);
00387                 unsigned long* length = mysql_fetch_lengths(result_);
00388                 if (!row || !length) {
00389                         if (throw_exceptions()) {
00390                                 throw EndOfResults();
00391                         }
00392                         else {
00393                                 return Row();
00394                         }
00395                 }
00396                 return Row(row, this, length, throw_exceptions());
00397         }
00398 
00400         my_ulonglong num_rows() const
00401         {
00402                 if (initialized_)
00403                         return mysql_num_rows(result_);
00404                 else
00405                         return 0;
00406         }
00407 
00409         void data_seek(uint offset) const
00410         {
00411                 mysql_data_seek(result_, offset);
00412         }
00413 
00415         size_type size() const
00416         {
00417                 return size_type(num_rows());
00418         }
00419 
00421         size_type rows() const
00422         {
00423                 return size_type(num_rows());
00424         }
00425 
00427         const Row at(size_type i) const
00428         {
00429                 data_seek(i);
00430                 return fetch_row();
00431         }
00432 };
00433 
00434 
00436 inline void swap(ResUse& x, ResUse& y)
00437 {
00438         ResUse tmp = x;
00439         x = y;
00440         y = tmp;
00441 }
00442 
00444 inline void swap(Result& x, Result& y)
00445 {
00446         Result tmp = x;
00447         x = y;
00448         y = tmp;
00449 }
00450 
00453 class ResNSel
00454 {
00455 public:
00456         bool success;                   
00457         my_ulonglong insert_id; 
00458         my_ulonglong rows;              
00459         std::string info;               
00460 
00461         ResNSel() :
00462         success(false)
00463         {
00464         }
00465 
00467         MYSQLPP_EXPORT ResNSel(Connection* q);
00468 
00470         operator bool() { return success; }
00471 };
00472 
00473 
00474 inline int ResUse::field_num(const std::string& i) const
00475 {
00476         if (!names_) {
00477                 names_ = new FieldNames(this);
00478         }
00479 
00480         size_t index = (*names_)[i];
00481         if ((index >= names_->size()) && throw_exceptions()) {
00482                 throw BadFieldName(i.c_str());
00483         }
00484         
00485         return int(index);
00486 }
00487 
00488 inline std::string& ResUse::field_name(int i)
00489 {
00490         if (!names_) {
00491                 names_ = new FieldNames(this);
00492         }
00493         return (*names_)[i];
00494 }
00495 
00496 inline const std::string& ResUse::field_name(int i) const
00497 {
00498         if (!names_) {
00499                 names_ = new FieldNames(this);
00500         }
00501         return (*names_)[i];
00502 }
00503 
00504 inline FieldNames& ResUse::field_names()
00505 {
00506         if (!names_) {
00507                 names_ = new FieldNames(this);
00508         }
00509         return *names_;
00510 }
00511 
00512 inline const FieldNames& ResUse::field_names() const
00513 {
00514         if (!names_) {
00515                 names_ = new FieldNames(this);
00516         }
00517         return *names_;
00518 }
00519 
00520 inline void ResUse::reset_field_names()
00521 {
00522         delete names_;
00523         names_ = 0;
00524         names_ = new FieldNames(this);
00525 }
00526 
00527 inline mysql_type_info& ResUse::field_type(int i)
00528 {
00529         if (!types_) {
00530                 types_ = new FieldTypes(this);
00531         }
00532         return (*types_)[i];
00533 }
00534 
00535 inline const mysql_type_info& ResUse::field_type(int i) const
00536 {
00537         if (!types_) {
00538                 types_ = new FieldTypes(this);
00539         }
00540         return (*types_)[i];
00541 }
00542 
00543 inline FieldTypes& ResUse::field_types()
00544 {
00545         if (!types_) {
00546                 types_ = new FieldTypes(this);
00547         }
00548         return *types_;
00549 }
00550 
00551 inline const FieldTypes& ResUse::field_types() const
00552 {
00553         if (!types_) {
00554                 types_ = new FieldTypes(this);
00555         }
00556         return *types_;
00557 }
00558 
00559 inline void ResUse::reset_field_types()
00560 {
00561         delete types_;
00562         types_ = 0;
00563         types_ = new FieldTypes(this);
00564 }
00565 
00566 inline int ResUse::names(const std::string& s) const
00567 {
00568         return field_num(s);
00569 }
00570 
00571 inline std::string& ResUse::names(int i)
00572 {
00573         return field_name(i);
00574 }
00575 
00576 inline const std::string& ResUse::names(int i) const
00577 {
00578         return field_name(i);
00579 }
00580 
00581 inline FieldNames& ResUse::names()
00582 {
00583         return field_names();
00584 }
00585 
00586 inline const FieldNames& ResUse::names() const
00587 {
00588         return field_names();
00589 }
00590 
00591 inline void ResUse::reset_names()
00592 {
00593         reset_field_names();
00594 }
00595 
00596 inline mysql_type_info& ResUse::types(int i)
00597 {
00598         return field_type(i);
00599 }
00600 
00601 inline const mysql_type_info& ResUse::types(int i) const
00602 {
00603         return field_type(i);
00604 }
00605 
00606 inline FieldTypes& ResUse::types()
00607 {
00608         return field_types();
00609 }
00610 
00611 inline const FieldTypes& ResUse::types() const
00612 {
00613         return field_types();
00614 }
00615 
00616 inline void ResUse::reset_types()
00617 {
00618         reset_field_types();
00619 }
00620 
00621 inline ResUse& ResUse::operator =(const ResUse& other)
00622 {
00623         if (this == &other) {
00624                 return *this;
00625         }
00626         copy(other);
00627         other.result_ = 0;
00628         return *this;
00629 }
00630 
00631 } // end namespace mysqlpp
00632 
00633 #endif

Generated on Thu Aug 25 06:12:11 2005 for MySQL++ by doxygen1.2.18