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

Generated on Mon Oct 23 13:23:58 2006 for FastDB by doxygen1.2.18