00001
00002
00003
00004
00005
00006
00007
00008
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,
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
00345
00346 dbQuery(dbQuery const&) : dbCompiledQuery() {}
00347 dbQuery& operator =(dbQuery const&) { return *this; }
00348
00349 public:
00350 int pos;
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
00381
00382
00383
00384
00385
00386
00387
00388
00389
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