test_bdb.cpp

来自「ncbi源码」· C++ 代码 · 共 2,043 行 · 第 1/3 页

    CBDB_Query::TQueryClause* eq_node1 = 
          CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "2", "0");
    CBDB_Query::TQueryClause* eq_node2 = 
          CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "1", "1");

    CBDB_Query::TQueryClause* and_node =
        new CBDB_Query::TQueryClause(CBDB_QueryNode::eAnd);
    and_node->AddNode(eq_node1);
    and_node->AddNode(eq_node2);

    query.SetQueryClause(and_node);

    bres = scanner.StaticEvaluate(query);

    assert(!bres);

    BDB_PrintQueryTree(cout, query);
    }}

    {{
    const char* ch = "('1'='1' AND '2'='0')";
    BDB_ParseQuery(ch, &query);
    bres = scanner.StaticEvaluate(query);
    assert(!bres);
    }}

    // ("1" == "1" OR "2" == "0") => true
    {{
    CBDB_Query::TQueryClause* eq_node1 = 
          CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "2", "0");
    CBDB_Query::TQueryClause* eq_node2 = 
          CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "1", "1");

    CBDB_Query::TQueryClause* and_node =
        new CBDB_Query::TQueryClause(CBDB_QueryNode::eOr);
    and_node->AddNode(eq_node1);
    and_node->AddNode(eq_node2);

    query.SetQueryClause(and_node);

    bres = scanner.StaticEvaluate(query);

    assert(bres);
    }}

    {{
    const char* ch = "('1'='1' OR '2'='0')";
    BDB_ParseQuery(ch, &query);
    bres = scanner.StaticEvaluate(query);
    assert(bres);
    }}

    
    // Testing the query evaluation involving data fields
    //

    // (id = 1) =>true
    {{
    CBDB_Query::TQueryClause* eq_node = 
          CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "id", "1");
    query.SetQueryClause(eq_node);

    bres = scanner.StaticEvaluate(query);

    assert(bres);
    }}

    {{
    const char* ch = "id = '1'";
    BDB_ParseQuery(ch, &query);
    bres = scanner.StaticEvaluate(query);
    assert(bres);
    }}


    // ("id" == "1" AND "idata" == "401") => true
    {{
    CBDB_Query::TQueryClause* eq_node1 = 
          CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "id", "1");
    CBDB_Query::TQueryClause* eq_node2 = 
          CBDB_Query::NewOperatorNode(CBDB_QueryNode::eEQ, "idata", "401");

    CBDB_Query::TQueryClause* and_node =
        new CBDB_Query::TQueryClause(CBDB_QueryNode::eAnd);
    and_node->AddNode(eq_node1);
    and_node->AddNode(eq_node2);

    query.SetQueryClause(and_node);

    bres = scanner.StaticEvaluate(query);

    assert(bres);
    BDB_PrintQueryTree(cout, query);
    }}

    {{
    const char* ch = "id = '1' AND idata = '401'";
    BDB_ParseQuery(ch, &query);
    bres = scanner.StaticEvaluate(query);
    assert(bres);
    }}

    {{
    const char* ch = "test";
    BDB_ParseQuery(ch, &query);
    bres = scanner.StaticEvaluate(query);
    assert(bres);
    }}

    {{
    const char* ch = "yyy";
    BDB_ParseQuery(ch, &query);
    bres = scanner.StaticEvaluate(query);
    assert(!bres);
    }}


    {{
    const char* ch = "id = '1' AND test";
    BDB_ParseQuery(ch, &query);
    bres = scanner.StaticEvaluate(query);
    assert(bres);
    }}

    {{
    const char* ch = "NOT test AND test";
    BDB_ParseQuery(ch, &query);
    bres = scanner.StaticEvaluate(query);
    BDB_PrintQueryTree(cout, query);
    assert(!bres);
    }}

    cout << "======== Query test ok." << endl;
}


