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

query.h

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

Generated on Thu Feb 12 18:46:27 2004 for GigaBASE by doxygen 1.3.5