示例#1
0
T_KRDB* kr_db_create(char *psDBName, T_DbsEnv *ptDbsEnv, T_KRModule *ptModule)
{
    T_KRDB *ptDB = (T_KRDB *)kr_calloc(sizeof(T_KRDB));
    if (ptDB == NULL) {
        fprintf(stderr, "kr_calloc ptDB failed!\n");
        return NULL;
    }
    strncpy(ptDB->caDBName, psDBName, sizeof(ptDB->caDBName));
    ptDB->dbsenv = ptDbsEnv;

    ptDB->pTableList = kr_list_new();
    kr_list_set_match(ptDB->pTableList, (KRCompareFunc )kr_tableid_match);
    kr_list_set_free(ptDB->pTableList, (KRFreeFunc )kr_table_drop);

    ptDB->pIndexList = kr_list_new();
    kr_list_set_match(ptDB->pIndexList, (KRCompareFunc )kr_indexid_match);
    kr_list_set_free(ptDB->pIndexList, (KRFreeFunc )kr_index_drop);

    ptDB->pIndexTableList = kr_list_new();
    kr_list_set_match(ptDB->pIndexTableList, (KRCompareFunc )kr_index_table_match);
    kr_list_set_free(ptDB->pIndexTableList, (KRFreeFunc )kr_index_table_drop);


    return ptDB;
}
示例#2
0
T_KRTable* kr_create_table(T_KRDB *krdb, int table_id, 
                char *table_name, char *mmap_file, 
                E_KRSizeKeepMode keep_mode, long keep_value, int field_cnt, 
                KRLoadDefFunc load_field_def_func, 
                KRMapFuncPre map_func_pre,
                KRMapFunc map_func, 
                KRMapFuncPost map_func_post,
                void *param)
{
    T_KRTable *ptTable = kr_calloc(sizeof(T_KRTable));
    if (ptTable == NULL) {
        fprintf(stderr, "kr_calloc ptTable failed!\n");
        return NULL;
    }
    ptTable->iTableId = table_id;
    strncpy(ptTable->caTableName, table_name, sizeof(ptTable->caTableName));
    strncpy(ptTable->caMMapFile, mmap_file, sizeof(ptTable->caMMapFile));
    ptTable->eSizeKeepMode = keep_mode;
    ptTable->lSizeKeepValue = keep_value;
    ptTable->iFieldCnt = field_cnt;
    ptTable->ptFieldDef = kr_calloc(ptTable->iFieldCnt * sizeof(T_KRFieldDef));
    if (ptTable == NULL) {
        fprintf(stderr, "kr_calloc ptTable->ptFieldDef failed!\n");
        return NULL;
    }
    load_field_def_func(param, ptTable->ptFieldDef, &ptTable->iTableId);
    
    ptTable->iRecordSize = sizeof(T_KRRecord);
    int i = 0;
    for (i = 0; i<ptTable->iFieldCnt; i++) {
        ptTable->iRecordSize += ptTable->ptFieldDef[i].length;
    }
    ptTable->iRecordSize = KR_MEMALIGN(ptTable->iRecordSize);

    ptTable->pMapFuncPre = map_func_pre;
    ptTable->pMapFunc = map_func;
    ptTable->pMapFuncPost = map_func_post;
    ptTable->uiRecordNum = 0;
    ptTable->uiRecordLoc = 0;

    if (ptTable->caMMapFile[0] == '\0') {
        ptTable->pRecordBuff = \
            (char *)kr_calloc(ptTable->iRecordSize * ptTable->lSizeKeepValue);
        if (ptTable->pRecordBuff == NULL) {
            fprintf(stderr, "kr_calloc ptTable->pRecordBuff failed!\n");
            return NULL;
        }
    } else {
        if (kr_db_mmap_table(ptTable) != 0) {
            fprintf(stderr, "kr_create_mmap_file failed!\n");
            return NULL;
        }
    }
    ptTable->pIndexList = kr_list_new();
    kr_list_set_match(ptTable->pIndexList, (KRCompareFunc )kr_indexid_match);
    
    kr_list_add_tail(krdb->pTableList, ptTable);

    return ptTable;
}
示例#3
0
int main(int argc,char *argv[])
{
    int i = 0;
    T_KRList *ptList = kr_list_new();
    kr_list_set_compare(ptList, (KRCompareDataFunc )record_compare);
    
    srandom((unsigned int)time(NULL));
    
    for (i=0; i<10; i++) {
        gstRecord[i].i=random()%9;
        gstRecord[i].d = i;
        snprintf(gstRecord[i].s, 20, "record_%d", i);

printf("kr_list_add_sorted[%d] [%d]\n", i, gstRecord[i].i);      
        //kr_list_add_tail(ptList, &gstRecord[i]);
        kr_list_add_sorted(ptList, &gstRecord[i], NULL);
    }
    
    kr_list_foreach(ptList, print_record, NULL);
    
    T_KRListNode *ptNode = kr_list_search(ptList, &gstRecord[7]);
    if (ptNode != NULL) {
        print_record(kr_list_value(ptNode), NULL);
    }
        
    kr_list_destroy(ptList);

    return 0;
}
示例#4
0
T_KROutput* kr_output_construct(T_KRParam *ptParam, char *psOutputModule, 
        KRGetTypeFunc pfGetType, KRGetValueFunc pfGetValue)
{
    T_KROutput *ptOutput = kr_calloc(sizeof(*ptOutput));
    if (ptOutput == NULL) {
        KR_LOG(KR_LOGERROR, "kr_calloc ptOutput failed!");
        return NULL;
    }
    
    /* load output module */
    ptOutput->ptOutputModule = kr_module_open(psOutputModule, RTLD_LAZY);
    if (ptOutput->ptOutputModule == NULL) {
        KR_LOG(KR_LOGERROR, "kr_module_open %s failed!", psOutputModule);
        kr_output_destruct(ptOutput);
        return NULL;
    }
    ptOutput->pfGetType = pfGetType;
    ptOutput->pfGetValue = pfGetValue;
    
    /*alloc output define list*/
    ptOutput->ptOutputDefineList = kr_list_new();
    kr_list_set_match(ptOutput->ptOutputDefineList, (KRListMatchFunc )kr_output_define_match);
    kr_list_set_free(ptOutput->ptOutputDefineList, (KRListFreeFunc )kr_output_define_free);
    
    /*create output list*/
    if (kr_param_object_foreach(ptParam, KR_PARAM_OUTPUT, 
            _kr_output_define_new, ptOutput) != 0) {
        KR_LOG(KR_LOGERROR, "_kr_db_build_table Error!");
        return NULL;
    }
    
    ptOutput->tConstructTime = kr_param_load_time(ptParam);
    
    return ptOutput;
}
示例#5
0
static void kr_rebuild_index_ins(T_KRIndexTable *ptIndextable, T_KRRecord *ptRecord)
{
    void *key = kr_field_get_value(ptRecord, ptIndextable->iIndexFieldId);
    T_KRHashTable *pHashTable = ptIndextable->ptIndex->pHashTable;

    T_KRIndexSolt *ptIndexSlot = kr_hashtable_lookup(pHashTable, key);
    if (ptIndexSlot == NULL) {
        /*create slot if not found*/
        ptIndexSlot = kr_calloc(sizeof(*ptIndexSlot));
        ptIndexSlot->eKeyType = 
            kr_field_get_type(ptRecord, ptIndextable->iIndexFieldId);
        KRDupFunc pfKeyDup = kr_get_dup_func(ptIndexSlot->eKeyType);
        ptIndexSlot->pKeyValue = pfKeyDup(key);
        ptIndexSlot->tLocMinProcTime = kr_get_proctime(ptRecord);
        ptIndexSlot->tLocMinTransTime = kr_get_transtime(ptRecord);
        ptIndexSlot->tExtMaxProcTime = kr_get_proctime(ptRecord);
        ptIndexSlot->tExtMaxTransTime = kr_get_transtime(ptRecord);
        ptIndexSlot->pRecList = kr_list_new();
        kr_hashtable_insert(pHashTable, ptIndexSlot->pKeyValue, ptIndexSlot);
    }

    /*modify statistical fields of local*/
    if (kr_get_proctime(ptRecord) < ptIndexSlot->tLocMinProcTime) {
        ptIndexSlot->tLocMinProcTime = kr_get_proctime(ptRecord);
    }
    if (kr_get_transtime(ptRecord) < ptIndexSlot->tLocMinTransTime) {
        ptIndexSlot->tLocMinTransTime = kr_get_transtime(ptRecord);
    }

    /*add record to list*/
    kr_list_add_tail(ptIndexSlot->pRecList, ptRecord);
}
示例#6
0
T_KRTable* kr_table_create(T_KRDB *ptDB,
        int iTableId, char *psTableName, 
        E_KRSizeKeepMode eKeepMode, long lKeepValue)
{
    T_KRTable *ptTable = kr_calloc(sizeof(T_KRTable));
    if (ptTable == NULL) {
        fprintf(stderr, "kr_calloc ptTable failed!\n");
        return NULL;
    }
    pthread_mutex_init(&ptTable->tLock, NULL);
    ptTable->ptDB = ptDB;
    ptTable->iTableId = iTableId;
    strncpy(ptTable->caTableName, psTableName, sizeof(ptTable->caTableName));
    ptTable->eKeepMode = eKeepMode;
    ptTable->lKeepValue = lKeepValue;
    ptTable->uiRecordNum = 0;
    ptTable->uiRecordLoc = 0;

    ptTable->pIndexTableList = kr_list_new();
    kr_list_set_match(ptTable->pIndexTableList, 
            (KRCompareFunc )kr_index_tableid_match);

    kr_list_add_tail(ptDB->pTableList, ptTable);

    return ptTable;
}
示例#7
0
T_KRIndex* kr_index_create(T_KRDB *ptDB,
        int iIndexId, char *psIndexName, 
        E_KRType eIndexFieldType)
{
    T_KRIndex *ptIndex = (T_KRIndex *)kr_calloc(sizeof(T_KRIndex));
    if (ptIndex == NULL) {
        fprintf(stderr, "kr_calloc ptIndex failed!\n");
        return NULL;
    }
    ptIndex->ptDB = ptDB;
    ptIndex->iIndexId = iIndexId;
    strncpy(ptIndex->caIndexName, psIndexName, sizeof(ptIndex->caIndexName));
    ptIndex->eIndexFieldType = eIndexFieldType;
    KRHashFunc hash_func = (KRHashFunc )kr_get_hash_func(eIndexFieldType);
    KREqualFunc equal_func = (KREqualFunc )kr_get_equal_func(eIndexFieldType);
    ptIndex->pHashTable = kr_hashtable_new(hash_func, equal_func);

    ptIndex->pIndexTableList = kr_list_new();
    kr_list_set_match(ptIndex->pIndexTableList, 
            (KRCompareFunc )kr_table_indexid_match);

    kr_list_add_tail(ptDB->pIndexList, ptIndex);
    
    return ptIndex;
}
示例#8
0
T_KRDB* kr_create_db(char *db_name, T_KRModule *krdbmodule)
{
    T_KRDB *ptDB = (T_KRDB *)kr_calloc(sizeof(T_KRDB));
    if (ptDB == NULL) {
        fprintf(stderr, "kr_calloc ptDB failed!\n");
        return NULL;
    }
    strncpy(ptDB->caDBName, db_name, sizeof(ptDB->caDBName));
    ptDB->ptModule = krdbmodule;
    
    ptDB->pTableList = kr_list_new();
    kr_list_set_match(ptDB->pTableList, (KRCompareFunc )kr_tableid_match);
    
    ptDB->pIndexList = kr_list_new();
    kr_list_set_match(ptDB->pIndexList, (KRCompareFunc )kr_indexid_match);
    
    return ptDB;
}
示例#9
0
static void kr_rebuild_index_ins(T_KRIndex *krindex, T_KRRecord *krrecord)
{
    void *key = kr_get_field_value(krrecord, krindex->iIndexFieldId);
    
    T_KRList *pRecList = kr_hashtable_lookup(krindex->pHashTable, key);
    if (pRecList == NULL) {
        pRecList = kr_list_new();
        kr_list_set_compare(pRecList, (KRCompareDataFunc)kr_db_field_compare);
    }

    if (krindex->iSortFieldId >= 0) {
        kr_list_add_sorted(pRecList, krrecord, &krindex->iSortFieldId);
    } else {
        kr_list_add_tail(pRecList, krrecord);
    }
        
    kr_hashtable_replace(krindex->pHashTable, key, pRecList);
}