home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Demos / OOFILE / Buildable, limited OOFILE / OOFILE partial source / oof3.cpp < prev    next >
Encoding:
Text File  |  1995-09-25  |  19.5 KB  |  978 lines  |  [TEXT/CWIE]
  1. // COPYRIGHT 1994 A.D. Software, All rights reserved
  2.  
  3. // OOFILE database field-related classes
  4. // see also oof4.cpp
  5.  
  6. #include "oof2.hpp"
  7. #include "oof3.hpp"
  8. #include "oofquery.hpp" 
  9. #include "oofrel.hpp"  
  10.  
  11. // -------------------------------------------------------
  12. //                      d b F i e l d 
  13. // -------------------------------------------------------
  14.  
  15.  
  16. dbField::dbField() :
  17.             mIndexOptions(kNotIndexed)
  18. {
  19.     dbTable::sCurrentlyConstructing->attachfield(this);
  20. }
  21.  
  22.  
  23. dbField::dbField(const OOF_IndexOptions indexOptions) :
  24.             mIndexOptions(indexOptions)
  25. {
  26.     dbTable::sCurrentlyConstructing->attachfield(this);
  27. }
  28.  
  29.  
  30. dbField::dbField(const char *fieldName) :
  31.                 mIndexOptions(kNotIndexed),
  32.                 mFieldName(fieldName)
  33. {
  34.     dbTable::sCurrentlyConstructing->attachfield(this);
  35. }
  36.  
  37.  
  38. dbField::dbField(const char *fieldName, const OOF_IndexOptions indexOptions) :
  39.                 mIndexOptions(indexOptions),
  40.                 mFieldName(fieldName)
  41. {
  42.     dbTable::sCurrentlyConstructing->attachfield(this);
  43. }
  44.  
  45.  
  46. dbField::dbField(const dbField& rhs) :
  47.             mBackend(0),
  48.             mTable(0),
  49.             mFieldNumber(rhs.mFieldNumber),
  50.             mIndexOptions(rhs.mIndexOptions),
  51.             mFieldName(rhs.mFieldName)
  52. {
  53. #ifdef OOF_Debug
  54.     validateDatabaseState();
  55. #endif
  56.     if(mRelationChain) { // must be copying a related field, probably a temp copy from a view
  57.         mTable = rhs.mTable;
  58.         mBackend = rhs.mBackend;
  59.     }
  60.     else // normal copy
  61.     {
  62.         dbTable* theTable = dbTable::sCurrentlyConstructing;
  63.         theTable->attachfield(this);
  64.     }
  65. }
  66.  
  67. unsigned int dbField::fieldEditLen() const
  68. {
  69.         if (fieldType()==charField)
  70.             return fieldLen();
  71.         else
  72.             if (fieldType()==textField)
  73.                 return 20;
  74.             else
  75.                 return 10;
  76. }
  77.  
  78.  
  79. const void* dbField::binaryContents()
  80. {
  81.     validateContextInCaseRelated();
  82.     return mBackend->getFieldReadFrom(mFieldNumber);
  83. }
  84.  
  85.  
  86. dbTable* dbField::fieldTable() const
  87. {
  88.     return mTable;  
  89. }
  90.  
  91.  
  92. unsigned int dbField::countSegments() const
  93. {    
  94.     if (mIndexOptions==kNotIndexed)
  95.         return 0;
  96.     else
  97.         return 1;  // overridden for compound keys
  98. }
  99.  
  100.  
  101. bool dbField::fieldIsBlob() const
  102. {
  103.     return false;  
  104. }
  105.  
  106.  
  107. bool dbField::fieldIsBinary() const
  108. {
  109.     return true;  
  110. }
  111.  
  112.  
  113. bool dbField::fieldIsVirtual() const
  114. {
  115.     return false;
  116. }
  117.     
  118.     
  119. bool dbField::fieldIsIndexed() const
  120. {
  121.     return mIndexOptions!=kNotIndexed;
  122. } 
  123.  
  124.  
  125. bool dbField::fieldIsUniqueIndexed() const
  126. {
  127.     return mIndexOptions==kIndexNoDups;
  128. } 
  129.  
  130.  
  131. char *dbField::copyAsChars()
  132. {
  133.     ostrstream oss;
  134.     extract(oss);
  135.     oss << ends;
  136. #ifdef _RTLDLL  // Borland use this to indicate runtime lib in DLL which may mean different allocator
  137.     char* s = oss.str();  // can't just return this - causes crash on delete[]
  138.     long sLen = strlen(s);
  139.     char* ret = new char[sLen+1];
  140.     assert(ret);
  141.     strncpy(ret, s, sLen);
  142.    ret[sLen]='\0';
  143.     oss.rdbuf()->freeze(0);  // leave buffer for stream to delete
  144.     return ret;
  145. #else
  146.     return oss.str();
  147. #endif
  148. }
  149.  
  150.  
  151. void dbField::extract(ostream& os)
  152. {
  153.     os << "";
  154. }
  155.  
  156.  
  157. bool dbField::insert(istream& is, char fieldSep, char recSep)
  158. {
  159.     char c;
  160.     while (is.good()) {
  161.         is >> c;
  162.         if ((c==fieldSep) || (c==recSep)) {
  163.             is.putback(c); // put the separator back so the caller knows what kind we hit
  164.             return true;  // OK - hit a separator
  165.         }
  166.     }
  167.     return false;  // fell through without hitting separator
  168. }
  169.  
  170.  
  171. void dbField::describe(ostream& os)
  172. {
  173.     if (mFieldName.isEmpty())
  174.         os << "Un-named field";
  175.     else
  176.         os << "field: " << mFieldName;
  177.     os << " is field type: " << fieldType() << endl;
  178.     if (fieldIsIndexed())
  179.         os << "    has indexing: " << fieldIndexOptions() << endl;
  180. }
  181.  
  182.  
  183. void dbField::validateContextInCaseRelated()
  184. {
  185. #ifdef OOF_Debug
  186.     validateDatabaseState();
  187. #endif
  188.     if (mRelationChain)
  189.         mRelationChain->validateContext();
  190. }
  191.  
  192.  
  193. dbField* dbField::GetRelatedFieldOrUs()
  194. {
  195.     if (ConsumePossibleRelationChain()) {
  196.         dbRelChain* tempChain = mRelationChain;
  197.         mRelationChain = 0;  // clear it, the clone field owns it
  198.         tempChain = tempChain->buildChain();
  199.         return tempChain->getFinalField(mFieldNumber);
  200.     }
  201.     else
  202.         return this;
  203. }
  204.  
  205.  
  206. // -------------------------------------------------------
  207. //                  d b F i x e d B i n a r y
  208. // -------------------------------------------------------
  209. OOF_fieldTypes dbFixedBinary::fieldType() const
  210. {
  211.     return fixedBinaryField; 
  212. }
  213.  
  214.  
  215. unsigned long dbFixedBinary::fieldLen() const
  216. {
  217.     return mBodyLength; 
  218. }
  219.  
  220.  
  221. dbFixedBinary& dbFixedBinary::operator=(dbFixedBinary& rhs)
  222. {
  223.     if (this == &rhs)  // MUST use this form to avoid invoking the operator== used for searches
  224.         return *this;
  225.     
  226.     setValue(rhs.binaryContents());
  227.     return *this;
  228. }
  229.  
  230.  
  231. dbFixedBinary&  dbFixedBinary::operator=(const char* str)
  232. {
  233.     assert(strlen(str) <= mBodyLength);
  234.     setValue(str);
  235.     return *this;
  236. }
  237.  
  238.  
  239.  
  240. void dbFixedBinary::setValue(const void* str)
  241. {
  242.     validateContextInCaseRelated();
  243.     char *writeTo = (char*)mBackend->getFieldWriteDest(mFieldNumber);
  244.     if (writeTo) {
  245.         memcpy(writeTo, str, mBodyLength);
  246. #ifdef OOF_SmartHeap
  247.     MemPoolCheck(MemDefaultPool);
  248. #endif
  249.     }    
  250.     else
  251.         ;  // error NOT YET IMPLEMENTED
  252.     mBackend->markDirty();
  253. }
  254.  
  255.  
  256. void dbFixedBinary::setByte(char c, unsigned int offset)
  257. {
  258.     validateContextInCaseRelated();
  259.     char *writeTo = (char*) mBackend->getFieldWriteDest(mFieldNumber);
  260.     if (writeTo) {
  261.         writeTo[offset] = c;
  262. #ifdef OOF_SmartHeap
  263.     MemPoolCheck(MemDefaultPool);
  264. #endif
  265.     }    
  266.     else
  267.         ;  // error NOT YET IMPLEMENTED
  268.     mBackend->markDirty();
  269. }
  270.  
  271.  
  272. void dbFixedBinary::extract(ostream& os)
  273. {
  274.     const char *asChars = (char*)binaryContents();
  275.     os << hex;
  276.     for (unsigned int i=0; i<mBodyLength; i++)
  277.         os << asChars[i] << ' ';
  278. }
  279.  
  280.  
  281.  
  282. void dbFixedBinary::generateTestData(const char *testBuf, unsigned long testBufLen)
  283. {
  284.     for (unsigned int i=0; i<mBodyLength; i++) {
  285.         char c = rand()%0xFF;
  286.         setByte(c, i);
  287.     }
  288. }
  289.  
  290.  
  291. void dbFixedBinary::describe(ostream& os)
  292. {
  293.     dbField::describe(os);
  294.     os << "    and a length of : " << mBodyLength << endl;
  295. }
  296.  
  297.  
  298. dbFixedBinary& dbFixedBinary::operator()()
  299. {
  300.     dbFixedBinary* retField = (dbFixedBinary*) GetRelatedFieldOrUs();
  301.     return *retField;
  302. }
  303.  
  304.  
  305. // -------------------------------------------------------
  306. //                      d b C h a r
  307. // -------------------------------------------------------
  308. char * dbChar::copyAsChars()
  309. {
  310.     char* ret = new char[mBackend->fieldDataLen(this)+1];
  311.     assert(ret);
  312.     strcpy(ret, (const char*)*this);
  313.     return ret;
  314. }
  315.  
  316. OOF_fieldTypes dbChar::fieldType() const
  317. {
  318.     return charField; 
  319. }
  320.  
  321.  
  322. bool dbChar::fieldIsBinary() const
  323. {
  324.     return false;  
  325. }
  326.  
  327.  
  328. unsigned long dbChar::fieldLen() const
  329. {
  330.     return mMaxLength; 
  331. }
  332.  
  333.  
  334. dbChar::operator const char*() 
  335. {
  336.     validateContextInCaseRelated();
  337.     return (char*) mBackend->getFieldReadFrom(mFieldNumber);
  338. }
  339.  
  340.  
  341. #ifdef _Macintosh
  342. void dbChar::asStr255(Str255 s) 
  343. {
  344.     validateContextInCaseRelated();
  345.     char* from = (char*) mBackend->getFieldReadFrom(mFieldNumber);
  346.     s[0] = strlen(from);
  347.     memcpy(s+1, from, s[0]);
  348. #ifdef OOF_SmartHeap
  349.     MemPoolCheck(MemDefaultPool);
  350. #endif
  351. }
  352.  
  353. void dbChar::setStr255(const Str255 s)
  354. {
  355.     long charLen = s[0];
  356.     const char* strStart = (char*) s+1;
  357.     setChars(strStart, charLen);
  358. }
  359.  
  360.  
  361.  
  362. // end of Mac-specific extra conversions
  363. #endif
  364.  
  365.  
  366. dbChar& dbChar::operator=(dbChar& rhs)
  367. {
  368.     if (this == &rhs)  // MUST use this form to avoid invoking the operator== used for searches
  369.         return *this;
  370.     
  371.     *this = (const char*)rhs;
  372.     return *this;
  373. }
  374.  
  375.  
  376. dbChar&  dbChar::operator=(const char* str)
  377. {
  378.     unsigned int charLen = strlen(str);
  379.     if (charLen > mMaxLength)
  380.         ;  // error NOT YET IMPLEMENTED
  381.     else
  382.     {
  383.         validateContextInCaseRelated();
  384.         char *writeTo = (char*)mBackend->getFieldWriteDest(mFieldNumber);
  385.         if (writeTo)
  386.             strcpy(writeTo, str);    
  387.         else
  388.             ;  // error NOT YET IMPLEMENTED
  389.     }
  390.     mBackend->markDirty();
  391.     return *this;
  392. }
  393.  
  394.  
  395.  
  396. void dbChar::setChars(const char* str , unsigned long charLen)
  397. {
  398.     assert(charLen <= mMaxLength);
  399.     validateContextInCaseRelated();
  400.     char *writeTo = (char*)mBackend->getFieldWriteDest(mFieldNumber);
  401.     if (writeTo) {
  402.         memcpy(writeTo, str, charLen);
  403.         writeTo[charLen]='\0';
  404.     }    
  405.     else
  406.         ;  // error NOT YET IMPLEMENTED
  407.     mBackend->markDirty();
  408. }
  409.  
  410.  
  411.  void dbChar::extract(ostream& os)
  412. {
  413.     os << (const char*)*this;
  414. }
  415.  
  416.  
  417.  
  418. bool dbChar::insert(istream& is, char fieldSep, char recSep)
  419. {
  420. // this is NOT very efficient, but it *is* safe
  421.     if (!is.good()) 
  422.         return false;
  423.         
  424.     const unsigned int maxLen = fieldLen();
  425.     assert(maxLen);  // brief flash of paranoia in case they get this far with a field of 0 len
  426.     char* buildBuf = new char[maxLen+1];
  427.     assert(buildBuf);
  428.     unsigned int charsRead = 0;
  429.     bool hitEndOfField = false;
  430.     while (is.good() && (charsRead<=maxLen)) {  // allow read one char past, in case it's terminator
  431.         char c;
  432.         is >> c;
  433.         if ((c==fieldSep) || (c==recSep)) {
  434.             is.putback(c); // put the separator back so the caller knows what kind we hit
  435.             hitEndOfField = true;
  436.             break;  // OK - hit a separator
  437.         }
  438.         if (charsRead<maxLen)
  439.             buildBuf[charsRead] = c;
  440.         charsRead++;
  441.     } // loop reading char at a time
  442.  
  443.     bool gotDataOK = false;
  444.     if (hitEndOfField)  // everybody happy
  445.         gotDataOK = true;
  446.     else {  // some form of problems along the way
  447.         if (charsRead>maxLen) {// too wide for DB field, store as short anyway
  448.             gotDataOK = true;
  449.             dbField::insert(is, fieldSep, recSep);  // consume the remainder
  450. #ifdef OOF_Debug
  451.             dbConnect::raise(ostrstream() << "dbChar::insert() of field " 
  452.                                                                         << mTable->tableName() << "." << fieldName()
  453.                                           << " has filled its length of " << maxLen 
  454.                                                                         << " before reaching the end of the field"
  455.                                             );   
  456. #endif
  457.         }
  458.     }
  459.     
  460.     if (gotDataOK) { 
  461.         buildBuf[charsRead] = '\0';  // now make it into a C string!
  462.         *this = buildBuf;  // finally, assign to the record
  463.     }
  464.     delete[] buildBuf;
  465.     return gotDataOK;  // if general stream problem, let caller report it
  466. }
  467.  
  468.  
  469. void dbChar::generateTestData(const char *testBuf, unsigned long testBufLen)
  470. {
  471.     unsigned long randLen = rand()%mMaxLength;
  472.     const char *readFrom = testBuf + rand()%(testBufLen-randLen);
  473.     setChars(readFrom, randLen);
  474. }
  475.  
  476.  
  477. dbQueryBinary    dbChar::operator==(const char* str) const
  478. {
  479.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::equals, new dbQueryLiteralStr(str));
  480. }  
  481.  
  482.  
  483. dbQueryBinary    dbChar::startsWith(const char* str) const
  484. {
  485.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::startsWith, new dbQueryLiteralStr(str));
  486. }  
  487.  
  488.  
  489. dbQueryTrinary    dbChar::between(const char* fromStr, const char* toStr) const
  490. {
  491.     return dbQueryTrinary(new dbQueryField(this), dbQueryClause::between,
  492.         new dbQueryLiteralStr(fromStr), new dbQueryLiteralStr(toStr));
  493. }
  494.  
  495.  
  496. dbQueryTrinary    dbChar::outside(const char* fromStr, const char* toStr) const
  497. {
  498.     return dbQueryTrinary(new dbQueryField(this), dbQueryClause::outside,
  499.         new dbQueryLiteralStr(fromStr), new dbQueryLiteralStr(toStr));
  500. }
  501.  
  502.  
  503. dbQueryBinary    dbChar::operator!=(const char* str) const
  504. {
  505.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::notEquals, new dbQueryLiteralStr(str));
  506. }  
  507.  
  508.  
  509.  dbQueryBinary    dbChar::operator<(const char* str) const
  510. {
  511.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::lessThan, new dbQueryLiteralStr(str));
  512. }  
  513.  
  514.  
  515.  dbQueryBinary    dbChar::operator<=(const char* str) const
  516. {
  517.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::lessThanOrEqual, new dbQueryLiteralStr(str));
  518. }  
  519.  
  520.  
  521.  dbQueryBinary    dbChar::operator>(const char* str) const
  522. {
  523.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::greaterThan, new dbQueryLiteralStr(str));
  524. }  
  525.  
  526.  
  527.  dbQueryBinary    dbChar::operator>=(const char* str) const
  528. {
  529.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::greaterThanOrEqual, new dbQueryLiteralStr(str));
  530. }  
  531.  
  532.  
  533. void dbChar::describe(ostream& os)
  534. {
  535.     dbField::describe(os);
  536.     os << "    and a maximum length of : " << mMaxLength << endl;
  537. }
  538.  
  539.  
  540. dbChar& dbChar::operator()()
  541. {
  542.     dbChar* retField = (dbChar*) GetRelatedFieldOrUs();
  543.     return *retField;
  544. }
  545.  
  546.  
  547. // -------------------------------------------------------
  548. //                      d b T e x t
  549. // -------------------------------------------------------
  550. dbText::operator const char*()
  551. {
  552.     if (!mLoaded)
  553.         LoadField();
  554.     if (fieldDataLen())
  555.         return (char *)mBody;
  556.     else
  557.         return &OOF_String::sEmptyStr;
  558. }
  559.  
  560.  
  561. char * dbText::copyAsChars()
  562. {
  563.     unsigned long len = mBackend->fieldDataLen(this);
  564.     char* ret;
  565.     if (len) {
  566.         ret = new char[len];  // len from DB includes null
  567.         memcpy(ret, (const char*)*this, len);
  568. #ifdef OOF_SmartHeap
  569.     MemPoolCheck(MemDefaultPool);
  570. #endif
  571.     }
  572.     else {
  573.         ret = new char[1];
  574.         ret[0] = '\0';
  575.     }
  576.     return ret;
  577. }
  578.  
  579.  
  580. OOF_fieldTypes dbText::fieldType() const
  581. {
  582.     return textField; 
  583. }
  584.  
  585.  
  586. bool dbText::fieldIsBinary() const
  587. {
  588.     return false;  
  589. }
  590.  
  591.  
  592. dbText& dbText::operator=(dbText& rhs)
  593. {
  594.     if (this == &rhs)  // MUST use this form to avoid invoking the operator== used for searches
  595.         return *this;
  596.     
  597.     *this = (const char*)rhs;
  598.     return *this;
  599. }
  600.  
  601.  
  602. dbText& dbText::operator=(const char* str)
  603. {
  604.     unsigned long charLen;
  605.     if (str)
  606.         charLen = strlen(str);
  607.     else
  608.         charLen = 0;
  609.     if (charLen) {
  610.         allocRoomFor(charLen+1);
  611.         memcpy((char*)mBody, str, charLen);
  612.         ((char*)mBody)[charLen] = '\0';
  613. #ifdef OOF_SmartHeap
  614.     MemPoolCheck(MemDefaultPool);
  615. #endif
  616.         SetLength(charLen+1);
  617.     }
  618.     else
  619.         SetLength(0);
  620.     mBackend->markDirty();
  621.     mDirty = true;
  622.     mLoaded = true;
  623.     return *this;
  624. }
  625.  
  626.  
  627. void dbText::setChars(const char* str , unsigned long charLen)
  628. {
  629.     if (str && charLen) {
  630.         allocRoomFor(charLen+1);
  631.         memcpy(mBody, str, charLen);
  632. #ifdef OOF_SmartHeap
  633.     MemPoolCheck(MemDefaultPool);
  634. #endif
  635.         ((char*)mBody)[charLen]='\0';
  636.         SetLength(charLen+1);
  637.     }
  638.     else
  639.         SetLength(0);
  640.     mBackend->markDirty();
  641.     mDirty = true;
  642.     mLoaded = true;
  643. }
  644.  
  645.  
  646. void dbText::operator+=(const char* str)
  647. {
  648.     unsigned long charLen = strlen(str);
  649.     unsigned long currentFldLen = mBackend->fieldDataLen(this);    // inc null
  650.     if (charLen) {
  651.         unsigned long newLen = currentFldLen+charLen;
  652.         allocRoomFor(newLen);
  653.         if (!mLoaded)
  654.             LoadField();
  655.         memcpy((char*)mBody+currentFldLen-1, str, charLen);    // we KNOW where the null is
  656.         ((char*)mBody)[newLen-1] = '\0';
  657.         #ifdef OOF_SmartHeap
  658.             MemPoolCheck(MemDefaultPool);
  659.         #endif
  660.         SetLength(newLen);
  661.         mBackend->markDirty();
  662.       mDirty = true;
  663.  
  664.     }
  665. }
  666.  
  667.  
  668. void dbText::extract(ostream& os)
  669. {
  670.     os << (const char*)*this;
  671. }
  672.  
  673.  
  674.  
  675. void dbText::generateTestData(const char *testBuf , unsigned long testBufLen)
  676. {
  677.     unsigned long randLen = rand()%testBufLen%10240;        // up to 10kb allowed in one dbText
  678.     const char *readFrom = testBuf + rand()%(testBufLen-randLen);
  679.     setChars(readFrom, randLen);
  680. }
  681.  
  682.  
  683. dbQueryBinary    dbText::operator==(const char* str) const
  684. {
  685.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::equals, new dbQueryLiteralStr(str));
  686. }  
  687.  
  688.  
  689.  dbQueryBinary    dbText::operator!=(const char* str) const
  690. {
  691.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::notEquals, new dbQueryLiteralStr(str));
  692. }  
  693.  
  694.  
  695.  dbQueryBinary    dbText::operator<(const char* str) const
  696. {
  697.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::lessThan, new dbQueryLiteralStr(str));
  698. }  
  699.  
  700.  
  701.  dbQueryBinary    dbText::operator<=(const char* str) const
  702. {
  703.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::lessThanOrEqual, new dbQueryLiteralStr(str));
  704. }  
  705.  
  706.  
  707.  dbQueryBinary    dbText::operator>(const char* str) const
  708. {
  709.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::greaterThan, new dbQueryLiteralStr(str));
  710. }  
  711.  
  712.  
  713.  dbQueryBinary    dbText::operator>=(const char* str) const
  714. {
  715.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::greaterThanOrEqual, new dbQueryLiteralStr(str));
  716. }  
  717.  
  718.  
  719. dbText& dbText::operator()()
  720. {
  721.     dbText* retField = (dbText*) GetRelatedFieldOrUs();
  722.     return *retField;
  723. }
  724.  
  725.  
  726. // -------------------------------------------------------
  727. //                      d b B L O B
  728. // -------------------------------------------------------
  729. dbBLOB::~dbBLOB()
  730. {
  731.     delete[] mBody;
  732. };
  733.  
  734.  
  735. OOF_fieldTypes dbBLOB::fieldType() const
  736. {
  737.     return blobField; 
  738. }
  739.  
  740.  
  741. unsigned long dbBLOB::fieldLen() const
  742. {
  743.     return mBackend->blobPointerReferenceSize();  
  744. }
  745.  
  746.  
  747. bool dbBLOB::fieldIsBlob() const
  748. {
  749.     return true;  
  750. }
  751.  
  752.  
  753. void dbBLOB::SetLength(unsigned long len)
  754. {
  755.     validateContextInCaseRelated();
  756.     mBackend->setBlobLength(mFieldNumber, len);
  757. }
  758.  
  759.  
  760. void dbBLOB::reset()
  761. {
  762.     mDirty = false;
  763.     mLoaded = false;
  764. }
  765.  
  766.  
  767.  
  768. void* dbBLOB::orphanBody()
  769. {
  770.     
  771.     void* ret = mBody;
  772.     reset();
  773.     mBody = 0;
  774.     mBodyLength = 0;
  775.     return ret;
  776. }
  777.  
  778.  
  779.  
  780. void dbBLOB::adoptBody(void* body, unsigned long bodyLen)
  781. {
  782.     delete[] mBody;
  783.     mBody = body;
  784.     mBodyLength = bodyLen;
  785.     mLoaded = mDirty = true;
  786. }
  787.  
  788.  
  789.  
  790. void* dbBLOB::allocRoomFor(unsigned long len)
  791. {
  792.     if (len > mBodyLength) {
  793.         if (mLoaded) {    // assume we must preserve the buffer
  794.             char *newBody = new char[len];
  795.             assert(newBody);
  796.             if (mBody) {
  797.                 memcpy(newBody, mBody, mBodyLength);
  798.                 delete[] mBody;
  799.             }
  800.             mBody = newBody;
  801.         }
  802.         else {            
  803.             delete[] mBody;
  804.             mBody = new char[len];
  805.             assert(mBody);
  806.         }
  807.         mBodyLength = len;
  808.     }
  809. #ifdef OOF_SmartHeap
  810.     MemPoolCheck(MemDefaultPool);
  811. #endif
  812.     return mBody;
  813. }
  814.  
  815.  
  816. void dbBLOB::LoadField()
  817. {
  818.     validateContextInCaseRelated();
  819.     mBackend->loadBlob(this);
  820.     mLoaded = true;
  821. }
  822.  
  823.  
  824. dbBLOB& dbBLOB::operator()()
  825. {
  826.     dbBLOB* retField = (dbBLOB*) GetRelatedFieldOrUs();
  827.     return *retField;
  828. }
  829.  
  830.  
  831.  
  832. // -------------------------------------------------------
  833. //               d b C o m p o u n d F i e l d 
  834. // -------------------------------------------------------
  835. OOF_fieldTypes dbCompoundField::fieldType() const
  836. {
  837.     return compoundField;
  838. }
  839.  
  840.  
  841. unsigned long dbCompoundField::fieldLen() const
  842. {
  843.     return mTotalLength;   
  844. }
  845.  
  846.  
  847. bool dbCompoundField::fieldIsVirtual() const
  848. {
  849.     return true;
  850. }
  851.  
  852.  
  853. const dbField* dbCompoundField::segment(unsigned int i) const
  854. {
  855.     assert(i<mSegments.count());
  856.     return (const dbField*) (mSegments.value(i));  // safe downcast
  857. }
  858.  
  859.  
  860. void dbCompoundField::addSegment(dbField& segfield) {
  861.     assert(segfield.fieldType() != textField);
  862.     mSegments.append(&segfield);
  863.     mTotalLength += segfield.fieldLen();
  864. }
  865.  
  866.  
  867. dbQueryBinary    dbCompoundField::operator==(const char* str) const
  868. {
  869.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::equals, new dbQueryLiteralStr(str));
  870. }  
  871.  
  872.  
  873.  dbQueryBinary    dbCompoundField::operator!=(const char* str) const
  874. {
  875.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::notEquals, new dbQueryLiteralStr(str));
  876. }  
  877.  
  878.  
  879.  dbQueryBinary    dbCompoundField::operator<(const char* str) const
  880. {
  881.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::lessThan, new dbQueryLiteralStr(str));
  882. }  
  883.  
  884.  
  885.  dbQueryBinary    dbCompoundField::operator<=(const char* str) const
  886. {
  887.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::lessThanOrEqual, new dbQueryLiteralStr(str));
  888. }  
  889.  
  890.  
  891.  dbQueryBinary    dbCompoundField::operator>(const char* str) const
  892. {
  893.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::greaterThan, new dbQueryLiteralStr(str));
  894. }  
  895.  
  896.  
  897. dbQueryBinary    dbCompoundField::operator>=(const char* str) const
  898. {
  899.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::greaterThanOrEqual, new dbQueryLiteralStr(str));
  900. }  
  901.  
  902.  
  903. dbQueryBinary    dbCompoundField::startsWith(const char* str) const
  904. {
  905.     return dbQueryBinary(new dbQueryField(this), dbQueryClause::startsWith, new dbQueryLiteralStr(str));
  906. }  
  907.  
  908.  
  909. void dbCompoundField::extract(ostream& os)
  910. {
  911.     unsigned int numSegments = mSegments.count();
  912.     for (unsigned int i=0; i<numSegments; i++) {
  913.         dbField* fld = (dbField*) mSegments[i];  // safe downcast
  914.         fld->extract(os);
  915.     }
  916. }
  917.  
  918.  
  919. // -------------------------------------------------------
  920. //                  O O F I L E _ f i e l d T y p e s
  921. // -------------------------------------------------------
  922. ostream& operator<<(ostream& os, OOF_fieldTypes ft)
  923. {
  924.     switch (ft) {
  925.     case (charField) :
  926.         os << "fixed-length chars";
  927.         break;
  928.         
  929.     case (textField) :
  930.         os << "variable-length text";
  931.         break;
  932.         
  933.     case (dateField) :
  934.         os << "date";
  935.         break;
  936.         
  937.     case (shortField) :
  938.         os << "short integer";
  939.         break;
  940.         
  941.     case (uShortField) :
  942.         os << "unsigned short integer";
  943.         break;
  944.         
  945.     case (longField) :
  946.         os << "long integer";
  947.         break;
  948.         
  949.     case (uLongField) :
  950.         os << "unsigned long integer";
  951.         break;
  952.         
  953.     case (realField) :
  954.         os << "real";
  955.         break;
  956.         
  957.     case (blobField) :
  958.         os << "binary blob";
  959.         break;
  960.         
  961.     case (compoundField) :
  962.         os << "compound";
  963.         break;
  964.         
  965.     case (fixedBinaryField) :
  966.         os << "compound";
  967.         break;
  968.         
  969.     case (boolField) :
  970.         os << "compound";
  971.         break;
  972.         
  973.     }
  974.     return os;
  975. }
  976.  
  977.  
  978.