00001
00002
00003
00004
00005
00006
00007
00008
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,
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
00311
00312 dbQuery(dbQuery const&) {}
00313 dbQuery& operator =(dbQuery const&) { return *this; }
00314
00315 public:
00316 int pos;
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
00347
00348
00349
00350
00351
00352
00353
00354
00355
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