static void s_TEST_BDB_IdTable_Fill2(void)
{
    cout << "======== Id table filling test 2." << endl;

    CBDB_Env env;
    env.OpenWithLocks(0);

    TestDBF1L  dbf1;

    dbf1.SetEnv(env);

    dbf1.SetPageSize(32 * 1024);
    dbf1.SetCacheSize(5 * (1024 * 1024));

    dbf1.Open(s_TestFileName, CBDB_File::eCreate);
    assert(dbf1.idata.IsNull());

    // Fill the table

    unsigned i;
    
    for (i = 1; i < s_RecsInTable; ++i) {
        char buf[256];
        sprintf(buf, s_TestStrTempl, i);
        dbf1.IdKey = i;
        dbf1.idata = 400+i;
        dbf1.str = buf;
        dbf1.i2.Set(i+3);
        int i2 = dbf1.i2;
        assert (i2 == (int)(i+3));

        assert(!dbf1.idata.IsNull());

        EBDB_ErrCode err = dbf1.Insert();
        assert(err == eBDB_Ok);
        assert(dbf1.idata.IsNull());
    }

    // Trying to put duplicate record

    dbf1.IdKey = 1;
    dbf1.idata = 400 + 1;
    dbf1.str = "test";
    EBDB_ErrCode err = dbf1.Insert();
    assert(err == eBDB_KeyDup);

    cout << "Table " << s_TestFileName 
         << " loaded ok. Checking consistency." 
         << endl;

    // Read the table check if all records are in place

    dbf1.Reopen(CBDB_File::eReadOnly);

    for (i = 1; i < s_RecsInTable; ++i) {
        dbf1.IdKey = i;
        EBDB_ErrCode ret = dbf1.Fetch();
        assert (ret == eBDB_Ok);

        ValidateRecord(dbf1, i);

    } // for

    {{
    TestDBF1  dbf11;
    dbf11.Attach(dbf1);

    for (i = 1; i < s_RecsInTable; ++i) {
        dbf11.IdKey = i;
        EBDB_ErrCode ret = dbf11.Fetch();
        assert (ret == eBDB_Ok);

        ValidateRecord(dbf11, i);

        // Checking that attached buffer doesn't change status of the main one
        dbf1.IdKey = 1;
        ret = dbf1.Fetch();
        assert (ret == eBDB_Ok);
        ValidateRecord(dbf1, 1);

        ValidateRecord(dbf11, i);

    } // for

    }}


    {{
    TestDBF1L  dbf11;
    dbf11.Open(s_TestFileName, CBDB_File::eReadWrite);

    for (i = 1; i < s_RecsInTable; ++i) {
        dbf11.IdKey = i;
        EBDB_ErrCode ret = dbf11.Fetch();
        assert (ret == eBDB_Ok);

        ValidateRecord(dbf11, i);

    } // for

    // Dumping the database to screen

    CBDB_FileDumper dump;
    dump.Dump(cout, dbf11);

    }}


    cout << "======== Id table filling test 2 ok." << endl;


}



//////////////////////////////////////////////////////////////////
//
// 
// DBD Id table cursor test
//
//

