コード例 #1
0
ファイル: tdb_encode.c プロジェクト: tempbottle/traildb
static tdb_error groupby_uuid(FILE *grouped_w,
                              const struct tdb_cons_event *events,
                              tdb_cons *cons,
                              uint64_t *num_trails,
                              uint64_t *max_timestamp,
                              uint64_t *max_timedelta)
{
    struct jm_fold_state state = {
        .grouped_w = grouped_w,
        .events = events,
        .min_timestamp = cons->min_timestamp
    };

    /* we require (min_timestamp - 0 < TDB_MAX_TIMEDELTA) */
    if (cons->min_timestamp >= TDB_MAX_TIMEDELTA)
        return TDB_ERR_TIMESTAMP_TOO_LARGE;

    j128m_fold(&cons->trails, groupby_uuid_handle_one_trail, &state);

    *num_trails = state.trail_id;
    *max_timestamp = state.max_timestamp;
    *max_timedelta = state.max_timedelta;

    free(state.buf);
    return state.ret;
}

tdb_error edge_encode_items(const tdb_item *items,
                            tdb_item **encoded,
                            uint64_t *num_encoded,
                            uint64_t *encoded_size,
                            tdb_item *prev_items,
                            const struct tdb_grouped_event *ev)
{
    uint64_t n = 0;
    uint64_t j = ev->item_zero;
    /* edge encode items: keep only fields that are different from
       the previous event */
    for (; j < ev->item_zero + ev->num_items; j++){
        tdb_field field = tdb_item_field(items[j]);
        if (prev_items[field] != items[j]){
            if (n == *encoded_size){
                *encoded_size += EDGE_INCREMENT;
                if (!(*encoded = realloc(*encoded,
                                         *encoded_size * sizeof(tdb_item))))
                    return TDB_ERR_NOMEM;
            }
            (*encoded)[n++] = prev_items[field] = items[j];
        }
    }
    *num_encoded = n;
    return 0;
}
コード例 #2
0
ファイル: tdb_cons.c プロジェクト: KalenAnson/traildb
static tdb_error store_uuids(tdb_cons *cons)
{
    char path[TDB_MAX_PATH_SIZE];
    struct jm_fold_state state = {.ret = 0};
    uint64_t num_trails = j128m_num_keys(&cons->trails);
    int ret = 0;

    /* this is why num_trails < TDB_MAX)NUM_TRAILS < 2^59:
       (2^59 - 1) * 16 < LONG_MAX (off_t) */
    if (num_trails > TDB_MAX_NUM_TRAILS)
        return TDB_ERR_TOO_MANY_TRAILS;

    TDB_PATH(path, "%s/uuids", cons->root);
    TDB_OPEN(state.out, path, "w");
    TDB_TRUNCATE(state.out, ((off_t)(num_trails * 16)));

    j128m_fold(&cons->trails, store_uuids_fun, &state);
    ret = state.ret;

done:
    TDB_CLOSE_FINAL(state.out);
    return ret;
}

int is_fieldname_invalid(const char* field)
{
    uint64_t i;

    if (!strcmp(field, "time"))
        return 1;

    for (i = 0; i < TDB_MAX_FIELDNAME_LENGTH && field[i]; i++)
        if (!index(TDB_FIELDNAME_CHARS, field[i]))
            return 1;

    if (i == 0 || i == TDB_MAX_FIELDNAME_LENGTH)
        return 1;

    return 0;
}