psearch.c

PB 熟悉的哥们希望大家可以互相学习一下

/***************************************************************
 *                                                             *
 * Copyright (c) 2001-2007 McObject LLC. All Right Reserved.   *
 *                                                             *
 ***************************************************************/

/* This samples demonstartes pattern search methods */

#include "test.h"
#include <platform.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mcowrap.h>

static const char* dbname = "test";
static const int FIRST_SEGSZ = 1024 * 8000UL;
#ifndef MCO_PLATFORM_X64
    static const int PAGESIZE = 96;
#else 
    static const int PAGESIZE = 192;
#endif 

const int MAP_ADDRESS = 0x20000000;

#define PSEARCH_K1 "abc_1*"
#define PSEARCH_K2 "??c_?2?"
#define PSEARCH_K3 5


#define NUMOBJECTS    20

void _SH_(void)
{

    char text[] = 
    {
        "\nThis samples demonstartes basic eXtremeDB pattern search methods.\n"
    };
    char text1[] = 
    {
        "Copyright (c) 2001-2007 McObject LLC. All Right Reserved.\n\n"
    };

    printf("%s\neXtremeDB runtime version %d.%d, build %d\n%s\n\nPress Enter to start", text, MCO_COMP_VER_MAJOR,
           MCO_COMP_VER_MINOR, MCO_COMP_BUILD_NUM, text1);

    getchar();

}


void psearch(mco_db_h db, char* pattern1, char* pattern2, int p3)
{
    MCO_RET rc = 0;
    mco_trans_h trn;
    mco_cursor_t csr;
    TestClass test;
    uint2 size1;

    uint4 v1;
    char key[64];
    char k2[64];

    int4 k3;

    uint4 bsize;
    void* buf;
    mco_pattern_policy_t p;

    /*
     * Get amount of memory needed for set of patterns
     */

    TestClass_i1_pattern_size(pattern1, (uint2)strlen(pattern1), pattern2, (uint2)strlen(pattern2), 0, &bsize);

    /*
     * Allocate memory
     */

    buf = malloc(bsize);

    /* start read-write transaction and initialize	a cursor.
     */
    mco_trans_start(db, MCO_READ_WRITE, MCO_TRANS_FOREGROUND, &trn);

    printf("\n");

    /*
     *  You can change '?' and '*' symbols to any ascii char
     *  or you can ignore other field than char<n> or string
     *
     *  NOTE: change policy operation require RW transaction!
     *  
     */

    mco_get_pattern_policy(trn, &p);
    p.ignore_other_fields = 0;
    mco_set_pattern_policy(trn, &p);


    /*
     * Pattern search
     */

    rc = TestClass_i1_index_cursor(trn, &csr);
    printf("\n\tStart search using all patterns and other index components\n");

    for (rc = TestClass_i1_pattern_search(trn, &csr, buf, bsize, pattern1, (uint2)strlen(pattern1), pattern2, (uint2)
         strlen(pattern2), p3); rc == MCO_S_OK; rc = TestClass_i1_pattern_next(trn, &csr, buf))
    {
        rc = TestClass_from_cursor(trn, &csr, &test);
        TestClass_v1_get(&test, &v1);
        TestClass_k3_get(&test, &k3);
        TestClass_key_get(&test, key, (uint2)sizeof(key), &size1);
        TestClass_k2_get(&test, k2, (uint2)sizeof(k2));

        printf("\t Found: v1=%d, key=%s(%d), k2=%s(%d), k3=%d\n", v1, key, size1, k2, strlen(k2), k3);
    }


    p.ignore_other_fields = 1;
    mco_set_pattern_policy(trn, &p);

    printf("\n\tStart search using all patterns and ignore other index components\n");

    for (rc = TestClass_i1_pattern_search(trn, &csr, buf, bsize, pattern1, (uint2)strlen(pattern1), pattern2, (uint2)
         strlen(pattern2), p3); rc == MCO_S_OK; rc = TestClass_i1_pattern_next(trn, &csr, buf))
    {
        rc = TestClass_from_cursor(trn, &csr, &test);
        TestClass_v1_get(&test, &v1);
        TestClass_k3_get(&test, &k3);
        TestClass_key_get(&test, key, (uint2)sizeof(key), &size1);
        TestClass_k2_get(&test, k2, (uint2)sizeof(k2));

        printf("\t Found: v1=%d, key=%s(%d), k2=%s(%d), k3=%d\n", v1, key, size1, k2, strlen(k2), k3);
    }

    free(buf);

    mco_trans_commit(trn);
    return ;
}

