Query.cpp Source File - SOAP to CORBA bridge

00001 // /******************************************************************************\
00002 // *
00003 // * File:          Query.cpp
00004 // * Creation date: May 17, 2001 14:24
00005 // * Author:        ClassBuilder
00006 // *                XXXX
00007 // * Purpose:       Method implementations of class 'DOQuery'
00008 // *
00009 // * Modifications: @INSERT_MODIFICATIONS(* )
00010 // * May 18, 2001 10:18 WERS
00011 // *     Updated code of method 'Seek'
00012 // *     Updated code of method 'Query'
00013 // *     Updated code of method 'GetNumRows'
00014 // *     Updated code of method 'GetNumFields'
00015 // *     Updated code of method 'FindQueryField'
00016 // *     Updated code of method 'Fetch'
00017 // * May 17, 2001 15:15 WERS
00018 // *     Added method 'GetRow'
00019 // *     Added method 'Seek'
00020 // *     Added method 'Fetch'
00021 // *     Added member 'm_row'
00022 // *     Updated code of method 'Query'
00023 // * May 17, 2001 14:55 WERS
00024 // *     Added method 'FindQueryField'
00025 // *     Added method 'FindQueryField'
00026 // * May 17, 2001 14:41 WERS
00027 // *     Added method 'GetNumFields'
00028 // *     Added relation 'Query(DOQuery) <>-->> QueryField(DOQueryField)'
00029 // *     Updated interface of method 'ConstructorInclude'
00030 // *     Updated interface of method 'Query'
00031 // * May 17, 2001 14:24 WERS
00032 // *     Added method 'DOQuery'
00033 // * May 17, 2001 14:24 WERS
00034 // *     Added method 'DestructorInclude'
00035 // *     Added method 'ConstructorInclude'
00036 // *     Added method 'Query'
00037 // *     Added method '~DOQuery'
00038 // *     Added relation 'Connection(DOConnection) <>-->> Query(DOQuery)'
00039 // *     Added member 'm_query'
00040 // *     Added member 'm_pRes'
00041 // *
00042 // *
00043 // \******************************************************************************/
00044 //@START_USER1
00049 /* --------------------------------------------------------------
00050 Copyright (C) 2001 LifeLine Networks BV <soap2corba@lifeline.nl>
00051 
00052 This program is free software; you can redistribute it and/or
00053 modify it under the terms of the GNU General Public License
00054 as published by the Free Software Foundation; either
00055 version 2 of the License, or (at your option) any later
00056 version.
00057 
00058 This program is distributed in the hope that it will be useful,
00059 but WITHOUT ANY WARRANTY; without even the implied warranty of
00060 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00061 GNU General Public License for more details.
00062 
00063 You should have received a copy of the GNU General Public License
00064 along with this program; if not, write to the Free Software
00065 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00066 -------------------------------------------------------------- */
00067 //@END_USER1
00068 
00069 
00070 // Master include file
00071 #include "DbObjects.h"
00072 
00073 
00074 //@START_USER2
00075 //@END_USER2
00076 
00077 
00078 // Static members
00079 
00080 
00084 DOQuery::DOQuery(DOConnection* pConnection) //@INIT_144
00085     : m_pRes(NULL)
00086     , m_query()
00087     , m_row(0)
00088 {//@CODE_144
00089     ConstructorInclude(pConnection);
00090 
00091     // Put in your own code
00092 }//@CODE_144
00093 
00094 
00098 DOQuery::~DOQuery()
00099 {//@CODE_53
00100     DestructorInclude();
00101 
00102     if (m_pRes) {
00103         mysql_free_result (m_pRes);
00104     }
00105 }//@CODE_53
00106 
00107 
00111 bool DOQuery::Fetch()
00112 {//@CODE_259
00113     if (m_pRes) {
00114         m_row = mysql_fetch_row (m_pRes);
00115     }
00116     return m_row != 0;
00117 }//@CODE_259
00118 
00119 
00120 DOQueryField* DOQuery::FindQueryField(unsigned int number)
00121 {//@CODE_246
00122     QueryFieldIterator iQueryField(this);
00123     while (++iQueryField)
00124     {
00125         if (number == iQueryField->GetNumber())
00126         {
00127             return iQueryField;
00128         }
00129     }
00130 
00131     return 0;
00132 }//@CODE_246
00133 
00134 
00138 DOQueryField* DOQuery::FindQueryField(const char* fldName)
00139 {//@CODE_248
00140     CString fnam = fldName;
00141     QueryFieldIterator iQueryField(this);
00142     while (++iQueryField)
00143     {
00144         if (fnam.CompareNoCase (iQueryField->GetName()) == 0)
00145         {
00146             return iQueryField;
00147         }
00148     }
00149 
00150     return 0;
00151 }//@CODE_248
00152 
00153 
00161 bool DOQuery::Query(const char* pszSQL)
00162 {//@CODE_141
00163     DeleteAllQueryField();
00164     m_row = 0;
00165     if (m_pRes) {
00166         mysql_free_result (m_pRes);
00167         m_pRes = NULL;
00168     }
00169     m_query = pszSQL;
00170     if (!mysql_query (GetConnection()->GetHdl(), m_query)) {
00171         m_pRes = mysql_store_result (GetConnection()->GetHdl());
00172         unsigned int numFlds = GetNumFields ();
00173         if (numFlds) {
00174             MYSQL_FIELD *flds = mysql_fetch_fields (m_pRes);
00175             unsigned int i;
00176             for (i = 0; i < numFlds; i ++) {
00177                 (void) new DOQueryField (this, i, flds + i);
00178             }
00179             Fetch ();
00180         }
00181         return true;
00182     }
00183     fprintf (stderr, "MySQL error for (%s): %s\n", (const char *) m_query, 
00184         mysql_error (GetConnection()->GetHdl()));
00185     return false;
00186     
00187 }//@CODE_141
00188 
00189 
00190 //{{AFX DO NOT EDIT CODE BELOW THIS LINE !!!
00191 
00195 void DOQuery::ConstructorInclude(DOConnection* pConnection)
00196 {
00197     // INIT_MULTI_OWNED_ACTIVE(DOQuery, Query, DOQueryField, QueryField)
00198    
00199     _firstQueryField = (DOQueryField*)0;
00200     _lastQueryField = (DOQueryField*)0;
00201     _countQueryField = 0;
00202     // INIT_MULTI_OWNED_PASSIVE(DOConnection, Connection, DOQuery, Query)
00203     assert(this);
00204     assert(pConnection);
00205     pConnection->_countQuery++;
00206 
00207     _refConnection = pConnection;
00208 
00209     if (pConnection->_lastQuery)
00210     {
00211         _nextConnection = (DOQuery*)0;
00212         _prevConnection = pConnection->_lastQuery;
00213         _prevConnection->_nextConnection = this;
00214         pConnection->_lastQuery = this;
00215     }
00216     else
00217     {
00218         _prevConnection = (DOQuery*)0;
00219         _nextConnection = (DOQuery*)0;
00220         pConnection->_firstQuery = pConnection->_lastQuery = this;
00221     }
00222 }
00223 
00224 
00228 void DOQuery::DestructorInclude()
00229 {
00230     // EXIT_MULTI_OWNED_ACTIVE(DOQuery, Query, DOQueryField, QueryField)
00231     { for (DOQueryField* item = GetFirstQueryField(); item; item = GetFirstQueryField())
00232           delete item; }
00233     // EXIT_MULTI_OWNED_PASSIVE(DOConnection, Connection, DOQuery, Query)
00234     
00235     assert(this);
00236     if (_refConnection)
00237     {
00238         DOConnection::QueryIterator::Check(this);
00239 
00240         _refConnection->_countQuery--;
00241 
00242         if (_nextConnection)
00243             _nextConnection->_prevConnection = _prevConnection;
00244         else
00245             _refConnection->_lastQuery = _prevConnection;
00246 
00247         if (_prevConnection)
00248             _prevConnection->_nextConnection = _nextConnection;
00249         else
00250             _refConnection->_firstQuery = _nextConnection;
00251 
00252         _prevConnection = (DOQuery*)0;
00253         _nextConnection = (DOQuery*)0;
00254         _refConnection = (DOConnection*)0;
00255     }
00256 }
00257 
00258 
00259 // Methods for the relation(s) of the class
00260 // METHODS_MULTI_OWNED_ACTIVE(DOQuery, Query, DOQueryField, QueryField)
00261 void DOQuery::AddQueryFieldFirst(DOQueryField* item)
00262 {
00263     
00264     assert(this);
00265 
00266     assert(item);
00267     assert(item->_refQuery == (DOQuery*)0);
00268 
00269     _countQueryField++;
00270 
00271     item->_refQuery = this;
00272 
00273     if (_firstQueryField)
00274     {
00275         _firstQueryField->_prevQuery = item;
00276         item->_nextQuery = _firstQueryField;
00277         _firstQueryField = item;
00278     }
00279     else
00280         _firstQueryField = _lastQueryField = item; 
00281 }
00282 
00283 void DOQuery::AddQueryFieldLast(DOQueryField* item)
00284 {
00285     
00286     assert(this);
00287 
00288     assert(item);
00289     assert(item->_refQuery == (DOQuery*)0);
00290 
00291     _countQueryField++;
00292 
00293     item->_refQuery = this;
00294 
00295     if (_lastQueryField)
00296     {
00297         _lastQueryField->_nextQuery = item;
00298         item->_prevQuery = _lastQueryField;
00299         _lastQueryField = item;
00300     }
00301     else
00302         _firstQueryField = _lastQueryField = item; 
00303 }
00304 
00305 void DOQuery::AddQueryFieldAfter(DOQueryField* item, DOQueryField* pos)
00306 {
00307     
00308     assert(this);
00309 
00310     assert(item);
00311     assert(item->_refQuery == (DOQuery*)0);
00312 
00313     assert(pos);
00314     assert(pos->_refQuery == this);
00315 
00316     _countQueryField++;
00317 
00318     item->_refQuery = this;
00319     item->_prevQuery = pos;
00320     item->_nextQuery = pos->_nextQuery;
00321     pos->_nextQuery  = item;
00322 
00323     if (item->_nextQuery)
00324         item->_nextQuery->_prevQuery = item;
00325     else
00326         _lastQueryField = item; 
00327 }
00328 
00329 void DOQuery::AddQueryFieldBefore(DOQueryField* item, DOQueryField* pos)
00330 {
00331     
00332     assert(this);
00333 
00334     assert(item);
00335     assert(item->_refQuery == (DOQuery*)0);
00336 
00337     assert(pos);
00338     assert(pos->_refQuery == this);
00339 
00340     _countQueryField++;
00341 
00342     item->_refQuery = this;
00343     item->_nextQuery = pos;
00344     item->_prevQuery = pos->_prevQuery;
00345     pos->_prevQuery  = item;
00346 
00347     if (item->_prevQuery)
00348         item->_prevQuery->_nextQuery = item;
00349     else
00350         _firstQueryField = item; 
00351 }
00352 
00353 void DOQuery::RemoveQueryField(DOQueryField* item)
00354 {
00355     
00356     assert(this);
00357 
00358     assert(item);
00359     assert(item->_refQuery == this);
00360 
00361     DOQuery::QueryFieldIterator::Check(item);
00362 
00363     _countQueryField--;
00364 
00365     if (item->_nextQuery)
00366         item->_nextQuery->_prevQuery = item->_prevQuery;
00367     else
00368         _lastQueryField = item->_prevQuery;
00369 
00370     if (item->_prevQuery)
00371         item->_prevQuery->_nextQuery = item->_nextQuery;
00372     else
00373         _firstQueryField = item->_nextQuery;
00374 
00375     item->_prevQuery = (DOQueryField*)0;
00376     item->_nextQuery = (DOQueryField*)0;
00377     item->_refQuery = (DOQuery*)0; 
00378 }
00379 
00380 void DOQuery::DeleteAllQueryField()
00381 {
00382     
00383     assert(this);
00384 
00385     for (DOQueryField* item = GetFirstQueryField(); item; item = GetFirstQueryField())
00386           delete item; 
00387 }
00388 
00389 void DOQuery::ReplaceQueryField(DOQueryField* item, DOQueryField* newItem)
00390 {
00391     
00392     assert(this);
00393 
00394     assert(item);
00395     assert(item->_refQuery == this);
00396 
00397     assert(newItem);
00398     assert(newItem->_refQuery == (DOQuery*)0);
00399 
00400     DOQuery::QueryFieldIterator::Check(item, newItem);
00401 
00402     if (item->_nextQuery)
00403         item->_nextQuery->_prevQuery = newItem;
00404     else
00405         _lastQueryField = newItem;
00406 
00407     if (item->_prevQuery)
00408         item->_prevQuery->_nextQuery = newItem;
00409     else
00410         _firstQueryField = newItem;
00411 
00412     newItem->_nextQuery = item->_nextQuery;
00413     newItem->_prevQuery = item->_prevQuery;
00414     item->_nextQuery = (DOQueryField*)0;
00415     item->_prevQuery = (DOQueryField*)0;
00416 
00417     item->_refQuery = (DOQuery*)0;
00418     newItem->_refQuery = this; 
00419 }
00420 
00421 DOQueryField* DOQuery::GetFirstQueryField() const
00422 {
00423     
00424     assert(this);
00425     return _firstQueryField; 
00426 }
00427 
00428 DOQueryField* DOQuery::GetLastQueryField() const
00429 {
00430     
00431     assert(this);
00432     return _lastQueryField; 
00433 }
00434 
00435 DOQueryField* DOQuery::GetNextQueryField(DOQueryField* pos) const
00436 {
00437     
00438     assert(this);
00439 
00440     if (pos == (DOQueryField*)0)
00441         return _firstQueryField;
00442 
00443     assert(pos);
00444     assert(pos->_refQuery == this);
00445 
00446     return pos->_nextQuery; 
00447 }
00448 
00449 DOQueryField* DOQuery::GetPrevQueryField(DOQueryField* pos) const
00450 {
00451     
00452     assert(this);
00453 
00454     if (pos == (DOQueryField*)0)
00455         return _lastQueryField;
00456 
00457     assert(pos);
00458     assert(pos->_refQuery == this);
00459 
00460     return pos->_prevQuery; 
00461 }
00462 
00463 int DOQuery::GetQueryFieldCount() const
00464 {
00465     
00466     assert(this);
00467     return _countQueryField; 
00468 }
00469 
00470 void DOQuery::MoveQueryFieldFirst(DOQueryField* item)
00471 {
00472     
00473     assert(item);
00474     assert(item->_refQuery);
00475     item->_refQuery->RemoveQueryField(item);
00476     AddQueryFieldFirst(item); 
00477 }
00478 
00479 void DOQuery::MoveQueryFieldLast(DOQueryField* item)
00480 {
00481     
00482     assert(item);
00483     assert(item->_refQuery);
00484     item->_refQuery->RemoveQueryField(item);
00485     AddQueryFieldLast(item); 
00486 }
00487 
00488 void DOQuery::MoveQueryFieldAfter(DOQueryField* item, DOQueryField* pos)
00489 {
00490     
00491     assert(item);
00492     assert(item->_refQuery);
00493     item->_refQuery->RemoveQueryField(item);
00494     AddQueryFieldAfter(item, pos); 
00495 }
00496 
00497 void DOQuery::MoveQueryFieldBefore(DOQueryField* item, DOQueryField* pos)
00498 {
00499     
00500     assert(item);
00501     assert(item->_refQuery);
00502     item->_refQuery->RemoveQueryField(item);
00503     AddQueryFieldBefore(item, pos); 
00504 }
00505 
00506 void DOQuery::SortQueryField(int (*comp)(DOQueryField*, DOQueryField*))
00507 {
00508     
00509     for (DOQueryField* a = GetFirstQueryField(); a; a = GetNextQueryField(a))
00510     {
00511         DOQueryField* b = GetNextQueryField(a);
00512 
00513         while (b && (comp(a, b) > 0))
00514         {
00515             DOQueryField* c = GetPrevQueryField(a);
00516             while (c && (comp(c, b) > 0))
00517                 c = GetPrevQueryField(c);
00518 
00519             if (c)
00520                 MoveQueryFieldAfter(b, c);
00521             else
00522                 MoveQueryFieldFirst(b);
00523 
00524             b = GetNextQueryField(a);
00525         }
00526     } 
00527 }
00528 // METHODS_ITERATOR_MULTI_ACTIVE(DOQuery, Query, DOQueryField, QueryField)
00529 DOQuery::QueryFieldIterator* DOQuery::QueryFieldIterator::_first = 0;
00530 DOQuery::QueryFieldIterator* DOQuery::QueryFieldIterator::_last = 0;
00531 
00532 DOQuery::QueryFieldIterator::QueryFieldIterator(
00533     const DOQuery* iterQuery,
00534     int (DOQueryField::*method)() const,
00535     DOQueryField* refQueryField)
00536 {
00537     assert(iterQuery);
00538 
00539     _iterQuery = iterQuery;
00540     _refQueryField = _prevQueryField = _nextQueryField = refQueryField;
00541     _prev = (QueryFieldIterator*)0;
00542     _next = (QueryFieldIterator*)0;
00543     _method = method;
00544     if (_last)
00545     {
00546         _last->_next = this;
00547         _prev = _last;
00548         _last = this;
00549     }
00550     else
00551         _first = _last = this;
00552 }
00553 
00554 DOQuery::QueryFieldIterator::QueryFieldIterator(
00555     const DOQuery& iterQuery,
00556     int (DOQueryField::*method)() const,
00557     DOQueryField* refQueryField)
00558 {
00559     assert(&iterQuery);
00560 
00561     _iterQuery = &iterQuery;
00562     _refQueryField = _prevQueryField = _nextQueryField = refQueryField;
00563     _prev = (QueryFieldIterator*)0;
00564     _next = (QueryFieldIterator*)0;
00565     _method = method;
00566     if (_last)
00567     {
00568         _last->_next = this;
00569         _prev = _last;
00570         _last = this;
00571     }
00572     else
00573         _first = _last = this;
00574 }
00575 
00576 DOQuery::QueryFieldIterator::QueryFieldIterator(
00577     const QueryFieldIterator& iterator,
00578     int (DOQueryField::*method)() const)
00579 {
00580     _iterQuery = iterator._iterQuery;
00581     _refQueryField = iterator._refQueryField;
00582     _prevQueryField = iterator._prevQueryField;
00583     _nextQueryField = iterator._nextQueryField;
00584     _prev = (QueryFieldIterator*)0;
00585     _next = (QueryFieldIterator*)0;
00586     _method = method;
00587     if (_last)
00588     {
00589         _last->_next = this;
00590         _prev = _last;
00591         _last = this;
00592     }
00593     else
00594         _first = _last = this;
00595 }
00596 
00597 DOQuery::QueryFieldIterator::~QueryFieldIterator()
00598 {
00599     if (_next)
00600         _next->_prev = _prev;
00601     else
00602         _last = _prev;
00603 
00604     if (_prev)
00605         _prev->_next = _next;
00606     else
00607         _first = _next;
00608 }
00609 
00610 void DOQuery::QueryFieldIterator::Check(DOQueryField* itemQueryField)
00611 {
00612     for (QueryFieldIterator* item = _first; item; item = item->_next)
00613     {
00614         if (item->_prevQueryField == itemQueryField)
00615         {
00616             item->_prevQueryField = item->_iterQuery->GetNextQueryField(item->_prevQueryField);
00617             item->_refQueryField = 0;
00618         }
00619         if (item->_nextQueryField == itemQueryField)
00620         {
00621             item->_nextQueryField = item->_iterQuery->GetPrevQueryField(item->_nextQueryField);
00622             item->_refQueryField = 0;
00623         }
00624     }
00625 }
00626 
00627 void DOQuery::QueryFieldIterator::Check(DOQueryField* itemQueryField, DOQueryField* newItemQueryField)
00628 {
00629     for (QueryFieldIterator* item = _first; item; item = item->_next)
00630     {
00631         if (item->_refQueryField == itemQueryField)
00632         {
00633             item->_refQueryField = item->_prevQueryField = item->_nextQueryField = newItemQueryField;
00634         }
00635         if (item->_prevQueryField == itemQueryField)
00636         {
00637             item->_prevQueryField = newItemQueryField;
00638             item->_refQueryField = 0;
00639         }
00640         if (item->_nextQueryField == itemQueryField)
00641         {
00642             item->_nextQueryField = newItemQueryField;
00643             item->_refQueryField = 0;
00644         }
00645     }
00646 }
00647 // METHODS_MULTI_OWNED_PASSIVE(DOConnection, Connection, DOQuery, Query)
00648 
00649 //}}AFX DO NOT EDIT CODE ABOVE THIS LINE !!!
00650 
00651 //@START_USER3
00652