Main Page | Class Hierarchy | Class List | File List | Class Members

query.h

00001 //-< QUERY.H >-------------------------------------------------------*--------*
00002 // FastDB                    Version 1.0         (c) 1999  GARRET    *     ?  *
00003 // (Main Memory Database Management System)                          *   /\|  *
00004 //                                                                   *  /  \  *
00005 //                          Created:     20-Nov-98    K.A. Knizhnik  * / [] \ *
00006 //                          Last update: 10-Dec-98    K.A. Knizhnik  * GARRET *
00007 //-------------------------------------------------------------------*--------*
00008 // Constructing and hashing database query statements
00009 //-------------------------------------------------------------------*--------*
00010 
00011 #ifndef __QUERY_H__
00012 #define __QUERY_H__
00013 
00017 class FASTDB_DLL_ENTRY dbQueryElement { 
00018     friend class dbQuery;
00019     friend class dbCompiler;
00020     friend class dbQueryExpression;
00021     friend class dbQueryElementAllocator;
00022     friend class dbCLI;
00023   public:
00024     enum ElementType { 
00025         qExpression, // part of SQL expression
00026         qVarBool,
00027         qVarInt1,
00028         qVarInt2,
00029         qVarInt4,
00030         qVarInt8,
00031         qVarReal4,
00032         qVarReal8,
00033         qVarString,
00034         qVarStringPtr,
00035         qVarReference,
00036         qVarArrayOfRef, 
00037         qVarArrayOfRefPtr,
00038         qVarRawData
00039 #ifdef USE_STD_STRING
00040         ,qVarStdString
00041 #endif
00042     };
00043     
00044     ElementType getType() const { return type; }
00045     dbQueryElement* nextElement() const { return next; }
00046 
00047     void* operator new (size_t size EXTRA_DEBUG_NEW_PARAMS);
00048     void  operator delete(void* p EXTRA_DEBUG_NEW_PARAMS);
00049 
00050     char* dump(char* buf);
00051     char* dumpValues(char* buf);
00052 
00053     dbQueryElement(ElementType t, void const* p, 
00054                    dbTableDescriptor* table = NULL) 
00055     {
00056         type = t;
00057         ptr  = p;       
00058         ref  = table;
00059         next = NULL;
00060     } 
00061   private:
00062     dbQueryElement*    next;
00063     void const*        ptr;
00064     ElementType        type;
00065     dbTableDescriptor* ref;
00066 };
00067 
00068 
00074 class FASTDB_DLL_ENTRY dbQueryElementAllocator { 
00075     friend class dbDatabase;
00076 
00077     dbMutex         mutex;
00078     dbQueryElement* freeChain;
00079     
00080   public:
00081     void deallocate(dbQueryElement* first, dbQueryElement** lastNext) { 
00082         dbCriticalSection cs(mutex);
00083         if (first != NULL) { 
00084             *lastNext = freeChain;
00085             freeChain = first;
00086         }
00087     }
00088         
00089     void* allocate(size_t size);
00090 
00091     dbQueryElementAllocator();
00092     ~dbQueryElementAllocator();
00093 
00094     static dbQueryElementAllocator instance;
00095 };
00096 
00116 class FASTDB_DLL_ENTRY dbComponent { 
00117   public:
00118     char const* structure;
00119     char const* field; 
00120 
00121     dbComponent(char const* s, char const* f=NULL) : structure(s), field(f) {}
00122 };
00123 
00124 
00131 class FASTDB_DLL_ENTRY dbQueryExpression { 
00132     friend class dbQuery;
00133     dbQueryElement*  first;
00134     dbQueryElement** last;
00135     bool             operand;
00136 
00137   public:
00138     dbQueryExpression& add(dbQueryElement::ElementType type, void const* ptr, dbTableDescriptor* table = NULL) {
00139         last = &(*last = new dbQueryElement(type, ptr, table))->next;
00140         operand = (type == dbQueryElement::qExpression);
00141         return *this;
00142     }
00143         
00144     dbQueryExpression& operator = (char const* ptr) { 
00145         first = NULL, last = &first;
00146         return add(dbQueryElement::qExpression, ptr);
00147     }
00148     dbQueryExpression& operator = (dbComponent const& comp);
00149 
00150     dbQueryExpression& operator = (dbQueryExpression const& expr);
00151 
00152     dbQueryExpression& operator,(int1 const& ptr) { 
00153         return add(dbQueryElement::qVarInt1, &ptr);
00154     }
00155     dbQueryExpression& operator,(int2 const& ptr) { 
00156         return add(dbQueryElement::qVarInt2, &ptr);
00157     }
00158     dbQueryExpression& operator,(int4 const& ptr) { 
00159         return add(dbQueryElement::qVarInt4, &ptr);
00160     }
00161     dbQueryExpression& operator,(db_int8 const& ptr) { 
00162         return add(dbQueryElement::qVarInt8, &ptr);
00163     }
00164     dbQueryExpression& operator,(nat1 const& ptr) {
00165         return add(dbQueryElement::qVarInt1, &ptr);
00166     }
00167     dbQueryExpression& operator,(nat2 const& ptr) {
00168         return add(dbQueryElement::qVarInt2, &ptr);
00169     }
00170     dbQueryExpression& operator,(nat4 const& ptr) {
00171         return add(dbQueryElement::qVarInt4, &ptr);
00172     }
00173     dbQueryExpression& operator,(db_nat8 const& ptr) {
00174         return add(dbQueryElement::qVarInt8, &ptr);
00175     }
00176 #if SIZEOF_LONG != 8
00177     dbQueryExpression& operator,(long const& ptr) {
00178         return add(dbQueryElement::qVarInt4, &ptr);
00179     }
00180     dbQueryExpression& operator,(unsigned long const& ptr) {
00181         return add(dbQueryElement::qVarInt4, &ptr);
00182     }
00183 #endif
00184     dbQueryExpression& operator,(real4 const& ptr) { 
00185         return add(dbQueryElement::qVarReal4, &ptr);
00186     }
00187     dbQueryExpression& operator,(real8 const& ptr) { 
00188         return add(dbQueryElement::qVarReal8, &ptr);
00189     }
00190     dbQueryExpression& operator,(bool const& ptr) { 
00191         return add(dbQueryElement::qVarBool, &ptr);
00192     }
00193     dbQueryExpression& operator,(char const* ptr) { 
00194         return add(operand ? dbQueryElement::qVarString 
00195                    : dbQueryElement::qExpression, ptr);
00196     }
00197     dbQueryExpression& operator,(char const** ptr) { 
00198         return add(dbQueryElement::qVarStringPtr, ptr);
00199     }
00200     dbQueryExpression& operator,(char** ptr) { 
00201         return add(dbQueryElement::qVarStringPtr, ptr);
00202     }
00203     dbQueryExpression& operator,(void const* ptr) { 
00204         return add(dbQueryElement::qVarRawData, ptr);
00205      }
00206 #ifdef USE_STD_STRING
00207     dbQueryExpression& operator,(std::string const& str) {
00208         return add(dbQueryElement::qVarStdString, &str);
00209     }
00210 #endif
00211     dbQueryExpression& operator,(dbQueryExpression const& expr) { 
00212         *last = new dbQueryElement(dbQueryElement::qExpression, "(");
00213         (*last)->next = expr.first;
00214         last = expr.last;
00215         *last = new dbQueryElement(dbQueryElement::qExpression, ")");
00216         last = &(*last)->next;
00217         operand = false;
00218         return *this;
00219     }
00220     dbQueryExpression& operator,(dbComponent const& comp) { 
00221         add(dbQueryElement::qExpression, comp.structure);
00222         if (comp.field != NULL) { 
00223             add(dbQueryElement::qExpression, ".");
00224             add(dbQueryElement::qExpression, comp.field);
00225         }
00226         operand = false;
00227         return *this;
00228     }
00229     dbQueryExpression& operator += (dbComponent const& comp) { 
00230         return *this,comp;
00231     }
00232     dbQueryExpression& operator += (char const* ptr) { 
00233         return add(dbQueryElement::qExpression, ptr);
00234     }
00235 #ifndef NO_MEMBER_TEMPLATES
00236     template<class T>
00237     dbQueryExpression& operator,(dbReference<T> const& value) { 
00238         return add(dbQueryElement::qVarReference, &value, &T::dbDescriptor);
00239     }
00240 
00241     template<class T>
00242     inline dbQueryExpression& operator,(dbArray< dbReference<T> > const& value) { 
00243         return add(dbQueryElement::qVarArrayOfRef, &value, 
00244                       &T::dbDescriptor);
00245     }
00246 
00247     template<class T>
00248     inline dbQueryExpression& operator,(dbArray< dbReference<T> >const* const& value) { 
00249         return add(dbQueryElement::qVarArrayOfRefPtr, &value, &T::dbDescriptor);
00250     }
00251 #endif
00252 };
00253 
00254 class dbOrderByNode;
00255 class dbFollowByNode;
00256 
00257 
00261 class FASTDB_DLL_ENTRY dbCompiledQuery { 
00262   public:
00263     dbExprNode*        tree;
00264     dbOrderByNode*     order;
00265     dbFollowByNode*    follow;
00266     dbTableDescriptor* table;
00267     int                schemeVersion;
00268 
00269     enum IteratorInit { 
00270         StartFromAny,
00271         StartFromFirst,
00272         StartFromLast,
00273         StartFromRef, 
00274         StartFromArray,
00275         StartFromArrayPtr
00276     };
00277     IteratorInit       startFrom;
00278     void const*        root;
00279 
00280     void destroy();
00281 
00282     bool compiled() { return tree != NULL; }
00283 
00284     dbCompiledQuery() { 
00285         tree = NULL;
00286         order = NULL;
00287         follow = NULL;
00288         table = NULL;
00289         startFrom = StartFromAny;
00290     }
00291 };
00292 
00297 class FASTDB_DLL_ENTRY dbQuery : public dbCompiledQuery { 
00298     friend class dbCompiler;
00299     friend class dbDatabase;
00300     friend class dbSubSql;
00301     friend class dbCLI;
00302   private:
00303     dbMutex            mutex;
00304     dbQueryElement*    elements;
00305     dbQueryElement**   nextElement;
00306     bool               operand;
00307     bool               mutexLocked;
00308 
00309     //
00310     // Prohibite query copying
00311     //
00312     dbQuery(dbQuery const&) {} 
00313     dbQuery& operator =(dbQuery const&) { return *this; }
00314 
00315   public:
00316     int                pos; // position of condition in statement
00317 
00318 
00319     char* dump(char* buf) { 
00320         char* p = buf;
00321         for (dbQueryElement* elem = elements; elem != NULL; elem = elem->next) { 
00322             p = elem->dump(p);
00323         }
00324         return buf;
00325     }
00326 
00327     char* dumpValues(char* buf) { 
00328         char* p = buf;
00329         for (dbQueryElement* elem = elements; elem != NULL; elem = elem->next) { 
00330             p = elem->dumpValues(p);
00331         }
00332         return buf;
00333     }
00334 
00335     dbQuery& append(dbQueryElement::ElementType type, void const* ptr,
00336                     dbTableDescriptor* table = NULL) 
00337     { 
00338         nextElement = &(*nextElement=new dbQueryElement(type,ptr,table))->next;
00339         operand = (type == dbQueryElement::qExpression);
00340         return *this;
00341     }
00342 
00343     dbQuery& reset();
00344 
00345     //
00346     // Redefined operator = and , make it possible to specify query in the
00347     // following way:
00348     //         int x, y;
00349     //         dbDataTime dt;
00350     //         dbQuery q; 
00351     //         dbCursor<record> cursor;
00352     //         q = "x=",x,"and y=",y,"and",dt == "date";
00353     //         for (x = 0; x < max_x; x++) { 
00354     //             for (y = 0; y < max_y; y++) { 
00355     //                 cursor.select(q);
00356     //                 ...
00357     //             }
00358     //         }
00359 
00360     dbQuery& add(dbQueryExpression const& expr); 
00361 
00362     dbQuery& And(char const* str) { 
00363         if (elements != NULL) { 
00364             append(dbQueryElement::qExpression, "and");
00365         }
00366         return append(dbQueryElement::qExpression, str);
00367     }
00368 
00369     dbQuery& Or(char const* str) { 
00370         if (elements != NULL) { 
00371             append(dbQueryElement::qExpression, "or");
00372         }
00373         return append(dbQueryElement::qExpression, str);
00374     }
00375 
00376     dbQuery& add(char const* str) { 
00377         return append(operand ? dbQueryElement::qVarString 
00378                       : dbQueryElement::qExpression, str);
00379     }
00380     dbQuery& add(char const** str) { 
00381         return append(dbQueryElement::qVarStringPtr, str);
00382     }
00383 #ifdef USE_STD_STRING
00384     dbQuery& add(std::string const& str) { 
00385         return append(dbQueryElement::qVarStdString, &str);
00386     }
00387     dbQuery& operator,(std::string const& str) { return add(str); }
00388 #endif
00389     dbQuery& add(char** str) { 
00390         return append(dbQueryElement::qVarStringPtr, str);
00391     }
00392     dbQuery& add(int1 const& value) { 
00393         return append(dbQueryElement::qVarInt1, &value);
00394     }
00395     dbQuery& add (int2 const& value) { 
00396         return append(dbQueryElement::qVarInt2, &value);
00397     }
00398     dbQuery& add (int4 const& value) { 
00399         return append(dbQueryElement::qVarInt4, &value);
00400     }
00401     dbQuery& add (db_int8 const& value) { 
00402         return append(dbQueryElement::qVarInt8, &value);
00403     }
00404     dbQuery& add(nat1 const& value) {
00405         return append(dbQueryElement::qVarInt1, &value);
00406     }
00407     dbQuery& add (nat2 const& value) {
00408         return append(dbQueryElement::qVarInt2, &value);
00409     }
00410     dbQuery& add (nat4 const& value) {
00411         return append(dbQueryElement::qVarInt4, &value);
00412     }
00413     dbQuery& add (db_nat8 const& value) {
00414         return append(dbQueryElement::qVarInt8, &value);
00415     }
00416 #if SIZEOF_LONG != 8
00417     dbQuery& add (long const& value) {
00418         return append(dbQueryElement::qVarInt4, &value);
00419     }
00420     dbQuery& add (unsigned long const& value) {
00421         return append(dbQueryElement::qVarInt4, &value);
00422     }
00423 #endif
00424     dbQuery& add (real4 const& value) { 
00425         return append(dbQueryElement::qVarReal4, &value);
00426     }
00427     dbQuery& add(real8 const& value) { 
00428         return append(dbQueryElement::qVarReal8, &value);
00429     }
00430     dbQuery& add(bool const& value) { 
00431         return append(dbQueryElement::qVarBool, &value);
00432     }
00433     dbQuery& add(void const* value) { 
00434         return append(dbQueryElement::qVarRawData, value);
00435     }
00436 
00437     dbQuery& operator,(char const*  value) { return add(value); }
00438     dbQuery& operator,(char const** value) { return add(value); }
00439     dbQuery& operator,(char** value) { return add(value); }
00440     dbQuery& operator,(int1 const&  value) { return add(value); }
00441     dbQuery& operator,(int2 const&  value) { return add(value); }
00442     dbQuery& operator,(int4 const&  value) { return add(value); }
00443     dbQuery& operator,(db_int8 const&  value) { return add(value); }
00444     dbQuery& operator,(nat1 const&  value) { return add(value); }
00445     dbQuery& operator,(nat2 const&  value) { return add(value); }
00446     dbQuery& operator,(nat4 const&  value) { return add(value); }
00447     dbQuery& operator,(db_nat8 const&  value) { return add(value); }
00448 #if SIZEOF_LONG != 8
00449     dbQuery& operator,(long const&  value) { return add(value); }
00450     dbQuery& operator,(unsigned long const&  value) { return add(value); }
00451 #endif
00452     dbQuery& operator,(real4 const& value) { return add(value); }
00453     dbQuery& operator,(real8 const& value) { return add(value); }
00454     dbQuery& operator,(bool const&  value) { return add(value); }
00455     dbQuery& operator,(void const*  value) { return add(value); }
00456     dbQuery& operator,(dbQueryExpression const& expr) { return add(expr); }
00457 
00458     dbQuery& operator = (const char* str) { 
00459         return reset().append(dbQueryElement::qExpression, str);
00460     }
00461 
00462 #ifndef NO_MEMBER_TEMPLATES
00463     template<class T>
00464     dbQuery& operator,(dbReference<T> const& value) { 
00465         return append(dbQueryElement::qVarReference, &value, &T::dbDescriptor);
00466     }
00467 
00468     template<class T>
00469     inline dbQuery& operator,(dbArray< dbReference<T> > const& value) { 
00470         return append(dbQueryElement::qVarArrayOfRef, &value, 
00471                       &T::dbDescriptor);
00472     }
00473 
00474     template<class T>
00475     inline dbQuery& operator,(dbArray< dbReference<T> >const* const& value) { 
00476         return append(dbQueryElement::qVarArrayOfRefPtr, &value, &T::dbDescriptor);
00477     }
00478 
00479     template<class T>
00480     dbQuery& add(dbReference<T> const& value) { 
00481         return append(dbQueryElement::qVarReference, &value, &T::dbDescriptor);
00482     }
00483 
00484     template<class T>
00485     dbQuery& add(dbArray< dbReference<T> > const& value) { 
00486         return append(dbQueryElement::qVarArrayOfRef, &value, 
00487                       &T::dbDescriptor);
00488     }
00489     template<class T>
00490     dbQuery& add(dbArray< dbReference<T> >const* const& value) { 
00491         return append(dbQueryElement::qVarArrayOfRefPtr, &value, &T::dbDescriptor);
00492     }
00493 
00494     template<class T>
00495     dbQuery& operator = (T const& value) { 
00496         return reset().add(value);
00497     }   
00498 #else
00499     dbQuery& operator = (dbQueryExpression const& expr) {
00500         return reset().add(expr);
00501     }    
00502 #endif
00503 
00504 
00505     dbQueryElement* getElements() const { 
00506         return elements;
00507     }
00508 
00509     dbQuery() { 
00510         elements = NULL;
00511         nextElement = &elements;
00512         operand = false;
00513         pos = 0;
00514     } 
00515     dbQuery(char const* str) { 
00516         elements = new dbQueryElement(dbQueryElement::qExpression, str);
00517         nextElement = &elements->next;
00518         operand = true;
00519         pos = 0;
00520     } 
00521     ~dbQuery() { 
00522         reset();
00523     }
00524 };
00525 
00526 #ifdef NO_MEMBER_TEMPLATES
00527 template<class T>
00528 inline dbQueryExpression& operator,(dbQueryExpression& expr, dbReference<T> const& value) { 
00529     return expr.add(dbQueryElement::qVarReference, &value, &T::dbDescriptor);
00530 }
00531 template<class T>
00532 inline dbQueryExpression& operator,(dbQueryExpression& expr, dbArray< dbReference<T> > const& value) { 
00533     return expr.add(dbQueryElement::qVarArrayOfRef, &value, 
00534                     &T::dbDescriptor);
00535 }
00536 
00537 template<class T>
00538 inline dbQueryExpression& operator,(dbQueryExpression& expr, dbArray< dbReference<T> >const* const& value) { 
00539     return expr.add(dbQueryElement::qVarArrayOfRefPtr, &value, &T::dbDescriptor);
00540 }
00541 
00542 template<class T>
00543 inline dbQuery& operator,(dbQuery& query, dbReference<T> const& value) { 
00544     return query.append(dbQueryElement::qVarReference, &value, 
00545                         &T::dbDescriptor);
00546 }
00547 
00548 template<class T>
00549 inline dbQuery& operator,(dbQuery& query, 
00550                              dbArray< dbReference<T> > const& value) 
00551 { 
00552     return query.append(dbQueryElement::qVarArrayOfRef, &value, 
00553                         &T::dbDescriptor);
00554 }
00555 
00556 template<class T>
00557 inline dbQuery& operator,(dbQuery& query, 
00558                              dbArray< dbReference<T> >const* const& value) 
00559 { 
00560     return query.append(dbQueryElement::qVarArrayOfRefPtr, &value, 
00561                         &T::dbDescriptor);
00562 }
00563 
00564 template<class T>
00565 inline dbQuery& add(dbQuery& query, dbReference<T> const& value) { 
00566     return query.append(dbQueryElement::qVarReference, &value, &T::dbDescriptor);
00567 }
00568 
00569 template<class T>
00570 inline dbQuery& add(dbQuery& query, dbArray< dbReference<T> > const& value) { 
00571     return query.append(dbQueryElement::qVarArrayOfRef, &value, 
00572                         &T::dbDescriptor);
00573 }
00574 
00575 template<class T>
00576 inline dbQuery& add(dbQuery& query, dbArray< dbReference<T> >const* const& value) { 
00577     return query.append(dbQueryElement::qVarArrayOfRefPtr, &value, &T::dbDescriptor);
00578 }
00579 #endif
00580 
00581 #define USER_FUNC(f) static dbUserFunction f##_descriptor(&f, #f)
00582 
00583 struct dbInheritedAttribute;
00584 union  dbSynthesizedAttribute;
00585 
00590 class FASTDB_DLL_ENTRY  dbUserFunctionArgument { 
00591   public:
00592     enum dbArgumentType { 
00593         atInteger, 
00594         atBoolean, 
00595         atString, 
00596         atReal, 
00597         atReference, 
00598         atRawBinary
00599     };  
00600     dbArgumentType type; 
00601     union {
00602         real8       realValue;
00603         db_int8     intValue;
00604         bool        boolValue;
00605         char const* strValue;
00606         oid_t       oidValue;
00607         void*       rawValue;
00608     } u;
00609 
00610   private:
00611     friend class dbDatabase;
00612     dbUserFunctionArgument(dbExprNode*             expr, 
00613                            dbInheritedAttribute&   iattr, 
00614                            dbSynthesizedAttribute& sattr, 
00615                            int                     i);
00616 };
00617 
00626 class FASTDB_DLL_ENTRY dbUserFunction { 
00627     friend class dbDatabase;
00628     friend class dbCompiler;
00629 
00630     void* fptr;
00631     char* name;
00632     
00633     dbUserFunction* next;
00634     static dbUserFunction* list;
00635 
00636     enum funcType {
00637         fInt2Bool,
00638         fReal2Bool,
00639         fStr2Bool,
00640         fInt2Int,
00641         fReal2Int,
00642         fStr2Int,
00643         fInt2Real,
00644         fReal2Real,
00645         fStr2Real,
00646         fInt2Str,
00647         fReal2Str,
00648         fStr2Str, 
00649         fArg2Bool, 
00650         fArg2Int, 
00651         fArg2Real, 
00652         fArg2Str, 
00653         fArgArg2Bool, 
00654         fArgArg2Int, 
00655         fArgArg2Real, 
00656         fArgArg2Str, 
00657         fArgArgArg2Bool, 
00658         fArgArgArg2Int, 
00659         fArgArgArg2Real, 
00660         fArgArgArg2Str
00661     };
00662     int type;
00663 
00664     void bind(char* name, void* f, funcType ftype);
00665 
00666   public:
00667 
00668     static dbUserFunction* find(char const* name) { 
00669         for (dbUserFunction* func = list; func != NULL; func = func->next) { 
00670             if (name == func->name) { 
00671                 return func;
00672             }
00673         }
00674         return NULL;
00675     }
00676     
00677     int getParameterType();
00678 
00679     int getNumberOfParameters();
00680 
00681     dbUserFunction(bool (*f)(db_int8), char* name) { 
00682         bind(name, (void*)f, fInt2Bool); 
00683     }
00684     dbUserFunction(bool (*f)(real8), char* name) { 
00685         bind(name, (void*)f, fReal2Bool); 
00686     }
00687     dbUserFunction(bool (*f)(char const*), char* name) { 
00688         bind(name, (void*)f, fStr2Bool); 
00689     }
00690     dbUserFunction(db_int8 (*f)(db_int8), char* name) { 
00691         bind(name, (void*)f, fInt2Int); 
00692     }
00693     dbUserFunction(db_int8 (*f)(real8), char* name) { 
00694         bind(name, (void*)f, fReal2Int); 
00695     }
00696     dbUserFunction(db_int8 (*f)(char const*), char* name) { 
00697         bind(name, (void*)f, fStr2Int); 
00698     }
00699     dbUserFunction(real8 (*f)(db_int8), char* name) { 
00700         bind(name, (void*)f, fInt2Real); 
00701     }
00702     dbUserFunction(real8 (*f)(real8), char* name) { 
00703         bind(name, (void*)f, fReal2Real); 
00704     }
00705     dbUserFunction(real8 (*f)(char const*), char* name) { 
00706         bind(name, (void*)f, fStr2Real); 
00707     }
00708     dbUserFunction(char* (*f)(db_int8), char* name) { 
00709         bind(name, (void*)f, fInt2Str); 
00710     }
00711     dbUserFunction(char* (*f)(real8), char* name) { 
00712         bind(name, (void*)f, fReal2Str); 
00713     }
00714     dbUserFunction(char* (*f)(char const*), char* name) { 
00715         bind(name, (void*)f, fStr2Str); 
00716     }
00717 
00718 
00719     dbUserFunction(bool (*f)(dbUserFunctionArgument&), char* name) { 
00720         bind(name, (void*)f, fArg2Bool); 
00721     }
00722     dbUserFunction(char* (*f)(dbUserFunctionArgument&), char* name) { 
00723         bind(name, (void*)f, fArg2Str); 
00724     }
00725     dbUserFunction(db_int8 (*f)(dbUserFunctionArgument&), char* name) { 
00726         bind(name, (void*)f, fArg2Int); 
00727     }
00728     dbUserFunction(real8 (*f)(dbUserFunctionArgument&), char* name) { 
00729         bind(name, (void*)f, fArg2Real); 
00730     }
00731 
00732     dbUserFunction(bool (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&), char* name) { 
00733         bind(name, (void*)f, fArgArg2Bool); 
00734     }
00735     dbUserFunction(char* (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&), char* name) { 
00736         bind(name, (void*)f, fArgArg2Str); 
00737     }
00738     dbUserFunction(db_int8 (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&), char* name) { 
00739         bind(name, (void*)f, fArgArg2Int); 
00740     }
00741     dbUserFunction(real8 (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&), char* name) { 
00742         bind(name, (void*)f, fArgArg2Real); 
00743     }
00744 
00745 
00746     dbUserFunction(bool (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&, dbUserFunctionArgument&), char* name) { 
00747         bind(name, (void*)f, fArgArgArg2Bool); 
00748     }
00749     dbUserFunction(char* (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&, dbUserFunctionArgument&), char* name) { 
00750         bind(name, (void*)f, fArgArgArg2Str); 
00751     }
00752     dbUserFunction(db_int8 (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&, dbUserFunctionArgument&), char* name) { 
00753         bind(name, (void*)f, fArgArgArg2Int); 
00754     }
00755     dbUserFunction(real8 (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&, dbUserFunctionArgument&), char* name) { 
00756         bind(name, (void*)f, fArgArgArg2Real); 
00757     }
00758 };
00759 
00760 #endif
00761 
00762 
00763 

Generated on Thu Feb 12 13:04:48 2004 for FastDB by doxygen 1.3.5