开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
test_bdb.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：44k
源码类别：

生物技术

开发平台：

C/C++

test_bdb.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: test_bdb.cpp,v $
  4.  * PRODUCTION Revision 1000.5  2004/06/01 18:37:53  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.46
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: test_bdb.cpp,v 1000.5 2004/06/01 18:37:53 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author: Anatoliy Kuznetsov
  36.  *
  37.  * File Description: Test application for NCBI Berkeley DB library (BDB)
  38.  *
  39.  */
  42. #include <ncbi_pch.hpp>
  43. #include <corelib/ncbiapp.hpp>
  44. #include <corelib/ncbiargs.hpp>
  45. #include <corelib/ncbifile.hpp>
  46. #include <corelib/ncbitime.hpp>
  47. #include <stdio.h>
  49. #include <bdb/bdb_expt.hpp>
  50. #include <bdb/bdb_types.hpp>
  51. #include <bdb/bdb_file.hpp>
  52. #include <bdb/bdb_env.hpp>
  53. #include <bdb/bdb_cursor.hpp>
  54. #include <bdb/bdb_blob.hpp>
  55. #include <bdb/bdb_map.hpp>
  56. #include <bdb/bdb_blobcache.hpp>
  57. #include <bdb/bdb_filedump.hpp>
  58. #include <bdb/bdb_trans.hpp>
  59. #include <bdb/bdb_query.hpp>
  61. #include <bdb/bdb_query_parser.hpp>
  63. #include <test/test_assert.h>  /* This header must go last */
  65. USING_NCBI_SCOPE;
  69. static const char* s_TestStrTempl = "Test str %i";
  70. static const char* s_StrKeyTempl = "%i test key %i";
  73. ////////////////////////////////
  74. // Test functions, classes, etc.
  75. //
  80. //////////////////////////////////////////////////////////////////
  81. // 
  82. // Structure implements simple database table with integer id primary key
  83. //
  84. //
  86. struct TestDBF1 : public CBDB_IdFile
  87. {
  88.     CBDB_FieldInt4      idata;
  89.     CBDB_FieldString    str;
  90.     CBDB_FieldInt4      i2;
  91.     CBDB_FieldInt2      ishort;
  92.     
  93.     TestDBF1()
  94.     {
  95.         BindData("idata", &idata);
  96.         BindData("str", &str, 256);
  97.         BindData("i2", &i2);
  98.         BindData("ishort", &ishort);
  99.     }
  100. };
  102. struct TestDBF1L : public CBDB_IdFile
  103. {
  104.     CBDB_FieldInt4      idata;
  105.     CBDB_FieldLString   str;
  106.     CBDB_FieldInt4      i2;
  107.     CBDB_FieldInt2      ishort;
  108.     
  109.     TestDBF1L()
  110.     {
  111.         BindData("idata", &idata);
  112.         BindData("str", &str, 256);
  113.         BindData("i2", &i2);
  114.         BindData("ishort", &ishort);
  116.         SetLegacyStringsCheck(true);        
  117.     }
  118. };
  121. // Utility function to check record consistency 
  122. template<class T>
  123. void ValidateRecord(const T& dbf1, unsigned int id)
  124. {
  125.     char buf[256];
  126.     sprintf(buf, s_TestStrTempl, id);
  128.     int idata1 = dbf1.idata;
  129.     unsigned int id_key = dbf1.IdKey;
  130.     string s;
  131.     s = dbf1.str;
  132.     int i21 = dbf1.i2;
  134.     assert(s == string(buf));
  135.     assert(id_key == id);
  136.     assert(idata1 == (int)(400 + id));
  137.     assert(i21 == (int)(id + 3));    
  138. }
  142. const char* s_TestFileName = "testbase.db";
  143. const char* s_TestFileName2= "testbase2.db";
  144. const char* s_TestFileName3= "testbase3.db";
  146. const char* s_db_map1 = "i2s.db";
  147. const char* s_db_map2 = "ii2s.db";
  149. const unsigned int s_RecsInTable = 100;
  152. //////////////////////////////////////////////////////////////////
  153. // 
  154. // Structure implements simple database table with case insensitive string 
  155. // as a primary key
  156. //
  157. //
  159. struct TestDBF2 : public CBDB_File
  160. {
  161.     CBDB_FieldStringCase  str_key;
  162.     CBDB_FieldInt4        idata;
  163.     CBDB_FieldString      str;
  164.     CBDB_FieldInt4        i2;
  166.     TestDBF2()
  167.     {
  168.         BindKey("strkey", &str_key, 256);
  169.         BindData("idata", &idata);
  170.         BindData("str", &str, 256);
  171.         BindData("i2", &i2);
  172.     }
  173. };
  175. // Utility function to check record consistency 
  176. void ValidateRecord(const TestDBF2& dbf2, unsigned i)
  177. {
  178.     char buf[256];
  179.     sprintf(buf, s_StrKeyTempl, i, i);
  180.     string s = (const char*)dbf2.str_key;
  181.     assert(s == string(buf));
  182.     assert(dbf2.idata == (int)(400+i));
  183.     sprintf(buf, s_TestStrTempl, i);
  184.     s = (const char*)dbf2.str;
  185.     assert(s == string(buf));
  186.     assert((int)dbf2.i2 == (int)(i+3));
  187. }
  190. struct TestDBF3 : public CBDB_File
  191. {
  192.     CBDB_FieldInt4        ikey;
  193.     CBDB_FieldInt4        idata;
  195.     TestDBF3()
  196.     {
  197.         BindKey("ikey",   &ikey);
  198.         BindData("idata", &idata);
  199.     }
  200. };
  203. //////////////////////////////////////////////////////////////////
  204. //
  205. // 
  206. // BDB transaction test
  207. //
  208. //
  210. static
  211. void s_TEST_BDB_Transaction(void)
  212. {
  213.     cout << "======== Transactions test." << endl;
  215.     CBDB_Env env;
  216.     env.OpenWithTrans(".");
  217.     
  218.     TestDBF3  dbf3;
  219.     
  220.     dbf3.SetEnv(env);
  221.    
  222.     dbf3.Open("trans_test.db", CBDB_File::eReadWriteCreate);
  223.     cout << dbf3.CountRecs() << endl;
  225.     CBDB_Transaction trans(env);
  227.     dbf3.SetTransaction(&trans);
  229.     dbf3.ikey = 10;
  230.     dbf3.idata = 11;
  231.     dbf3.Insert();
  233.     dbf3.ikey = 12;
  234.     dbf3.idata = 13;
  235.     dbf3.Insert();
  237.     trans.Commit();
  239.     dbf3.ikey = 10;
  240.     EBDB_ErrCode ret = dbf3.Fetch();
  241.     assert (ret == eBDB_Ok);
  242.     
  243.     int idata = dbf3.idata;
  244.     assert(idata == 11);
  246.     dbf3.ikey = 10;
  247.     dbf3.idata = 20;
  248.     dbf3.UpdateInsert();
  250.     ret = dbf3.Fetch();
  251.     assert (ret == eBDB_Ok);
  253.     idata = dbf3.idata;
  254.     assert(idata == 20);
  256.     dbf3.ikey = 12;
  257.     ret = dbf3.Fetch();
  258.     assert (ret == eBDB_Ok);
  260.     idata = dbf3.idata;
  261.     assert(idata == 13);
  263.     trans.Abort();
  265.     dbf3.SetTransaction(0);
  266.     dbf3.ikey = 10;
  267.     ret = dbf3.Fetch();
  268.     assert (ret == eBDB_Ok);
  269.     
  270.     idata = dbf3.idata;
  271.     assert(idata == 11);
  273.     cout << "======== Transactions test ok." << endl;
  274. }
  277. //////////////////////////////////////////////////////////////////
  278. //
  279. // 
  280. // BDB types test
  281. //
  282. //
  284. static void s_TEST_BDB_Types(void)
  285. {
  286.     cout << "======== BDB types test." << endl;
  288.     TestDBF1  dbf1;
  289.     cout << "======== BDB types test ok." << endl;
  290. }
  293. //////////////////////////////////////////////////////////////////
  294. //
  295. // 
  296. // BDB Id table fill test
  297. //
  298. //
  300. static 
  301. void s_IdTableFill(TestDBF1& dbf, unsigned int records)
  302. {
  303.     for (unsigned int i = 1; i < records; ++i) {
  304.         char buf[256];
  305.         sprintf(buf, s_TestStrTempl, i);
  306.         dbf.IdKey = i;
  307.         dbf.idata = 400+i;
  308.         dbf.str = buf;
  309.         dbf.i2.Set(i+3);
  310.         int i2 = dbf.i2;
  311.         assert (i2 == (int)(i+3));
  313.         assert(!dbf.idata.IsNull());
  315.         EBDB_ErrCode err = dbf.Insert();
  316.         assert(err == eBDB_Ok);
  317.         assert(dbf.idata.IsNull());
  318.     }
  320. }
  323. static void s_TEST_BDB_IdTable_Fill(void)
  324. {
  325.     cout << "======== Id table filling test." << endl;
  327.     CBDB_Env env;
  328.     env.OpenWithLocks(0);
  329.     env.OpenErrFile("err_test.txt");
  331.     TestDBF1  dbf1;
  333.     dbf1.SetEnv(env);
  335.     dbf1.SetPageSize(32 * 1024);
  336.     dbf1.SetCacheSize(5 * (1024 * 1024));
  338.     dbf1.Open(s_TestFileName, CBDB_File::eCreate);
  339.     assert(dbf1.idata.IsNull());
  341.     // Fill the table
  343.     unsigned i;
  345.     s_IdTableFill(dbf1, s_RecsInTable);
  346.     
  347.     // Trying to put duplicate record
  349.     dbf1.IdKey = 1;
  350.     dbf1.idata = 400 + 1;
  351.     dbf1.str = "test";
  352.     EBDB_ErrCode err = dbf1.Insert();
  353.     assert(err == eBDB_KeyDup);
  355.     cout << "Table " << s_TestFileName 
  356.          << " loaded ok. Checking consistency." 
  357.          << endl;
  359.     // Read the table check if all records are in place
  361.     dbf1.Reopen(CBDB_File::eReadOnly);
  363.     for (i = 1; i < s_RecsInTable; ++i) {
  364.         dbf1.IdKey = i;
  365.         EBDB_ErrCode ret = dbf1.Fetch();
  366.         assert (ret == eBDB_Ok);
  368.         ValidateRecord(dbf1, i);
  370.     } // for
  372.     {{
  373.     TestDBF1  dbf11;
  374.     dbf11.Attach(dbf1);
  376.     for (i = 1; i < s_RecsInTable; ++i) {
  377.         dbf11.IdKey = i;
  378.         EBDB_ErrCode ret = dbf11.Fetch();
  379.         assert (ret == eBDB_Ok);
  381.         ValidateRecord(dbf11, i);
  383.         // Checking that attached buffer doesn't change status of the main one
  384.         dbf1.IdKey = 1;
  385.         ret = dbf1.Fetch();
  386.         assert (ret == eBDB_Ok);
  387.         ValidateRecord(dbf1, 1);
  389.         ValidateRecord(dbf11, i);
  391.     } // for
  393.     }}
  396.     {{
  397.     TestDBF1L  dbf11;
  398.     dbf11.Open(s_TestFileName, CBDB_File::eReadWrite);
  400.     for (i = 1; i < s_RecsInTable; ++i) {
  401.         dbf11.IdKey = i;
  402.         EBDB_ErrCode ret = dbf11.Fetch();
  403.         assert (ret == eBDB_Ok);
  405.         ValidateRecord(dbf11, i);
  407.     } // for
  409.     string s = "123";
  410.     s.append(1, (char)0);
  411.     s.append("123");
  413.     cout << "(" << s << ")" << s.length() << endl;
  415.     dbf11.IdKey = 1000;
  416.     dbf11.idata = 1000;
  417.     dbf11.str = s;
  419.     dbf11.Insert();
  421.     dbf11.IdKey = 1000;
  422.     EBDB_ErrCode ret = dbf11.Fetch();
  423.     assert (ret == eBDB_Ok);
  425.     string s2 = dbf11.str;
  426.     string s3 = dbf11.str.GetString();
  427.     size_t l2 = s2.length();
  428.     size_t l3 = s3.length();
  429.     assert(s3 == s);
  430.     assert(s2 == s);
  431.     assert(l2 == l3);
  433.     // Dumping the database to screen
  435.     CBDB_FileDumper dump;
  436.     dump.Dump(cout, dbf11);
  438.     }}
  441.     cout << "======== Id table filling test ok." << endl;
  444. }
  448. static void s_TEST_BDB_IdTable_FillStress(void)
  449. {
  450.     cout << "======== Id table filling stress test." << endl;
  452.     CBDB_Env env;
  453.     env.SetCacheSize(150 * (1024 * 1024));
  454.     env.OpenWithLocks(0);
  456.     TestDBF1  dbf1;
  458.     dbf1.SetEnv(env);
  460.     dbf1.Open(s_TestFileName, CBDB_File::eCreate);
  461.     assert(dbf1.idata.IsNull());
  463.     // Fill the table
  465.     unsigned i;
  467.     const unsigned int recs = 1000000;
  469.     s_IdTableFill(dbf1, recs);
  471.     cout << "Table loaded..." << endl;    
  473.     // Read the table check if all records are in place
  475.     dbf1.Reopen(CBDB_File::eReadOnly);
  477.     for (i = 1; i < recs; ++i) {
  478.         dbf1.IdKey = i;
  479.         EBDB_ErrCode ret = dbf1.Fetch();
  480.         assert (ret == eBDB_Ok);
  482.         ValidateRecord(dbf1, i);
  484.     } // for
  486.     cout << "Check 1 complete" << endl;
  488.     dbf1.Reopen(CBDB_File::eReadOnly);
  490.     for (i = 1; i < recs; ++i) {
  492.         {{
  493.             CBDB_FileCursor cur(dbf1);
  494.             cur.SetCondition(CBDB_FileCursor::eEQ);
  496.             cur.From << i;
  497.             EBDB_ErrCode ret = cur.FetchFirst();
  498.             assert (ret == eBDB_Ok);
  499.             ValidateRecord(dbf1, i);
  500.         }}
  503.     } // for
  506.     cout << "======== Id table stress filling test ok." << endl;
  509. }
  512. class CTestScanner : public CBDB_FileScanner
  513. {
  514. public:
  516.     CTestScanner(CBDB_File& db_file)
  517.     : CBDB_FileScanner(db_file)
  518.     {}
  520.     virtual EScanAction OnRecordFound()
  521.     {
  522.         return eContinue;
  523.     }
  525. protected:
  526.     
  527. };
  530. static void s_TEST_BDB_Query(void)
  531. {
  532.     bool bres;
  534.     cout << "======== Query test." << endl;
  536.     TestDBF1  dbf1;
  537.     dbf1.Open(s_TestFileName, CBDB_File::eReadOnly);
  539.     dbf1.IdKey = 1;
  540.     dbf1.Fetch();
  542.     CTestScanner  scanner(dbf1);
  543.     CBDB_Query    query;
  545.     {{
  546.         const char* ch = " test";
  547.         CBDB_Query    query;
  548.         BDB_PrintQueryTree(cout, query);
  550.         BDB_ParseQuery(ch, &query);
  551.         BDB_PrintQueryTree(cout, query);
  552.     }}
  554.     {{
  555.         const char* ch = "  '2' And ((name3 OR 1) & name3)";
  556.         CBDB_Query    query;
  557.         BDB_ParseQuery(ch, &query);
  558.         BDB_PrintQueryTree(cout, query);
  559.     }}
  561.     // Testing the query evaluation logic
  562.     //
  564.     // "1" == "2" => false
  565.     {{
  566.     CBDB_Query::TQueryClause* eq_node = 
  567.           CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "1", "2");
  568.     query.SetQueryClause(eq_node);
  570.     bres = scanner.StaticEvaluate(query);
  572.     assert(!bres);
  573.     BDB_PrintQueryTree(cout, query);
  574.     }}
  576.     {{
  577.     const char* ch = "'1' = 2";
  578.     BDB_ParseQuery(ch, &query);
  579.     bres = scanner.StaticEvaluate(query);
  580.     assert(!bres);
  581.     }}
  583.     {{
  584.     const char* ch = "not '1' = 2";
  585.     BDB_ParseQuery(ch, &query);
  586.     bres = scanner.StaticEvaluate(query);
  587.     cout << endl;
  588.     BDB_PrintQueryTree(cout, query);
  589.     assert(bres);
  590.     }}
  592.     {{
  593.     const char* ch = "'1' != 2";
  594.     BDB_ParseQuery(ch, &query);
  595.     bres = scanner.StaticEvaluate(query);
  596.     assert(bres);
  597.     }}
  599.     {{
  600.     const char* ch = "'1' <> 2";
  601.     BDB_ParseQuery(ch, &query);
  602.     bres = scanner.StaticEvaluate(query);
  603.     assert(bres);
  604.     }}
  606.     {{
  607.     const char* ch = "'1' < 2";
  608.     BDB_ParseQuery(ch, &query);
  609.     bres = scanner.StaticEvaluate(query);
  610.     assert(bres);
  611.     }}
  613.     {{
  614.     const char* ch = "'1' <= 1";
  615.     BDB_ParseQuery(ch, &query);
  616.     bres = scanner.StaticEvaluate(query);
  617.     assert(bres);
  618.     }}
  620.     {{
  621.     const char* ch = "'1' >= 1";
  622.     BDB_ParseQuery(ch, &query);
  623.     bres = scanner.StaticEvaluate(query);
  624.     assert(bres);
  625.     }}
  627.     {{
  628.     const char* ch = "'2' > 1";
  629.     BDB_ParseQuery(ch, &query);
  630.     bres = scanner.StaticEvaluate(query);
  631.     assert(bres);
  632.     }}
  634.     // "2" == "2" => true
  635.     {{
  636.     CBDB_Query::TQueryClause* eq_node = 
  637.           CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "2", "2");
  638.     query.SetQueryClause(eq_node);
  640.     bres = scanner.StaticEvaluate(query);
  642.     assert(bres);
  643.     }}
  646.     {{    
  647.     const char* ch = "2 = 2";
  648.     BDB_ParseQuery(ch, &query);
  649.     bres = scanner.StaticEvaluate(query);
  650.     assert(bres);
  651.     }}
  654.     // ("1" == "1" AND "2" == "2") => true
  655.     {{
  656.     CBDB_Query::TQueryClause* eq_node1 = 
  657.           CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "2", "2");
  658.     CBDB_Query::TQueryClause* eq_node2 = 
  659.           CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "1", "1");
  661.     CBDB_Query::TQueryClause* and_node =
  662.         new CBDB_Query::TQueryClause(CBDB_QueryNode::eAnd);
  663.     and_node->AddNode(eq_node1);
  664.     and_node->AddNode(eq_node2);
  666.     query.SetQueryClause(and_node);
  668.     bres = scanner.StaticEvaluate(query);
  670.     assert(bres);
  671.     }}
  673.     {{    
  674.     const char* ch = "(1=1 AND 2=2)";
  675.     BDB_ParseQuery(ch, &query);
  676.     bres = scanner.StaticEvaluate(query);
  677.     assert(bres);
  678.     }}
  680.     // ("1" == "1" AND "2" == "0") => false
  681.     {{
  682.     CBDB_Query::TQueryClause* eq_node1 = 
  683.           CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "2", "0");
  684.     CBDB_Query::TQueryClause* eq_node2 = 
  685.           CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "1", "1");
  687.     CBDB_Query::TQueryClause* and_node =
  688.         new CBDB_Query::TQueryClause(CBDB_QueryNode::eAnd);
  689.     and_node->AddNode(eq_node1);
  690.     and_node->AddNode(eq_node2);
  692.     query.SetQueryClause(and_node);
  694.     bres = scanner.StaticEvaluate(query);
  696.     assert(!bres);
  698.     BDB_PrintQueryTree(cout, query);
  699.     }}
  701.     {{
  702.     const char* ch = "('1'='1' AND '2'='0')";
  703.     BDB_ParseQuery(ch, &query);
  704.     bres = scanner.StaticEvaluate(query);
  705.     assert(!bres);
  706.     }}
  708.     // ("1" == "1" OR "2" == "0") => true
  709.     {{
  710.     CBDB_Query::TQueryClause* eq_node1 = 
  711.           CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "2", "0");
  712.     CBDB_Query::TQueryClause* eq_node2 = 
  713.           CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "1", "1");
  715.     CBDB_Query::TQueryClause* and_node =
  716.         new CBDB_Query::TQueryClause(CBDB_QueryNode::eOr);
  717.     and_node->AddNode(eq_node1);
  718.     and_node->AddNode(eq_node2);
  720.     query.SetQueryClause(and_node);
  722.     bres = scanner.StaticEvaluate(query);
  724.     assert(bres);
  725.     }}
  727.     {{
  728.     const char* ch = "('1'='1' OR '2'='0')";
  729.     BDB_ParseQuery(ch, &query);
  730.     bres = scanner.StaticEvaluate(query);
  731.     assert(bres);
  732.     }}
  734.     
  735.     // Testing the query evaluation involving data fields
  736.     //
  738.     // (id = 1) =>true
  739.     {{
  740.     CBDB_Query::TQueryClause* eq_node = 
  741.           CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "id", "1");
  742.     query.SetQueryClause(eq_node);
  744.     bres = scanner.StaticEvaluate(query);
  746.     assert(bres);
  747.     }}
  749.     {{
  750.     const char* ch = "id = '1'";
  751.     BDB_ParseQuery(ch, &query);
  752.     bres = scanner.StaticEvaluate(query);
  753.     assert(bres);
  754.     }}
  757.     // ("id" == "1" AND "idata" == "401") => true
  758.     {{
  759.     CBDB_Query::TQueryClause* eq_node1 = 
  760.           CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "id", "1");
  761.     CBDB_Query::TQueryClause* eq_node2 = 
  762.           CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "idata", "401");
  764.     CBDB_Query::TQueryClause* and_node =
  765.         new CBDB_Query::TQueryClause(CBDB_QueryNode::eAnd);
  766.     and_node->AddNode(eq_node1);
  767.     and_node->AddNode(eq_node2);
  769.     query.SetQueryClause(and_node);
  771.     bres = scanner.StaticEvaluate(query);
  773.     assert(bres);
  774.     BDB_PrintQueryTree(cout, query);
  775.     }}
  777.     {{
  778.     const char* ch = "id = '1' AND idata = '401'";
  779.     BDB_ParseQuery(ch, &query);
  780.     bres = scanner.StaticEvaluate(query);
  781.     assert(bres);
  782.     }}
  784.     {{
  785.     const char* ch = "test";
  786.     BDB_ParseQuery(ch, &query);
  787.     bres = scanner.StaticEvaluate(query);
  788.     assert(bres);
  789.     }}
  791.     {{
  792.     const char* ch = "yyy";
  793.     BDB_ParseQuery(ch, &query);
  794.     bres = scanner.StaticEvaluate(query);
  795.     assert(!bres);
  796.     }}
  799.     {{
  800.     const char* ch = "id = '1' AND test";
  801.     BDB_ParseQuery(ch, &query);
  802.     bres = scanner.StaticEvaluate(query);
  803.     assert(bres);
  804.     }}
  806.     {{
  807.     const char* ch = "NOT test AND test";
  808.     BDB_ParseQuery(ch, &query);
  809.     bres = scanner.StaticEvaluate(query);
  810.     BDB_PrintQueryTree(cout, query);
  811.     assert(!bres);
  812.     }}
  814.     cout << "======== Query test ok." << endl;
  815. }
  818. static void s_TEST_BDB_IdTable_Fill2(void)
  819. {
  820.     cout << "======== Id table filling test 2." << endl;
  822.     CBDB_Env env;
  823.     env.OpenWithLocks(0);
  825.     TestDBF1L  dbf1;
  827.     dbf1.SetEnv(env);
  829.     dbf1.SetPageSize(32 * 1024);
  830.     dbf1.SetCacheSize(5 * (1024 * 1024));
  832.     dbf1.Open(s_TestFileName, CBDB_File::eCreate);
  833.     assert(dbf1.idata.IsNull());
  835.     // Fill the table
  837.     unsigned i;
  838.     
  839.     for (i = 1; i < s_RecsInTable; ++i) {
  840.         char buf[256];
  841.         sprintf(buf, s_TestStrTempl, i);
  842.         dbf1.IdKey = i;
  843.         dbf1.idata = 400+i;
  844.         dbf1.str = buf;
  845.         dbf1.i2.Set(i+3);
  846.         int i2 = dbf1.i2;
  847.         assert (i2 == (int)(i+3));
  849.         assert(!dbf1.idata.IsNull());
  851.         EBDB_ErrCode err = dbf1.Insert();
  852.         assert(err == eBDB_Ok);
  853.         assert(dbf1.idata.IsNull());
  854.     }
  856.     // Trying to put duplicate record
  858.     dbf1.IdKey = 1;
  859.     dbf1.idata = 400 + 1;
  860.     dbf1.str = "test";
  861.     EBDB_ErrCode err = dbf1.Insert();
  862.     assert(err == eBDB_KeyDup);
  864.     cout << "Table " << s_TestFileName 
  865.          << " loaded ok. Checking consistency." 
  866.          << endl;
  868.     // Read the table check if all records are in place
  870.     dbf1.Reopen(CBDB_File::eReadOnly);
  872.     for (i = 1; i < s_RecsInTable; ++i) {
  873.         dbf1.IdKey = i;
  874.         EBDB_ErrCode ret = dbf1.Fetch();
  875.         assert (ret == eBDB_Ok);
  877.         ValidateRecord(dbf1, i);
  879.     } // for
  881.     {{
  882.     TestDBF1  dbf11;
  883.     dbf11.Attach(dbf1);
  885.     for (i = 1; i < s_RecsInTable; ++i) {
  886.         dbf11.IdKey = i;
  887.         EBDB_ErrCode ret = dbf11.Fetch();
  888.         assert (ret == eBDB_Ok);
  890.         ValidateRecord(dbf11, i);
  892.         // Checking that attached buffer doesn't change status of the main one
  893.         dbf1.IdKey = 1;
  894.         ret = dbf1.Fetch();
  895.         assert (ret == eBDB_Ok);
  896.         ValidateRecord(dbf1, 1);
  898.         ValidateRecord(dbf11, i);
  900.     } // for
  902.     }}
  905.     {{
  906.     TestDBF1L  dbf11;
  907.     dbf11.Open(s_TestFileName, CBDB_File::eReadWrite);
  909.     for (i = 1; i < s_RecsInTable; ++i) {
  910.         dbf11.IdKey = i;
  911.         EBDB_ErrCode ret = dbf11.Fetch();
  912.         assert (ret == eBDB_Ok);
  914.         ValidateRecord(dbf11, i);
  916.     } // for
  918.     // Dumping the database to screen
  920.     CBDB_FileDumper dump;
  921.     dump.Dump(cout, dbf11);
  923.     }}
  926.     cout << "======== Id table filling test 2 ok." << endl;
  929. }
  933. //////////////////////////////////////////////////////////////////
  934. //
  935. // 
  936. // DBD Id table cursor test
  937. //
  938. //
  940. static void s_TEST_BDB_IdTable_Cursor(void)
  941. {
  942.     cout << "======== Id table cursor test." << endl;
  944.     TestDBF1  dbf1;
  946.     dbf1.Open(s_TestFileName, CBDB_File::eReadOnly);
  948.     // Search point test
  950.     unsigned search_id = s_RecsInTable / 2;
  951.     if (search_id == 0) {
  952.         cout << "Too few records to test cursor operation." << endl;
  953.         assert(0);
  954.     }
  956.     // -----------------------------------
  957.     {{
  958.     cout << "Testing Eq cursor" << endl;
  960.     CBDB_FileCursor cur1(dbf1);
  961.     cur1.SetCondition(CBDB_FileCursor::eEQ);
  963.     cur1.From << search_id;
  964.     
  965.     unsigned recs_fetched = 0;
  967.     while (cur1.Fetch() == eBDB_Ok) {
  968.         unsigned fetched_id = dbf1.IdKey;
  969.         assert(search_id == fetched_id);
  971.         ValidateRecord(dbf1, fetched_id);
  973.         ++recs_fetched;
  974.     }
  976.     assert(recs_fetched == 1);
  978.     }}
  981.     // -----------------------------------
  983.     {{
  985.     cout << "Testing reusable Eq cursor" << endl;
  986.     search_id = s_RecsInTable / 2;
  988.     CBDB_FileCursor cur1(dbf1);
  989.     cur1.SetCondition(CBDB_FileCursor::eEQ);
  991.     for ( ;search_id > 0; --search_id) {
  992.         cur1.From << search_id;
  993.     
  994.         unsigned recs_fetched = 0;
  996.         while (cur1.Fetch() == eBDB_Ok) {
  997.             unsigned fetched_id = dbf1.IdKey;
  998.             assert(search_id == fetched_id);
  1000.             ValidateRecord(dbf1, fetched_id);
  1001.             ++recs_fetched;
  1002.         }
  1004.         assert(recs_fetched == 1);
  1006.     } // for
  1008.     }}
  1010.     // -----------------------------------
  1012.     {{
  1014.     cout << "Testing forward GE - LE cursor" << endl;
  1015.     search_id = s_RecsInTable / 2;
  1017.     CBDB_FileCursor cur1(dbf1);
  1018.     cur1.SetCondition(CBDB_FileCursor::eGE, CBDB_FileCursor::eLE);
  1020.     cur1.From << search_id;
  1021.     cur1.To   << s_RecsInTable - 1;
  1023.     unsigned recs_fetched = 0;
  1025.     for (unsigned i = search_id; cur1.Fetch() == eBDB_Ok; ++i) {
  1026.         unsigned fetched_id = dbf1.IdKey;
  1027.         assert(i == fetched_id);
  1029.         ValidateRecord(dbf1, fetched_id);
  1030.         ++recs_fetched;
  1031.     }
  1033.     assert(recs_fetched == (s_RecsInTable) - search_id);
  1035.     }}
  1037.     // -----------------------------------
  1039.     {{
  1041.     cout << "Testing forward GE - LT cursor" << endl;
  1042.     search_id = s_RecsInTable / 2;
  1044.     CBDB_FileCursor cur1(dbf1);
  1045.     cur1.SetCondition(CBDB_FileCursor::eGE, CBDB_FileCursor::eLT);
  1047.     cur1.From << search_id;
  1048.     cur1.To   << s_RecsInTable - 1;
  1050.     unsigned recs_fetched = 0;
  1052.     for (unsigned i = search_id; cur1.Fetch() == eBDB_Ok; ++i) {
  1053.         unsigned fetched_id = dbf1.IdKey;
  1054.         assert(i == fetched_id);
  1056.         ValidateRecord(dbf1, fetched_id);
  1057.         ++recs_fetched;
  1058.     }
  1060.     assert(recs_fetched == (s_RecsInTable-1) - search_id);
  1062.     }}
  1064.     // -----------------------------------
  1066.     {{
  1068.     cout << "Testing forward GT - LT cursor" << endl;
  1069.     search_id = s_RecsInTable / 2;
  1071.     CBDB_FileCursor cur1(dbf1);
  1072.     cur1.SetCondition(CBDB_FileCursor::eGT, CBDB_FileCursor::eLT);
  1074.     cur1.From << search_id;
  1075.     cur1.To   << s_RecsInTable - 1;
  1077.     unsigned recs_fetched = 0;
  1079.     for (unsigned i = search_id+1; cur1.Fetch() == eBDB_Ok; ++i) {
  1080.         unsigned fetched_id = dbf1.IdKey;
  1081.         assert(i == fetched_id);
  1083.         ValidateRecord(dbf1, fetched_id);
  1084.         ++recs_fetched;
  1085.     }
  1087.     assert(recs_fetched == (s_RecsInTable-2) - search_id);
  1089.     }}
  1091.     // -----------------------------------
  1093.     {{
  1095.     cout << "Testing backward LE - GE cursor" << endl;
  1096.     search_id = s_RecsInTable / 2;
  1098.     CBDB_FileCursor cur1(dbf1);
  1099.     cur1.SetCondition(CBDB_FileCursor::eLE, CBDB_FileCursor::eGE);
  1101.     cur1.From << search_id;
  1102.     cur1.To   << 1;
  1104.     unsigned recs_fetched = 0;
  1106.     for (unsigned i = search_id; cur1.Fetch() == eBDB_Ok; --i) {
  1107.         unsigned fetched_id = dbf1.IdKey;
  1108.         assert(i == fetched_id);
  1110.         ValidateRecord(dbf1, fetched_id);
  1111.         ++recs_fetched;
  1112.     }
  1114.     assert(recs_fetched == search_id);
  1116.     }}
  1118.     // -----------------------------------
  1120.     {{
  1122.     cout << "Testing backward LE - GT cursor" << endl;
  1123.     search_id = s_RecsInTable / 2;
  1125.     CBDB_FileCursor cur1(dbf1);
  1126.     cur1.SetCondition(CBDB_FileCursor::eLE, CBDB_FileCursor::eGT);
  1128.     cur1.From << search_id;
  1129.     cur1.To   << 1;
  1131.     unsigned recs_fetched = 0;
  1133.     for (unsigned i = search_id; cur1.Fetch() == eBDB_Ok; --i) {
  1134.         unsigned fetched_id = dbf1.IdKey;
  1135.         assert(i == fetched_id);
  1137.         ValidateRecord(dbf1, fetched_id);
  1138.         ++recs_fetched;
  1139.     }
  1141.     assert(recs_fetched == search_id - 1);
  1143.     }}
  1145.     // -----------------------------------
  1147.     {{
  1149.     cout << "Testing backward LT - GT cursor" << endl;
  1150.     search_id = s_RecsInTable / 2;
  1152.     CBDB_FileCursor cur1(dbf1);
  1153.     cur1.SetCondition(CBDB_FileCursor::eLT, CBDB_FileCursor::eGT);
  1155.     cur1.From << search_id;
  1156.     cur1.To   << 1;
  1158.     unsigned recs_fetched = 0;
  1160.     for (unsigned i = search_id-1; cur1.Fetch() == eBDB_Ok; --i) {
  1161.         unsigned fetched_id = dbf1.IdKey;
  1162.         assert(i == fetched_id);
  1164.         ValidateRecord(dbf1, fetched_id);
  1165.         ++recs_fetched;
  1166.     }
  1168.     assert(recs_fetched == search_id - 2);
  1170.     }}
  1172.     // -----------------------------------
  1174.     // TO DO: Test illegitimate cases, suppoed to return empty set
  1177.     dbf1.Close();
  1179.     cout << "======== Id table cursor test ok." << endl;    
  1180. }
  1182. //////////////////////////////////////////////////////////////////
  1183. //
  1184. // 
  1185. // LOB test
  1186. //
  1187. //
  1189. static void s_TEST_BDB_LOB_File(void)
  1190. {
  1191.     cout << "======== LOB file test." << endl;    
  1193.     CBDB_LobFile lob;
  1194.     lob.Open("lobtest.db", "lob", CBDB_LobFile::eCreate);
  1196.     const char* test_data = "This is a LOB test data";
  1197.     unsigned lob_len = ::strlen(test_data)+1;
  1199.     EBDB_ErrCode ret = lob.Insert(1, test_data, lob_len);
  1200.     assert(ret == eBDB_Ok);
  1202.     cout << "Testing two-phase read." << endl;
  1203.     lob.Reopen(CBDB_LobFile::eReadOnly);
  1204.     
  1205.     ret = lob.Fetch(1);
  1206.     assert(ret == eBDB_Ok);
  1207.     unsigned len1 = lob.LobSize();
  1208.     assert(len1 == lob_len);
  1210.     char buf[256] = {0,};
  1211.     ret = lob.GetData(buf, sizeof(buf));
  1212.     assert(ret == eBDB_Ok);
  1214.     if (strcmp(buf, test_data) != 0) {
  1215.         cout << "LOB content comparison error!" << endl;
  1216.         cout << "LobData:" << buf << endl;
  1217.         assert(0);
  1218.     }
  1220.     buf[0] = 0;
  1222.     // Reallocate read cannot be used in some cases.
  1223.     // Under Windows if BerkeleyDB libdb*.lib has been build with runtime 
  1224.     // different from application runtime reallocate will crash the application
  1225.     // In this test case test_bdb is build with "Multithreaded Debug DLL" runtime
  1226.     // and Berkeley DB with uses "Mutithereaded DLL". Reallocation is not possible
  1227.     // in this configuration.
  1228. #ifndef _DEBUG
  1229.     cout << "Testing reallocate read." << endl;
  1231.     unsigned buf_size = 5;         // insufficient memory to get the BLOB
  1232.     void* buf2=::malloc(buf_size); 
  1234.     // Here we create a check buf if reallocate fails for some reasons
  1235.     // chances are it will result in checkblock signature failure
  1236.     unsigned check_buf_size = 2000;
  1237.     unsigned* check_buf = new unsigned[check_buf_size];
  1238.     unsigned i;
  1239.     for (i = 0; i < buf_size; ++i) {
  1240.         check_buf[i] = i;
  1241.     }
  1242.     
  1244.     ret = lob.Fetch(1, &buf2, 5, CBDB_LobFile::eReallocAllowed);
  1245.     assert(ret == eBDB_Ok);
  1247.     unsigned new_buf_size = lob.LobSize();
  1248.     assert(buf_size < new_buf_size);
  1250.     if (strcmp((char*)buf2, test_data) != 0) {
  1251.         cout << "LOB content comparison error!" << endl;
  1252.         cout << "LobData:" << buf2 << endl;
  1253.         assert(0);
  1254.     }
  1255.     
  1256.     ::free(buf2);   // should not crash here
  1258.     // Check the signature
  1259.     for (i = 0; i < buf_size; ++i) {
  1260.         assert(check_buf[i] == i);
  1261.     }
  1262. #endif
  1263.     cout << "======== LOB file test ok." << endl;
  1264. }
  1267. //////////////////////////////////////////////////////////////////
  1268. //
  1269. // 
  1270. // LOB test
  1271. //
  1272. //
  1274. struct BLobTestDBF1 : public CBDB_BLobFile
  1275. {
  1276.     CBDB_FieldInt4        i1;
  1277.     CBDB_FieldInt4        i2;
  1279.     BLobTestDBF1()
  1280.     {
  1281.         BindKey("i1", &i1);
  1282.         BindKey("i2", &i2);
  1283.     }
  1284. };
  1287. static void s_TEST_BDB_BLOB_File(void)
  1288. {
  1289.     cout << "======== BLob file test." << endl;    
  1291.     BLobTestDBF1 blob;
  1292.     blob.Open("blobtest.db", "blob", CBDB_LobFile::eCreate);
  1294.     const char* test_data = "This is a BLOB test data";
  1295.     unsigned lob_len = ::strlen(test_data)+1;
  1297.     blob.i1 = 1;
  1298.     blob.i2 = 2;
  1300.     EBDB_ErrCode ret = blob.Insert(test_data, lob_len);
  1301.     assert(ret == eBDB_Ok);
  1303.     blob.i1 = 1;
  1304.     blob.i2 = 3;
  1307.     const char* test_data2 
  1308.         = "This is a BLOB test data.TEst test test test....BDB. test.";
  1309.     lob_len = ::strlen(test_data2)+1;
  1311.     ret = blob.Insert(test_data2, lob_len);
  1312.     assert(ret == eBDB_Ok);
  1314.     {{
  1316.     blob.i1 = 1;
  1317.     blob.i2 = 4;
  1319.     CBDB_BLobStream* bstream = blob.CreateStream();
  1321.     unsigned len = strlen(test_data);
  1322.     for (unsigned i = 0; i < len+1; ++i) {
  1323.         char ch = test_data[i];
  1324.         bstream->Write(&ch, 1);
  1325.     }
  1327.     delete bstream;
  1329.     blob.i1 = 1;
  1330.     blob.i2 = 4;
  1332.     ret = blob.Fetch();
  1333.     assert(ret == eBDB_Ok);
  1334.     unsigned len1 = blob.LobSize();
  1335.     assert(len1 == strlen(test_data)+1);
  1337.     char buf[256] = {0,};
  1338.     ret = blob.GetData(buf, sizeof(buf));
  1339.     assert(ret == eBDB_Ok);
  1341.     if (strcmp(buf, test_data) != 0) {
  1342.         cout << "BLOB content comparison error!" << endl;
  1343.         cout << "BLobData:" << buf << endl;
  1344.         assert(0);
  1345.     }
  1348.     }}
  1350.     cout << "Testing two-phase read." << endl;
  1351.     blob.Reopen(CBDB_LobFile::eReadOnly);
  1352.     
  1353.     blob.i1 = 1;
  1354.     blob.i2 = 2;
  1356.     ret = blob.Fetch();
  1357.     assert(ret == eBDB_Ok);
  1358.     unsigned len1 = blob.LobSize();
  1359.     assert(len1 == strlen(test_data)+1);
  1361.     char buf[256] = {0,};
  1362.     ret = blob.GetData(buf, sizeof(buf));
  1363.     assert(ret == eBDB_Ok);
  1365.     if (strcmp(buf, test_data) != 0) {
  1366.         cout << "BLOB content comparison error!" << endl;
  1367.         cout << "BLobData:" << buf << endl;
  1368.         assert(0);
  1369.     }
  1373.     buf[0] = 0;
  1375.     cout << "Testing BLOB based cursor" << endl;
  1377.     CBDB_FileCursor cur(blob);
  1378.     cur.SetCondition(CBDB_FileCursor::eEQ);
  1380.     cur.From << 1;
  1382.     const char* tdata = test_data;
  1383.     while (cur.Fetch() == eBDB_Ok) {
  1384.     
  1385.         assert(blob.i2 == 2 || blob.i2 == 3 || blob.i2 == 4);
  1386.         unsigned len = blob.LobSize();
  1387.         ret = blob.GetData(buf, sizeof(buf));
  1388.         assert(ret == eBDB_Ok);
  1389.         if (strcmp(buf, tdata) != 0) {
  1390.             int i2 = blob.i2;
  1391.             if (i2 == 4) {
  1392.                 assert(strcmp(buf, test_data) ==0);
  1393.             }
  1394.             else {
  1395.                 cout << "BLOB content comparison error!" << endl;
  1396.                 cout << "BLobData:" << buf << endl;
  1397.                 assert(0);
  1398.             }
  1399.         }
  1400.         cout << "Lob len=" << len << endl;
  1401.         tdata = test_data2;
  1402.     }
  1404.     cout << "Testing read stream" << endl;
  1406.     blob.i1 = 1;
  1407.     blob.i2 = 2;
  1409.     CBDB_BLobStream* bstream = blob.CreateStream();
  1411.     char ch;
  1412.     size_t bytes_read = 0;
  1414.     size_t pending = bstream->PendingCount();
  1415.     
  1417.     for(int i=0;;++i) {
  1418.         bstream->Read(&ch, 1, &bytes_read);
  1419.         if (bytes_read == 0)
  1420.             break;
  1421.         assert(ch == test_data[i]);
  1423.         size_t pend = bstream->PendingCount();
  1424.         assert(pend == pending - 1);
  1426.         pending = pend;
  1427.     }
  1429.     delete bstream;
  1431.     cout << "======== BLob file test ok." << endl;
  1432. }
  1436. //////////////////////////////////////////////////////////////////
  1437. //
  1438. // 
  1439. // Id table record delete test
  1440. //
  1441. //
  1443. static void s_TEST_BDB_IdTable_DeleteInsert(void)
  1444. {
  1445.     cout << "======== BDB Id Table Delete/Insert test." << endl;
  1447.     TestDBF1  dbf1;
  1449.     dbf1.Open(s_TestFileName, CBDB_File::eReadWrite);
  1450.     
  1451.     
  1452.     unsigned int search_id = s_RecsInTable / 2;
  1453.     dbf1.IdKey = search_id;
  1454.     
  1455.     EBDB_ErrCode err = dbf1.Delete();
  1456.     assert(err == eBDB_Ok);
  1458.     dbf1.IdKey = search_id;
  1459.     err = dbf1.Fetch();
  1460.     assert(err == eBDB_NotFound);
  1462.     dbf1.IdKey = search_id;
  1463.     dbf1.idata = 800;
  1464.     dbf1.str = "123456789";
  1465.     dbf1.i2.Set(300);
  1466.     dbf1.Insert();
  1468.     dbf1.IdKey = search_id;
  1469.     err = dbf1.Fetch();
  1470.     assert(err == eBDB_Ok);
  1472.     // Test UpdateInsert
  1474.     dbf1.Reopen(CBDB_File::eReadWrite);
  1475.     dbf1.IdKey = 2;
  1476.     dbf1.idata = 250;
  1477.     dbf1.str = "test";
  1478.     err = dbf1.UpdateInsert();
  1479.     assert(err == eBDB_Ok);
  1481.     dbf1.IdKey = 2;
  1482.     dbf1.idata = 0;
  1483.     err = dbf1.Fetch();
  1484.     assert(err == eBDB_Ok);
  1485.     int idata = dbf1.idata;
  1486.     assert(idata == 250);
  1488.     dbf1.Close();
  1491.     cout << "======== BDB Id Table Delete/Insert test ok." << endl;
  1492. }
  1495. //////////////////////////////////////////////////////////////////
  1496. //
  1497. // 
  1498. // BDB string key table fill test
  1499. //
  1500. //
  1503. static void s_TEST_BDB_StrTable_Fill(void)
  1504. {
  1505.     cout << "======== StrKey table filling test." << endl;
  1507.     TestDBF2  dbf;
  1509.     dbf.Open(s_TestFileName2, CBDB_File::eCreate);
  1511.     // Fill the table
  1513.     unsigned i;
  1514.     for (i = 1; i < s_RecsInTable; ++i) {
  1515.         char buf[256];
  1516.         sprintf(buf, s_StrKeyTempl, i, i);
  1517.         dbf.str_key = buf;
  1518.         dbf.idata = 400+i;
  1519.         sprintf(buf, s_TestStrTempl, i);
  1520.         dbf.str = buf;
  1521.         dbf.i2.Set(i+3);
  1522.         int i2 = dbf.i2;
  1523.         assert (i2 == (int)(i+3));
  1524.         EBDB_ErrCode err = dbf.Insert();
  1525.         assert(err == eBDB_Ok);
  1526.     }
  1528.     cout << "Table " << s_TestFileName2 
  1529.          << " loaded ok. Checking consistency." 
  1530.          << endl;
  1532.     // Read the table check if all records are in place
  1534.     dbf.Reopen(CBDB_File::eReadOnly);
  1536.     for (i = 1; i < s_RecsInTable; ++i) {
  1537.         char buf[256];
  1538.         sprintf(buf, s_StrKeyTempl, i, i);
  1539.         dbf.str_key = buf;
  1540.         EBDB_ErrCode err = dbf.Fetch();
  1541.         assert (err == eBDB_Ok);
  1543.         ValidateRecord(dbf, i);
  1545.     } // for
  1547.     cout << "======== StrKey table filling test ok." << endl;
  1550. }
  1553. //////////////////////////////////////////////////////////////////
  1554. //
  1555. // 
  1556. // Database record structure to test with duplicate records
  1557. //
  1558. //
  1560. struct TestDuplicateKeys : public CBDB_File
  1561. {
  1562.     CBDB_FieldInt4        idata;
  1563.     CBDB_FieldString      str;
  1565.     TestDuplicateKeys() 
  1566.     : CBDB_File(CBDB_File::eDuplicatesEnable)
  1567.     {
  1568.         BindKey("idata", &idata);
  1569.         BindData("str", &str, 256);
  1570.     }
  1571. };
  1573. //////////////////////////////////////////////////////////////////
  1574. //
  1575. // 
  1576. // BDB string key table fill test
  1577. //
  1578. //
  1581. static void s_TEST_BDB_Duplicates(void)
  1582. {
  1583.     cout << "======== Duplicate keys test." << endl;
  1585.     TestDuplicateKeys  dbf;
  1587.     dbf.Open(s_TestFileName3, CBDB_File::eCreate);
  1589.     // Fill the table
  1591.     dbf.idata = 1;
  1592.     dbf.str = "Str1";
  1593.     EBDB_ErrCode ret = dbf.Insert();
  1594.     assert (ret == eBDB_Ok);
  1595.     
  1596.     dbf.idata = 1;
  1597.     dbf.str = "Str11";
  1598.     ret = dbf.Insert();
  1599.     assert (ret == eBDB_Ok);
  1601.     dbf.idata = 10;
  1602.     dbf.str = "Str100";
  1603.     ret = dbf.Insert();
  1604.     assert (ret == eBDB_Ok);
  1606.     {{
  1607.         CBDB_FileCursor cur(dbf);
  1608.         cur.SetCondition(CBDB_FileCursor::eEQ);
  1610.         cur.From << 1;
  1611.         unsigned int recs_fetched = 0;
  1612.         while (cur.Fetch() == eBDB_Ok) {
  1613.             unsigned idata = dbf.idata;
  1614.             assert(idata == 1);
  1616.             string str = (const char*)dbf.str;
  1617.             assert(str == "Str1" || str == "Str11");
  1619.             ++recs_fetched;
  1620.         }
  1622.         assert(recs_fetched == 2);
  1624.     }}
  1626.     dbf.idata = 1;
  1627.     ret = dbf.Delete();
  1628.     assert (ret == eBDB_Ok);
  1629.     {{
  1630.         CBDB_FileCursor cur(dbf);
  1631.         cur.SetCondition(CBDB_FileCursor::eEQ);
  1633.         cur.From << 1;
  1634.         unsigned int recs_fetched = 0;
  1635.         while (cur.Fetch() == eBDB_Ok) {
  1636.             assert(0);
  1637.             ++recs_fetched;
  1638.         }
  1639.         assert(recs_fetched == 0);
  1641.     }}
  1644.     cout << "======== Duplicate keys test ok." << endl;
  1646. }
  1649. //////////////////////////////////////////////////////////////////
  1650. //
  1651. // 
  1652. // db_map test
  1653. //
  1654. //
  1656. bool CheckMapDataValid_i2s(int first, const string& second)
  1657. {
  1658.     char szBuf[256];
  1659.     sprintf(szBuf, "Data%i", first);
  1660.     return second == string(szBuf);
  1661. }
  1663. static void s_TEST_db_map(void)
  1664. {
  1665.     cout << "======== db_map test." << endl;
  1667.     db_map<int, string>  i2s;
  1669.     i2s.open(s_db_map1, ios_base::out|ios_base::trunc);
  1671.     i2s.insert(pair<const int, string>(1, "Data1"));
  1672.     i2s.insert(pair<const int, string>(2, "Data2"));
  1673.     i2s.insert(pair<const int, string>(3, "Data3"));
  1675.     string v = i2s[2];
  1677.     assert(v == "Data2");
  1679.     {{
  1680.     db_map<int, string>::const_iterator it(i2s.begin());
  1681.     while (it.valid()) {
  1682.         bool b = CheckMapDataValid_i2s((*it).first, (*it).second);
  1683.         assert(b);
  1684.         ++it;
  1685.     }
  1687.     }}
  1689.     {{
  1690.     db_map<int, string>::const_iterator it(i2s.begin());
  1691.     db_map<int, string>::const_iterator it_end(i2s.end());
  1692.     for (;it != it_end; ++it) {
  1693.         bool b = CheckMapDataValid_i2s(it->first, it->second);
  1694.         assert(b);
  1695.     }
  1697.     }}
  1699.     i2s.clear();
  1700.     size_t sz = i2s.size();
  1701.     assert(sz == 0);
  1703.     // testing string -> int case
  1705.     db_map<string, int>  s2i;
  1707.     s2i.open("s2i.db", ios_base::out|ios_base::trunc);
  1709.     s2i.insert(pair<const string, int>("Data1", 1));
  1710.     s2i.insert(pair<const string, int>("Data2", 2));
  1711.     s2i.insert(pair<const string, int>("Data3", 3));
  1713.     int i = s2i[string("Data2")];
  1715.     assert(i == 2);
  1718.     cout << "======== db_map test ok." << endl;
  1720. }
  1722. static void s_TEST_db_multimap(void)
  1723. {
  1724.     cout << "======== db_multimap test." << endl;
  1726.     db_multimap<int, string>  ii2s;
  1728.     ii2s.open(s_db_map2, ios_base::out|ios_base::trunc);
  1730.     ii2s.insert(pair<const int, string>(1, "Data1"));
  1731.     ii2s.insert(pair<const int, string>(2, "Data2"));
  1732.     ii2s.insert(pair<const int, string>(3, "Data3"));
  1733.     ii2s.insert(pair<const int, string>(3, "Data31"));
  1735.     size_t sz = ii2s.size();
  1736.     assert(sz == 4);
  1738.     sz = 0;
  1739.     {{
  1740.     db_multimap<int, string>::const_iterator it(ii2s.find(3));
  1741.     while (it.valid()) {
  1742.         const string& data = it->second;
  1743.         if (sz == 0) {
  1744.             assert(data == "Data3");
  1745.         } else {
  1746.             assert(data == "Data31");
  1747.         }
  1749.         ++sz;
  1750.         ++it;
  1751.     }
  1753.     }}
  1754.     assert(sz == 2);
  1756.     ii2s.erase(3);
  1757.     sz = ii2s.size();
  1758.     assert(sz == 2);
  1761.     cout << "======== db_multimap test ok." << endl;
  1763. }
  1765. static void s_TEST_ICache(void)
  1766. {
  1767.     cout << "======== ICache test." << endl;
  1769.     vector<int> data;
  1770.     data.push_back(10);
  1771.     data.push_back(20);
  1772.     data.push_back(30);
  1773.     data.push_back(40);
  1775.     const void* dp = &data[0];
  1777.     CBDB_Cache  bdb_cache;
  1778.     int top = bdb_cache.GetTimeStampPolicy();
  1779.     bdb_cache.SetTimeStampPolicy(top, 30);
  1780.     bdb_cache.Open(".", "bcache", CBDB_Cache::eNoLock, 1024*1024 * 100);
  1782.     bdb_cache.Store("test_key1", 1, "", dp, data.size() * sizeof(int));
  1784.     vector<int> data2;
  1786.     size_t sz = bdb_cache.GetSize("test_key1", 1, "");
  1787.     assert(sz);
  1789.     sz = sz / sizeof(int);
  1790.     assert(sz == data.size());
  1792.     data2.resize(sz);
  1793.     void* dp2 = &data2[0];
  1795.     bool res = bdb_cache.Read("test_key1", 1, "", dp2, sz * sizeof(int));
  1797.     assert(data2[0] == data[0]);
  1798.     assert(data2[1] == data[1]);
  1799.     assert(data2[2] == data[2]);
  1800.     assert(data2[3] == data[3]);
  1802. }
  1805. ////////////////////////////////
  1806. // Test application
  1807. //
  1809. class CBDB_Test : public CNcbiApplication
  1810. {
  1811. public:
  1812.     void Init(void);
  1813.     int Run(void);
  1814. };
  1817. void CBDB_Test::Init(void)
  1818. {
  1819.     SetDiagPostLevel(eDiag_Warning);
  1820.     SetDiagPostFlag(eDPF_File);
  1821.     SetDiagPostFlag(eDPF_Line);
  1822.     auto_ptr<CArgDescriptions> d(new CArgDescriptions);
  1823.     d->SetUsageContext("test_bdb",
  1824.                        "test BDB library");
  1825.     SetupArgDescriptions(d.release());
  1826. }
  1829. int CBDB_Test::Run(void)
  1830. {
  1831.     cout << "Run BDB test" << endl << endl;
  1833.     try
  1834.     {
  1835.         s_TEST_BDB_Types();
  1837.         s_TEST_BDB_IdTable_Fill();
  1839.         // s_TEST_BDB_IdTable_Fill2();
  1841.         s_TEST_BDB_IdTable_Cursor();
  1843.         s_TEST_BDB_IdTable_DeleteInsert();
  1845.         s_TEST_BDB_LOB_File();
  1847.         s_TEST_BDB_BLOB_File();
  1849.         s_TEST_BDB_StrTable_Fill();
  1851.         s_TEST_BDB_Duplicates();
  1853.         s_TEST_BDB_Transaction();
  1855.         s_TEST_db_map();
  1857.         s_TEST_db_multimap();
  1859.         s_TEST_ICache();
  1861.         s_TEST_BDB_Query();
  1863.         s_TEST_BDB_IdTable_FillStress();
  1865.     }
  1866.     catch (CBDB_ErrnoException& ex)
  1867.     {
  1868.         cout << "Error! DBD errno exception:" << ex.what();
  1869.         return 1;
  1870.     }
  1871.     catch (CBDB_LibException& ex)
  1872.     {
  1873.         cout << "Error! DBD library exception:" << ex.what();
  1874.         return 1;
  1875.     }
  1877.     cout << endl;
  1878.     cout << "TEST execution completed successfully!" << endl << endl;
  1879.     return 0;
  1880. }
  1883. ///////////////////////////////////
  1884. // APPLICATION OBJECT  and  MAIN
  1885. //
  1887. int main(int argc, const char* argv[])
  1888. {
  1889.     // Execute main application function
  1890.     return CBDB_Test().AppMain(argc, argv, 0, eDS_Default, 0);
  1891. }
  1894. /*
  1895.  * ===========================================================================
  1896.  * $Log: test_bdb.cpp,v $
  1897.  * Revision 1000.5  2004/06/01 18:37:53  gouriano
  1898.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.46
  1899.  *
  1900.  * Revision 1.46  2004/05/25 18:48:51  kuznets
  1901.  * Added cache RAM size parameter to CBDB_Cache::Open.
  1902.  *
  1903.  * Revision 1.45  2004/05/17 20:55:27  gorelenk
  1904.  * Added include of PCH ncbi_pch.hpp
  1905.  *
  1906.  * Revision 1.44  2004/04/28 12:18:27  kuznets
  1907.  * Remove obsolete IntCache test
  1908.  *
  1909.  * Revision 1.43  2004/03/23 16:37:55  kuznets
  1910.  * Implemented NOT predicate
  1911.  *
  1912.  * Revision 1.42  2004/03/23 14:51:19  kuznets
  1913.  * Implemented logical NOT, <, <=, >, >=
  1914.  *
  1915.  * Revision 1.41  2004/03/12 12:41:50  kuznets
  1916.  * + stress test for cursors
  1917.  *
  1918.  * Revision 1.40  2004/03/10 16:22:22  kuznets
  1919.  * + more tests
  1920.  *
  1921.  * Revision 1.39  2004/03/10 16:19:55  kuznets
  1922.  * + test case for single word queries
  1923.  *
  1924.  * Revision 1.38  2004/03/08 13:36:09  kuznets
  1925.  * One more test case for queries
  1926.  *
  1927.  * Revision 1.37  2004/03/01 14:07:11  kuznets
  1928.  * + test case for queries
  1929.  *
  1930.  * Revision 1.36  2004/02/04 19:16:50  kuznets
  1931.  * Fixed compilation bug (Workshop)
  1932.  *
  1933.  * Revision 1.35  2004/02/04 17:05:47  kuznets
  1934.  * Minor fix (compilation).
  1935.  *
  1936.  * Revision 1.34  2004/02/04 15:13:11  kuznets
  1937.  * + test case for length prefixed strings, when source std::string
  1938.  * contains zero chars.
  1939.  *
  1940.  * Revision 1.33  2003/12/23 22:32:24  ucko
  1941.  * Rename the second s_TEST_BDB_IdTable_Fill, but don't run it yet
  1942.  * because it crashes. :-/
  1943.  *
  1944.  * Revision 1.32  2003/12/22 18:58:02  kuznets
  1945.  * Added l-string test
  1946.  *
  1947.  * Revision 1.31  2003/12/12 19:13:31  kuznets
  1948.  * Transaction test: minor change file opening option.
  1949.  *
  1950.  * Revision 1.30  2003/12/12 14:09:53  kuznets
  1951.  * + s_TEST_BDB_Transaction()
  1952.  *
  1953.  * Revision 1.29  2003/11/26 13:09:44  kuznets
  1954.  * Re-enables icache test
  1955.  *
  1956.  * Revision 1.28  2003/11/25 19:58:37  kuznets
  1957.  * Temporary disabled ICache test (fails on Solaris)
  1958.  *
  1959.  * Revision 1.27  2003/11/25 19:36:54  kuznets
  1960.  * + test for ICache implementation
  1961.  *
  1962.  * Revision 1.26  2003/11/14 04:31:10  ucko
  1963.  * bytes_read should be size_t, not unsigned.
  1964.  *
  1965.  * Revision 1.25  2003/10/27 14:21:15  kuznets
  1966.  * + DBD dumper test
  1967.  *
  1968.  * Revision 1.24  2003/10/24 13:41:51  kuznets
  1969.  * Tested blob stream PendingCount
  1970.  *
  1971.  * Revision 1.23  2003/10/20 20:15:54  kuznets
  1972.  * Cache test improved
  1973.  *
  1974.  * Revision 1.22  2003/10/20 19:59:03  kuznets
  1975.  * + Unit test for Int cache
  1976.  *
  1977.  * Revision 1.21  2003/10/15 18:14:33  kuznets
  1978.  * Changed test to work with alternative page size and larger cache.
  1979.  *
  1980.  * Revision 1.20  2003/09/29 16:54:58  kuznets
  1981.  * Reverting unnecessary commit
  1982.  *
  1983.  * Revision 1.19  2003/09/29 16:27:07  kuznets
  1984.  * Cleaned up 64-bit compilation warnings
  1985.  *
  1986.  * Revision 1.18  2003/09/17 18:19:02  kuznets
  1987.  * Added test for BLOB streaming
  1988.  *
  1989.  * Revision 1.17  2003/09/16 15:15:16  kuznets
  1990.  * Test corrected to use Int2 field
  1991.  *
  1992.  * Revision 1.16  2003/08/27 20:05:33  kuznets
  1993.  * Added test working with file locking environment
  1994.  *
  1995.  * Revision 1.15  2003/07/25 15:35:59  kuznets
  1996.  * Added simple db_map<string, int> test
  1997.  *
  1998.  * Revision 1.14  2003/07/24 15:44:44  kuznets
  1999.  * Clened up several compiler warnings
  2000.  *
  2001.  * Revision 1.13  2003/07/23 20:23:37  kuznets
  2002.  * + test for clean, erase (db_map)
  2003.  *
  2004.  * Revision 1.12  2003/07/22 19:21:56  kuznets
  2005.  * Added test case for CBDB_File::Attach function
  2006.  *
  2007.  * Revision 1.11  2003/07/22 16:38:30  kuznets
  2008.  * Polishing test
  2009.  *
  2010.  * Revision 1.10  2003/07/22 15:21:17  kuznets
  2011.  * Sketched two tet cases for db_map and db_multimap
  2012.  *
  2013.  * Revision 1.9  2003/07/09 14:29:47  kuznets
  2014.  * Added DB_DUP mode test.
  2015.  *
  2016.  * Revision 1.8  2003/05/27 18:05:08  kuznets
  2017.  * Fixed compilation warnings
  2018.  *
  2019.  * Revision 1.7  2003/05/08 13:44:04  kuznets
  2020.  * Minor test improvements
  2021.  *
  2022.  * Revision 1.6  2003/05/07 14:13:45  kuznets
  2023.  * + test case for cursor reading of BLOB storage.
  2024.  *
  2025.  * Revision 1.5  2003/05/05 20:15:35  kuznets
  2026.  * Added CBDB_BLobFile
  2027.  *
  2028.  * Revision 1.4  2003/05/02 14:10:57  kuznets
  2029.  * Added test for UpdateInsert
  2030.  *
  2031.  * Revision 1.3  2003/04/29 20:50:22  kuznets
  2032.  * Code cleanup
  2033.  *
  2034.  * Revision 1.2  2003/04/29 19:04:13  kuznets
  2035.  * +Test makefiles
  2036.  *
  2037.  * Revision 1.1  2003/04/28 18:12:52  kuznets
  2038.  * Initial revision
  2039.  *
  2040.  *
  2041.  * ===========================================================================
  2042.  */