static void s_TEST_BDB_IdTable_Cursor(void)
{
    cout << "======== Id table cursor test." << endl;

    TestDBF1  dbf1;

    dbf1.Open(s_TestFileName, CBDB_File::eReadOnly);

    // Search point test

    unsigned search_id = s_RecsInTable / 2;
    if (search_id == 0) {
        cout << "Too few records to test cursor operation." << endl;
        assert(0);
    }

    // -----------------------------------
    {{
    cout << "Testing Eq cursor" << endl;

    CBDB_FileCursor cur1(dbf1);
    cur1.SetCondition(CBDB_FileCursor::eEQ);

    cur1.From << search_id;
    
    unsigned recs_fetched = 0;

    while (cur1.Fetch() == eBDB_Ok) {
        unsigned fetched_id = dbf1.IdKey;
        assert(search_id == fetched_id);

        ValidateRecord(dbf1, fetched_id);

        ++recs_fetched;
    }

    assert(recs_fetched == 1);

    }}


    // -----------------------------------

    {{

    cout << "Testing reusable Eq cursor" << endl;
    search_id = s_RecsInTable / 2;

    CBDB_FileCursor cur1(dbf1);
    cur1.SetCondition(CBDB_FileCursor::eEQ);

    for ( ;search_id > 0; --search_id) {
        cur1.From << search_id;
    
        unsigned recs_fetched = 0;

        while (cur1.Fetch() == eBDB_Ok) {
            unsigned fetched_id = dbf1.IdKey;
            assert(search_id == fetched_id);

            ValidateRecord(dbf1, fetched_id);
            ++recs_fetched;
        }

        assert(recs_fetched == 1);

    } // for

    }}

    // -----------------------------------

    {{

    cout << "Testing forward GE - LE cursor" << endl;
    search_id = s_RecsInTable / 2;

    CBDB_FileCursor cur1(dbf1);
    cur1.SetCondition(CBDB_FileCursor::eGE, CBDB_FileCursor::eLE);

    cur1.From << search_id;
    cur1.To   << s_RecsInTable - 1;

    unsigned recs_fetched = 0;

    for (unsigned i = search_id; cur1.Fetch() == eBDB_Ok; ++i) {
        unsigned fetched_id = dbf1.IdKey;
        assert(i == fetched_id);

        ValidateRecord(dbf1, fetched_id);
        ++recs_fetched;
    }

    assert(recs_fetched == (s_RecsInTable) - search_id);

    }}

    // -----------------------------------

    {{

    cout << "Testing forward GE - LT cursor" << endl;
    search_id = s_RecsInTable / 2;

    CBDB_FileCursor cur1(dbf1);
    cur1.SetCondition(CBDB_FileCursor::eGE, CBDB_FileCursor::eLT);

    cur1.From << search_id;
    cur1.To   << s_RecsInTable - 1;

    unsigned recs_fetched = 0;

    for (unsigned i = search_id; cur1.Fetch() == eBDB_Ok; ++i) {
        unsigned fetched_id = dbf1.IdKey;
        assert(i == fetched_id);

        ValidateRecord(dbf1, fetched_id);
        ++recs_fetched;
    }

    assert(recs_fetched == (s_RecsInTable-1) - search_id);

    }}

    // -----------------------------------

    {{

    cout << "Testing forward GT - LT cursor" << endl;
    search_id = s_RecsInTable / 2;

    CBDB_FileCursor cur1(dbf1);
    cur1.SetCondition(CBDB_FileCursor::eGT, CBDB_FileCursor::eLT);

    cur1.From << search_id;
    cur1.To   << s_RecsInTable - 1;

    unsigned recs_fetched = 0;

    for (unsigned i = search_id+1; cur1.Fetch() == eBDB_Ok; ++i) {
        unsigned fetched_id = dbf1.IdKey;
        assert(i == fetched_id);

        ValidateRecord(dbf1, fetched_id);
        ++recs_fetched;
    }

    assert(recs_fetched == (s_RecsInTable-2) - search_id);

    }}

    // -----------------------------------

    {{

    cout << "Testing backward LE - GE cursor" << endl;
    search_id = s_RecsInTable / 2;

    CBDB_FileCursor cur1(dbf1);
    cur1.SetCondition(CBDB_FileCursor::eLE, CBDB_FileCursor::eGE);

    cur1.From << search_id;
    cur1.To   << 1;

    unsigned recs_fetched = 0;

    for (unsigned i = search_id; cur1.Fetch() == eBDB_Ok; --i) {
        unsigned fetched_id = dbf1.IdKey;
        assert(i == fetched_id);

        ValidateRecord(dbf1, fetched_id);
        ++recs_fetched;
    }

    assert(recs_fetched == search_id);

    }}

    // -----------------------------------

    {{

    cout << "Testing backward LE - GT cursor" << endl;
    search_id = s_RecsInTable / 2;

    CBDB_FileCursor cur1(dbf1);
    cur1.SetCondition(CBDB_FileCursor::eLE, CBDB_FileCursor::eGT);

    cur1.From << search_id;
    cur1.To   << 1;

    unsigned recs_fetched = 0;

    for (unsigned i = search_id; cur1.Fetch() == eBDB_Ok; --i) {
        unsigned fetched_id = dbf1.IdKey;
        assert(i == fetched_id);

        ValidateRecord(dbf1, fetched_id);
        ++recs_fetched;
    }

    assert(recs_fetched == search_id - 1);

    }}

    // -----------------------------------

    {{

    cout << "Testing backward LT - GT cursor" << endl;
    search_id = s_RecsInTable / 2;

    CBDB_FileCursor cur1(dbf1);
    cur1.SetCondition(CBDB_FileCursor::eLT, CBDB_FileCursor::eGT);

    cur1.From << search_id;
    cur1.To   << 1;

    unsigned recs_fetched = 0;

    for (unsigned i = search_id-1; cur1.Fetch() == eBDB_Ok; --i) {
        unsigned fetched_id = dbf1.IdKey;
        assert(i == fetched_id);

        ValidateRecord(dbf1, fetched_id);
        ++recs_fetched;
    }

    assert(recs_fetched == search_id - 2);

    }}

    // -----------------------------------

    // TO DO: Test illegitimate cases, suppoed to return empty set


    dbf1.Close();

    cout << "======== Id table cursor test ok." << endl;    
}

//////////////////////////////////////////////////////////////////
//
// 
// LOB test
//
//

