home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Demos / OOFILE / Buildable, limited OOFILE / OOFILE partial source / oofquery.cpp < prev    next >
Encoding:
Text File  |  1995-09-26  |  10.0 KB  |  431 lines  |  [TEXT/CWIE]
  1. // COPYRIGHT 1994 A.D. Software, All rights reserved
  2.  
  3. // OOFILE database queries
  4.  
  5. #include "oofquery.hpp"
  6. #include "oof3.hpp"
  7. #include <assert.h>
  8.  
  9. // -------------------------------------------------------
  10. //                 d b Q u e r y C l a u s e
  11. // -------------------------------------------------------
  12. dbQueryBinaryCombo dbQueryClause::operator&(dbQueryClause& rhs) const
  13. {
  14.     return dbQueryBinaryCombo(this, dbQueryClause::and, &rhs);
  15. }
  16.  
  17.  
  18. dbQueryBinaryCombo dbQueryClause::operator&&(dbQueryClause& rhs) const
  19. {
  20.     return dbQueryBinaryCombo(this, dbQueryClause::and, &rhs);
  21. }
  22.  
  23.  
  24. dbQueryBinaryCombo dbQueryClause::operator|(dbQueryClause& rhs) const
  25. {
  26.     return dbQueryBinaryCombo(this, dbQueryClause::or, &rhs);
  27. }
  28.  
  29.  
  30. dbQueryBinaryCombo dbQueryClause::operator||(dbQueryClause& rhs) const
  31. {
  32.     return dbQueryBinaryCombo(this, dbQueryClause::or, &rhs);
  33. }
  34.  
  35.  
  36.  
  37. // -------------------------------------------------------
  38. //                 d b Q u e r y B i n a r y 
  39. // -------------------------------------------------------
  40. dbQueryBinary::dbQueryBinary(dbQueryBinary& rhs)
  41. {
  42.     mLhs = rhs.mLhs;
  43.     mRhs = rhs.mRhs;
  44.     mBinOp = rhs.mBinOp;
  45.     rhs.mLhs = 0;
  46.     rhs.mRhs = 0;
  47. }
  48.  
  49.  
  50. dbQueryBinary::~dbQueryBinary()
  51. {
  52.     delete mLhs;
  53.     delete mRhs;
  54. }
  55.  
  56.  
  57. dbQueryBinary& dbQueryBinary::operator=(dbQueryBinary& rhs) 
  58. { 
  59.     assert(0);  // should never be called
  60.     return *this; 
  61. };
  62.  
  63.  
  64. dbQueryClause::QueryClauseTypes  dbQueryBinary::queryClauseType()  const
  65. {
  66.     if (mRhs->queryClauseType()==atomicfield)
  67.         return binaryfieldTofield;
  68.     else
  69.         return binaryfieldToLiteral;
  70. }
  71.  
  72.  
  73. dbQueryLiteralStr* dbQueryBinary::literalStrClause() const
  74. {
  75.     if (mRhs->queryClauseType()==atomicLiteralStr) 
  76.         return (dbQueryLiteralStr*) mRhs;  // safe downcast
  77.     else
  78.         return 0;
  79. }
  80.  
  81.  
  82. dbQueryLiteral* dbQueryBinary::literalClause() const
  83. {
  84. // NOTE the following assumes that logic to handle binary logical clauses is a superset of
  85. // that handling strings, and if the difference is important we have tried literalStrClause()
  86. // BEFORE trying this routine
  87.     if ((mRhs->queryClauseType()==atomicLiteral) || (mRhs->queryClauseType()==atomicLiteralStr))
  88.         return (dbQueryLiteral*) mRhs;  // safe downcast, actually to a parent of the exact type (a dbQueryLiteralLong etc.)
  89.     else
  90.         return 0;
  91. }
  92.  
  93.  
  94.  
  95. // -------------------------------------------------------
  96. //           d b Q u e r y B i n a r y C o m b o
  97. // -------------------------------------------------------
  98. dbQueryBinaryCombo::~dbQueryBinaryCombo()
  99. {
  100.     delete[] mTempKeyStoreToDispose;
  101. }
  102.  
  103.  
  104. dbQueryBinaryCombo::dbQueryBinaryCombo(dbQueryBinaryCombo& rhs)
  105. {
  106.     mLhs = rhs.mLhs;
  107.     mRhs = rhs.mRhs;
  108.     mComboOp = rhs.mComboOp;
  109.     mTempKeyStoreToDispose = 0;
  110. // don't need to clear rhs pointers as not deleted
  111. }
  112.  
  113.  
  114. dbQueryBinaryCombo& dbQueryBinaryCombo::operator=(dbQueryBinaryCombo& rhs) 
  115. { 
  116.     assert(0);  // should never be called
  117.     return *this; 
  118. };
  119.  
  120.  
  121. dbQueryClause::QueryClauseTypes  dbQueryBinaryCombo::queryClauseType()  const
  122. {
  123.     return binaryCombination;
  124. }
  125.  
  126.     
  127. const dbQueryClause* dbQueryBinaryCombo::item(unsigned int i) const
  128. {
  129.     assert(i<2);  // for now, later will have a list of items
  130.     if (i==0)
  131.         return mLhs;
  132.     else
  133.         return mRhs;
  134. }
  135.  
  136.  
  137. unsigned long dbQueryBinaryCombo::pairFieldsIfCouldUseCompoundIndex() const
  138. {
  139.     if (mComboOp != and)
  140.         return 0;  // early failure - they're not ANDed
  141.         
  142.     if (mLhs->queryClauseType() != binaryfieldToLiteral)
  143.         return 0;
  144.         
  145.     if (mRhs->queryClauseType() != binaryfieldToLiteral)
  146.         return 0;
  147.         
  148.     dbQueryBinary* lhs = (dbQueryBinary*) mLhs;  // safe downcast due to above tests 
  149.     if (lhs->binaryOperator() != equals)
  150.         return 0;
  151.         
  152.     dbQueryBinary* rhs = (dbQueryBinary*) mRhs;  // safe downcast due to above tests 
  153.     if (rhs->binaryOperator() != equals) 
  154.         return 0;
  155.         
  156. // if get here have an expression that CAN be used with a compound index
  157. // ie:  A==a && B==b 
  158.     const dbField* fld = lhs->lhsField();
  159.     unsigned long ret = fld->fieldNumber();
  160.     fld = rhs->lhsField();
  161.     ret = (ret << 16) + fld->fieldNumber();
  162.     return ret;
  163. }
  164.  
  165.  
  166. dbQueryBinary dbQueryBinaryCombo::makeCompoundSearch(const dbCompoundField* fld)
  167. {
  168. // this gets a little complicated:
  169. // we make this look like a string query, BUT 
  170. // either of our components can really be binary values
  171. // and we also must pad out the LHS to its full key width
  172.     assert(fld->fieldLen()<USHRT_MAX);
  173.     unsigned short keyLen = fld->fieldLen();
  174.     char* target = new char[keyLen];  // uh oh - we need to delete this after the query succeeds!
  175.     assert(target);
  176.     if (mTempKeyStoreToDispose)
  177.         delete[] mTempKeyStoreToDispose;  // just in case we are reusing a query object somehow
  178.     mTempKeyStoreToDispose = target;
  179.  
  180.     {
  181.         assert(mLhs->queryClauseType() == binaryfieldToLiteral);
  182.         dbQueryLiteral* lit = ((dbQueryBinary*) mLhs)->literalClause();  // safe downcast
  183.         assert(lit);
  184.         memset(target, 0, keyLen);  // clear the entire compound key width
  185.     // NOT YET IMPLEMENTED - would be a loop for more than 2 segments
  186.         memcpy(target, lit->binaryContents(), lit->literalLen());    
  187.         #ifdef OOF_SmartHeap
  188.             MemPoolCheck(MemDefaultPool);
  189.         #endif
  190.     }
  191.     
  192.     assert(mRhs->queryClauseType() == binaryfieldToLiteral);
  193.     dbQueryBinary* rhs = (dbQueryBinary*) mRhs;  // safe downcast
  194.     dbQueryLiteral* finalLit = rhs->literalClause();
  195.     target += fld->segment(0)->fieldLen();
  196.     memcpy(target, finalLit->binaryContents(), finalLit->literalLen());    
  197.     #ifdef OOF_SmartHeap
  198.         MemPoolCheck(MemDefaultPool);
  199.     #endif
  200.     
  201.     return dbQueryBinary(    new dbQueryField(fld), 
  202.                                                 rhs->binaryOperator(), 
  203.                                                 new dbQueryLiteralBLOB(mTempKeyStoreToDispose, keyLen)
  204.                                             );
  205. }
  206.  
  207.  
  208. // -------------------------------------------------------
  209. //                 d b Q u e r y T r i n a r y 
  210. // -------------------------------------------------------
  211. // NOTE there is a lot of horrible code in this class
  212. // it is offensively coarse, but reasonably efficient and a long way
  213. // down the priority list for a rewrite.
  214. dbQueryTrinary::dbQueryTrinary(dbQueryTrinary& rhs)
  215. {
  216.     mLhs = rhs.mLhs;
  217.     mFrom = rhs.mFrom;
  218.     mTo = rhs.mTo;
  219.     mTrinOp = rhs.mTrinOp;
  220.     rhs.mLhs = 0;
  221.     rhs.mFrom = 0;
  222.     rhs.mTo = 0;
  223. }
  224.  
  225.  
  226. dbQueryTrinary::~dbQueryTrinary()
  227. {
  228.     delete mLhs;
  229.     delete mFrom;
  230.     delete mTo;
  231. }
  232.  
  233.  
  234. dbQueryTrinary& dbQueryTrinary::operator=(dbQueryTrinary& rhs) 
  235. { 
  236.     assert(0);  // should never be called
  237.     return *this; 
  238. };
  239.  
  240.  
  241. dbQueryClause::QueryClauseTypes  dbQueryTrinary::queryClauseType()  const
  242. {
  243.         return trinaryFieldToLiterals;
  244. }
  245.  
  246.  
  247. dbQueryLiteralStr* dbQueryTrinary::literalStrFromClause() const
  248. {
  249.     if (mFrom->queryClauseType()==atomicLiteralStr) 
  250.         return (dbQueryLiteralStr*) mFrom;  // safe downcast
  251.     else
  252.         return 0;
  253. }
  254.  
  255.  
  256. dbQueryLiteralStr* dbQueryTrinary::literalStrToClause() const
  257. {
  258.     if (mTo->queryClauseType()==atomicLiteralStr) 
  259.         return (dbQueryLiteralStr*) mTo;  // safe downcast
  260.     else
  261.         return 0;
  262. }
  263.  
  264.  
  265. dbQueryLiteral* dbQueryTrinary::literalFromClause() const
  266. {
  267.     if (mFrom->queryClauseType()==atomicLiteral) 
  268.         return (dbQueryLiteral*) mFrom;  // safe downcast
  269.         return 0;
  270. }
  271.  
  272.     
  273. dbQueryLiteral* dbQueryTrinary::literalToClause() const
  274. {
  275.     if (mTo->queryClauseType()==atomicLiteral) 
  276.         return (dbQueryLiteral*) mTo;  // safe downcast
  277.     else
  278.         return 0;
  279. }
  280.  
  281.     
  282. // -------------------------------------------------------
  283. //                 d b Q u e r y F i e l d
  284. // -------------------------------------------------------
  285. dbQueryClause::QueryClauseTypes  dbQueryField::queryClauseType()  const
  286. {
  287.     return atomicfield;
  288. }
  289.  
  290.  
  291. // -------------------------------------------------------
  292. //                 d b Q u e r y L i t e r a l
  293. // -------------------------------------------------------
  294. dbQueryClause::QueryClauseTypes  dbQueryLiteral::queryClauseType()  const
  295. {
  296.     return atomicLiteral;
  297. }
  298.  
  299.  
  300. const void* dbQueryLiteral:: binaryContents() const
  301. {
  302.     return 0;
  303. }
  304.  
  305.  
  306. unsigned short dbQueryLiteral::literalLen() const
  307. {
  308.     return 0;
  309. }
  310.  
  311.     
  312. // -------------------------------------------------------
  313. //          d b Q u e r y L i t e r a l L o n g
  314. // -------------------------------------------------------
  315. const void* dbQueryLiteralLong:: binaryContents() const
  316. {
  317.     return &mNum;
  318. }
  319.  
  320.  
  321. unsigned short dbQueryLiteralLong::literalLen() const
  322. {
  323.     return sizeof(long);
  324. }
  325.  
  326.  
  327.     
  328. // -------------------------------------------------------
  329. //          d b Q u e r y L i t e r a l U l o n g
  330. // -------------------------------------------------------
  331. const void* dbQueryLiteralUlong:: binaryContents() const
  332. {
  333.     return &mNum;
  334. }
  335.  
  336.  
  337. unsigned short dbQueryLiteralUlong::literalLen() const
  338. {
  339.     return sizeof(unsigned long);
  340. }
  341.  
  342.  
  343.     
  344. // -------------------------------------------------------
  345. //          d b Q u e r y L i t e r a l S h o r t
  346. // -------------------------------------------------------
  347. const void* dbQueryLiteralShort:: binaryContents() const
  348. {
  349.     return &mNum;
  350. }
  351.  
  352.  
  353. unsigned short dbQueryLiteralShort::literalLen() const
  354. {
  355.     return sizeof(short);
  356. }
  357.  
  358.  
  359.     
  360. // -------------------------------------------------------
  361. //          d b Q u e r y L i t e r a l U s h o r t
  362. // -------------------------------------------------------
  363. const void* dbQueryLiteralUshort:: binaryContents() const
  364. {
  365.     return &mNum;
  366. }
  367.  
  368.  
  369. unsigned short dbQueryLiteralUshort::literalLen() const
  370. {
  371.     return sizeof(unsigned short);
  372. }
  373.  
  374.  
  375.     
  376. // -------------------------------------------------------
  377. //         d b Q u e r y L i t e r a l D o u b l e
  378. // -------------------------------------------------------
  379. const void* dbQueryLiteralDouble:: binaryContents() const
  380. {
  381.     return &mNum;
  382. }
  383.  
  384.  
  385. unsigned short dbQueryLiteralDouble::literalLen() const
  386. {
  387.     return sizeof(double);
  388. }
  389.  
  390.  
  391.     
  392. // -------------------------------------------------------
  393. //         d b Q u e r y L i t e r a l B L O B
  394. // -------------------------------------------------------
  395. const void* dbQueryLiteralBLOB:: binaryContents() const
  396. {
  397.     return mBLOB;
  398. }
  399.  
  400.  
  401. unsigned short dbQueryLiteralBLOB::literalLen() const
  402. {
  403.     return mBLOBlen;
  404. }
  405.  
  406.  
  407.     
  408. // -------------------------------------------------------
  409. //            d b Q u e r y L i t e r a l S t r
  410. // -------------------------------------------------------
  411. dbQueryClause::QueryClauseTypes  dbQueryLiteralStr::queryClauseType()  const
  412. {
  413.     return atomicLiteralStr;
  414. }
  415.  
  416.  
  417. const void* dbQueryLiteralStr::binaryContents() const
  418. {
  419.     return mStr;
  420. }
  421.  
  422.  
  423. unsigned short dbQueryLiteralStr::literalLen() const
  424. {
  425.     if (!mStr)
  426.         return 0;
  427.     return strlen(mStr);
  428. }
  429.  
  430.  
  431.