int newobj(mco_db_h db, int id0, uint4 vh)
{
    MCO_RET rc;
    mco_trans_h t;

    TestClass hClass;
    test_oid id;
    char src1[64];
    char src2[64];
    int donetrn = 0;
    uint2 v1 = (uint4)(rand() &0x3FF);
    int4 k3 = (uint4)(rand() % 10);


    id.seq = id0;

    /*
     * open a transaction and obtain a transaction handle. This transaction is a
     * read_write transaction, ran at the FOREGROUND priority level.
     */
    mco_trans_start(db, MCO_READ_WRITE, MCO_TRANS_FOREGROUND, &t);


    /*
     * Allocate a new class and return a class handle. Two input parameters must be
     * passed to the new interface: the transaction handle t and class id. If
     * successful the output parameter hClass is a pointer to the newly allocated class.
     */
    rc = TestClass_new(t, &id, &hClass);
    if (rc)
    {
        goto Err;
    }

    /* assign values, two strings and one integer. By this time, we must
     * know the string size already. Note that return value is not checked
     * with every call. In case of an error, runtime sets the transaction into
     * set "error state" and will return the error indication at commit
     */
    TestClass_v1_put(&hClass, v1);
    TestClass_k3_put(&hClass, k3);
    sprintf(src1, "abc_%03d", rand() &0xff);
    TestClass_key_put(&hClass, src1, (uint2)strlen(src1));
    sprintf(src2, "abc_%03d", rand() &0xff);
    TestClass_k2_put(&hClass, src2, (uint2)strlen(src2));


    /* 
     * commit the transaction unless there is a problem and return 1, otherwise
     * rollback and return 0
     */
    rc = mco_trans_commit(t);
    donetrn = 1;

    /*
     * Important! After the transaction was committed, the class handle is no longer
     * valid. Any attempt to reference the created object would result in error
     * condition.
     */
    if (rc)
    {
        goto Err;
    }

    printf("\n\t v1=%d, k1=%s, k2=%s k3=%d\tinserted okay", v1, src1, src2, k3);
    return 1;

    Err: printf("\n\t error (%d) inserting object with OID %d", rc, id.seq);

    if (!donetrn)
    {
        mco_trans_rollback(t);
    }
    return 0;
}



/* fatal error handler */
static void errhandler(int n)
{
    printf("\neXtremeDB runtime fatal error: %d", n);
    getchar();
    exit( - 1);
}


int main(int argc, char** argv)
{

    MCO_RET rc;
    mco_db_h db = 0;
    int num = NUMOBJECTS, one_id[NUMOBJECTS], vhash[NUMOBJECTS];
    char* start_mem;
    mco_runtime_info_t info;

    _SH_();
    mco_get_runtime_info(&info);

    if (info.mco_shm_supported)
    {
        start_mem = (char*)MAP_ADDRESS;
    }
    else
    {
        start_mem = (char*)malloc(FIRST_SEGSZ);

        if (!start_mem)
        {
            printf("Couldn't allocated memory\n");
            exit(1);
        }
    }

    /* set fatal error handler */
    mco_error_set_handler(&errhandler);

    mco_runtime_start();
    /* Create a database - allocate 2M starting from mem. */
    rc = mco_db_open(dbname, test_get_dictionary(), start_mem, FIRST_SEGSZ, (uint2)PAGESIZE);

    if (rc)
    {
        printf("\nerror creating database");
        free(start_mem);
        exit(1);
    }

    /* connect to the database, obtain a database handle */
    mco_db_connect(dbname, &db);
    printf("\ndb handle = %d\n\tFilling database with random values:", db);

    srand((unsigned)time(NULL));
    while (0 < num--)
    {
        /* get some random values */
        one_id[num] = rand();
        vhash[num] = (uint4)rand();

        /* create a new object */
        newobj(db, one_id[num], vhash[num]);
    }

    if (argc < 4)
    {
        printf("\n\n\tPattern search keys: \"%s\", \"%s\", %d\n", PSEARCH_K1, PSEARCH_K2, PSEARCH_K3);
        psearch(db, PSEARCH_K1, PSEARCH_K2, PSEARCH_K3);
    }
    else
    {
        printf("\n\n\tPattern search keys: \"%s\", \"%s\", %d\n", argv[1], argv[2], atoi(argv[3]));
        psearch(db, argv[1], argv[2], atoi(argv[3]));
    };

    /* disconnect from the database, db is no longer valid */
    mco_db_disconnect(db);

    /* destroy the db */
    mco_db_close(dbname);

    mco_runtime_stop();

    if (!info.mco_shm_supported)
    {
        free(start_mem);
    }

    printf("Press Enter key to exit");
    getchar();
    PROG_EXIT(0);
}