static void s_TEST_BDB_LOB_File(void)
{
    cout << "======== LOB file test." << endl;    

    CBDB_LobFile lob;
    lob.Open("lobtest.db", "lob", CBDB_LobFile::eCreate);

    const char* test_data = "This is a LOB test data";
    unsigned lob_len = ::strlen(test_data)+1;

    EBDB_ErrCode ret = lob.Insert(1, test_data, lob_len);
    assert(ret == eBDB_Ok);

    cout << "Testing two-phase read." << endl;
    lob.Reopen(CBDB_LobFile::eReadOnly);
    
    ret = lob.Fetch(1);
    assert(ret == eBDB_Ok);
    unsigned len1 = lob.LobSize();
    assert(len1 == lob_len);

    char buf[256] = {0,};
    ret = lob.GetData(buf, sizeof(buf));
    assert(ret == eBDB_Ok);

    if (strcmp(buf, test_data) != 0) {
        cout << "LOB content comparison error!" << endl;
        cout << "LobData:" << buf << endl;
        assert(0);
    }

    buf[0] = 0;

    // Reallocate read cannot be used in some cases.
    // Under Windows if BerkeleyDB libdb*.lib has been build with runtime 
    // different from application runtime reallocate will crash the application
    // In this test case test_bdb is build with "Multithreaded Debug DLL" runtime
    // and Berkeley DB with uses "Mutithereaded DLL". Reallocation is not possible
    // in this configuration.
#ifndef _DEBUG
    cout << "Testing reallocate read." << endl;

    unsigned buf_size = 5;         // insufficient memory to get the BLOB
    void* buf2=::malloc(buf_size); 

    // Here we create a check buf if reallocate fails for some reasons
    // chances are it will result in checkblock signature failure
    unsigned check_buf_size = 2000;
    unsigned* check_buf = new unsigned[check_buf_size];
    unsigned i;
    for (i = 0; i < buf_size; ++i) {
        check_buf[i] = i;
    }
    

    ret = lob.Fetch(1, &buf2, 5, CBDB_LobFile::eReallocAllowed);
    assert(ret == eBDB_Ok);

    unsigned new_buf_size = lob.LobSize();
    assert(buf_size < new_buf_size);

    if (strcmp((char*)buf2, test_data) != 0) {
        cout << "LOB content comparison error!" << endl;
        cout << "LobData:" << buf2 << endl;
        assert(0);
    }
    
    ::free(buf2);   // should not crash here

    // Check the signature
    for (i = 0; i < buf_size; ++i) {
        assert(check_buf[i] == i);
    }
#endif
    cout << "======== LOB file test ok." << endl;
}


//////////////////////////////////////////////////////////////////
//
// 
// LOB test
//
//

struct BLobTestDBF1 : public CBDB_BLobFile
{
    CBDB_FieldInt4        i1;
    CBDB_FieldInt4        i2;

    BLobTestDBF1()
    {
        BindKey("i1", &i1);
        BindKey("i2", &i2);
    }
};


static void s_TEST_BDB_BLOB_File(void)
{
    cout << "======== BLob file test." << endl;    

    BLobTestDBF1 blob;
    blob.Open("blobtest.db", "blob", CBDB_LobFile::eCreate);

    const char* test_data = "This is a BLOB test data";
    unsigned lob_len = ::strlen(test_data)+1;

    blob.i1 = 1;
    blob.i2 = 2;

    EBDB_ErrCode ret = blob.Insert(test_data, lob_len);
    assert(ret == eBDB_Ok);

    blob.i1 = 1;
    blob.i2 = 3;


    const char* test_data2 
        = "This is a BLOB test data.TEst test test test....BDB. test.";
    lob_len = ::strlen(test_data2)+1;

    ret = blob.Insert(test_data2, lob_len);
    assert(ret == eBDB_Ok);

    {{

    blob.i1 = 1;
    blob.i2 = 4;

    CBDB_BLobStream* bstream = blob.CreateStream();

    unsigned len = strlen(test_data);
    for (unsigned i = 0; i < len+1; ++i) {
        char ch = test_data[i];
        bstream->Write(&ch, 1);
    }

    delete bstream;

    blob.i1 = 1;
    blob.i2 = 4;

    ret = blob.Fetch();
    assert(ret == eBDB_Ok);
    unsigned len1 = blob.LobSize();
    assert(len1 == strlen(test_data)+1);

    char buf[256] = {0,};
    ret = blob.GetData(buf, sizeof(buf));
    assert(ret == eBDB_Ok);

    if (strcmp(buf, test_data) != 0) {
        cout << "BLOB content comparison error!" << endl;
        cout << "BLobData:" << buf << endl;
        assert(0);
    }


    }}

    cout << "Testing two-phase read." << endl;
    blob.Reopen(CBDB_LobFile::eReadOnly);
    
    blob.i1 = 1;
    blob.i2 = 2;

    ret = blob.Fetch();
    assert(ret == eBDB_Ok);
    unsigned len1 = blob.LobSize();
    assert(len1 == strlen(test_data)+1);

    char buf[256] = {0,};
    ret = blob.GetData(buf, sizeof(buf));