00001
00002
00003
00004
00005
00006
00007
00008
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,
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
00342
00343 dbQuery(dbQuery const&) {}
00344 dbQuery& operator =(dbQuery const&) { return *this; }
00345
00346 public:
00347 int pos;
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
00377
00378
00379
00380
00381
00382
00383
00384
00385
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