Ejemplo n.º 1
0
void test_zsets_zrev(Ardb& db)
{
    DBID dbid = 0;
    db.ZClear(dbid, "myzset");
    db.ZAdd(dbid, "myzset", ValueData((int64) 1), "one");
    db.ZAdd(dbid, "myzset", ValueData((int64) 2), "two");
    db.ZAdd(dbid, "myzset", ValueData((int64) 3), "three");
    ZSetQueryOptions options;
    options.withscores = true;
    ValueDataArray values;
    std::string str;
    db.ZRevRange(dbid, "myzset", 0, -1, values, options);
    CHECK_FATAL(values.size() != 6, "Fail:%zu", values.size());
    CHECK_FATAL(values[0].ToString(str) != "three", "Fail:%s", values[0].ToString(str).c_str());
    CHECK_FATAL(values[2].ToString(str) != "two", "Fail:%s", values[2].ToString(str).c_str());
    values.clear();
    db.ZRevRangeByScore(dbid, "myzset", "+inf", "-inf", values, options);
    CHECK_FATAL(values.size() != 6, "Fail:%zu", values.size());
    CHECK_FATAL(values[0].ToString(str) != "three", "Fail:%s", values[0].ToString(str).c_str());
    CHECK_FATAL(values[2].ToString(str) != "two", "Fail:%s", values[2].ToString(str).c_str());
    options.withscores = false;
    values.clear();
    db.ZRevRangeByScore(dbid, "myzset", "2", "1", values, options);
    CHECK_FATAL(values.size() != 2, "Fail:%zu", values.size());
    CHECK_FATAL(values[0].ToString(str) != "two", "Fail:%s", values[0].ToString(str).c_str());
    CHECK_FATAL(values[1].ToString(str) != "one", "Fail:%s", values[1].ToString(str).c_str());
    values.clear();
    db.ZRevRangeByScore(dbid, "myzset", "2", "(1", values, options);
    CHECK_FATAL(values.size() != 1, "Fail:%zu", values.size());
    CHECK_FATAL(values[0].ToString(str) != "two", "Fail:%s", values[0].ToString(str).c_str());
}
Ejemplo n.º 2
0
void test_sort_set(Ardb& db)
{
    DBID dbid = 0;
    db.SClear(dbid, "myset");
    db.SAdd(dbid, "myset", "ab3");
    db.SAdd(dbid, "myset", "ab2");
    db.SAdd(dbid, "myset", "ab1");
    db.SAdd(dbid, "myset", "ab4");

    StringArray args;
    ValueDataArray vs;
    db.Sort(dbid, "myset", args, vs);
    std::string str;
    CHECK_FATAL(vs.size() != 4, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "ab1", "sort result[0]:%s", str.c_str());
    CHECK_FATAL(vs[1].ToString(str) != "ab2", "sort result[1]:%s", str.c_str());
    CHECK_FATAL(vs[2].ToString(str) != "ab3", "sort result[2]:%s", str.c_str());
    CHECK_FATAL(vs[3].ToString(str) != "ab4", "sort result[3]:%s", str.c_str());

    vs.clear();
    string_to_string_array("limit 1 2", args);
    db.Sort(dbid, "myset", args, vs);
    CHECK_FATAL(vs.size() != 2, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "ab2", "sort result[0]:%s", str.c_str());
    CHECK_FATAL(vs[1].ToString(str) != "ab3", "sort result[1]:%s", str.c_str());

    vs.clear();
    args.clear();
    string_to_string_array("by weight_*", args);
    db.Set(dbid, "weight_ab1", "1000");
    db.Set(dbid, "weight_ab2", "900");
    db.Set(dbid, "weight_ab3", "800");
    db.Set(dbid, "weight_ab4", "700");
    db.Sort(dbid, "myset", args, vs);
    CHECK_FATAL(vs.size() != 4, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "ab4", "sort result[0]:%s", str.c_str());
    CHECK_FATAL(vs[1].ToString(str) != "ab3", "sort result[1]:%s", str.c_str());
    CHECK_FATAL(vs[2].ToString(str) != "ab2", "sort result[2]:%s", str.c_str());
    CHECK_FATAL(vs[3].ToString(str) != "ab1", "sort result[3]:%s", str.c_str());

    db.HSet(dbid, "myhash_ab1", "field", "hash100");
    db.HSet(dbid, "myhash_ab2", "field", "hash10");
    db.HSet(dbid, "myhash_ab3", "field", "hash9");
    db.HSet(dbid, "myhash_ab4", "field", "hash1000");
    args.clear();
    string_to_string_array("by weight_* get myhash_*->field get #", args);

    vs.clear();
    db.Sort(dbid, "myset", args, vs);
    CHECK_FATAL(vs.size() != 8, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "hash1000", "sort result[0]:%s", str.c_str());
    CHECK_FATAL(vs[2].ToString(str) != "hash9", "sort result[2]:%s", str.c_str());
    CHECK_FATAL(vs[4].ToString(str) != "hash10", "sort result[4]:%s", str.c_str());
    CHECK_FATAL(vs[6].ToString(str) != "hash100", "sort result[6]:%s", str.c_str());
    CHECK_FATAL(vs[1].ToString(str) != "ab4", "sort result[1]:%s", str.c_str());
    CHECK_FATAL(vs[3].ToString(str) != "ab3", "sort result[3]:%s", str.c_str());
    CHECK_FATAL(vs[5].ToString(str) != "ab2", "sort result[5]:%s", str.c_str());
    CHECK_FATAL(vs[7].ToString(str) != "ab1", "sort result[7]:%s", str.c_str());
}
Ejemplo n.º 3
0
void test_zsets_zrange(Ardb& db)
{
    DBID dbid = 0;
    db.ZClear(dbid, "myzset");
    db.ZAdd(dbid, "myzset", ValueData((int64) 1), "one");
    db.ZAdd(dbid, "myzset", ValueData((int64) 1), "uno");
    db.ZAdd(dbid, "myzset", ValueData((int64) 2), "two");
    db.ZAdd(dbid, "myzset", ValueData((int64) 3), "two");
    ZSetQueryOptions options;
    options.withscores = true;
    ValueDataArray values;
    db.ZRange(dbid, "myzset", 0, -1, values, options);
    std::string str;
    CHECK_FATAL(values.size() != 6, "Fail:%zu", values.size());
    CHECK_FATAL(values[0].ToString(str) != "one", "Fail:%s", values[0].ToString(str).c_str());
    CHECK_FATAL(values[2].ToString(str) != "uno", "Fail:%s", values[1].ToString(str).c_str());
    values.clear();
    db.ZRangeByScore(dbid, "myzset", "-inf", "+inf", values, options);
    CHECK_FATAL(values.size() != 6, "Fail:%zu", values.size());
    CHECK_FATAL(values[0].ToString(str) != "one", "Fail:%s", values[0].ToString(str).c_str());
    CHECK_FATAL(values[2].ToString(str) != "uno", "Fail:%s", values[1].ToString(str).c_str());
    values.clear();
    db.ZRangeByScore(dbid, "myzset", "(1", "3", values, options);
    CHECK_FATAL(values.size() != 2, "Fail:%zu", values.size());
    CHECK_FATAL(values[0].ToString(str) != "two", "Fail:%s", values[0].ToString(str).c_str());

    db.ZClear(dbid, "myzset");
    uint32 maxzsetsize = 1000;
    for (uint32 i = 0; i < maxzsetsize; i++)
    {
        char value[16];
        sprintf(value, "value%u", i);
        db.ZAdd(dbid, "myzset", ValueData((int64) i), value);
    }
    options.withscores = false;
    values.clear();
    db.ZRange(dbid, "myzset", 1, 10, values, options);
    CHECK_FATAL(values.size() != 10, "Fail:%zu", values.size());
}
Ejemplo n.º 4
0
void test_sort_list(Ardb& db)
{
    DBID dbid = 0;
    db.LClear(dbid, "mylist");
    db.RPush(dbid, "mylist", "100");
    db.RPush(dbid, "mylist", "10");
    db.RPush(dbid, "mylist", "9");
    db.RPush(dbid, "mylist", "1000");

    StringArray args;
    ValueDataArray vs;
    db.Sort(dbid, "mylist", args, vs);
    CHECK_FATAL(vs.size() != 4, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].integer_value != 9, "sort result[0]:%"PRId64, vs[0].integer_value);
    CHECK_FATAL(vs[1].integer_value != 10, "sort result[0]:%"PRId64, vs[1].integer_value);
    CHECK_FATAL(vs[2].integer_value != 100, "sort result[0]:%"PRId64, vs[2].integer_value);
    CHECK_FATAL(vs[3].integer_value != 1000, "sort result[0]:%"PRId64, vs[3].integer_value);

    vs.clear();

    args.clear();
    string_to_string_array("limit 1 2", args);
    db.Sort(dbid, "mylist", args, vs);
    CHECK_FATAL(vs.size() != 2, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].integer_value != 10, "sort result[0]:%"PRId64, vs[0].integer_value);
    CHECK_FATAL(vs[1].integer_value != 100, "sort result[0]:%"PRId64, vs[1].integer_value);

    vs.clear();
    args.clear();
    string_to_string_array("by weight_*", args);
    db.Set(dbid, "weight_100", "1000");
    db.Set(dbid, "weight_10", "900");
    db.Set(dbid, "weight_9", "800");
    db.Set(dbid, "weight_1000", "700");
    db.Sort(dbid, "mylist", args, vs);
    CHECK_FATAL(vs.size() != 4, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].integer_value != 1000, "sort result[0]:%"PRId64, vs[0].integer_value);
    CHECK_FATAL(vs[1].integer_value != 9, "sort result[0]:%"PRId64, vs[1].integer_value);
    CHECK_FATAL(vs[2].integer_value != 10, "sort result[0]:%"PRId64, vs[2].integer_value);
    CHECK_FATAL(vs[3].integer_value != 100, "sort result[0]:%"PRId64, vs[3].integer_value);

    db.HSet(dbid, "myhash", "field_100", "hash100");
    db.HSet(dbid, "myhash", "field_10", "hash10");
    db.HSet(dbid, "myhash", "field_9", "hash9");
    db.HSet(dbid, "myhash", "field_1000", "hash1000");

    args.clear();
    string_to_string_array("by weight_* get myhash->field_* get #", args);
    vs.clear();
    db.Sort(dbid, "mylist", args, vs);
    std::string str;
    CHECK_FATAL(vs.size() != 8, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "hash1000", "sort result[0]:%s", str.c_str());
    CHECK_FATAL(vs[2].ToString(str) != "hash9", "sort result[2]:%s", str.c_str());
    CHECK_FATAL(vs[4].ToString(str) != "hash10", "sort result[4]:%s", str.c_str());
    CHECK_FATAL(vs[6].ToString(str) != "hash100", "sort result[6]:%s", str.c_str());
    CHECK_FATAL(vs[1].integer_value != 1000, "sort result[1]:%"PRId64, vs[1].integer_value);
    CHECK_FATAL(vs[3].integer_value != 9, "sort result[3]:%"PRId64, vs[3].integer_value);
    CHECK_FATAL(vs[5].integer_value != 10, "sort result[5]:%"PRId64, vs[5].integer_value);
    CHECK_FATAL(vs[7].integer_value != 100, "sort result[7]:%"PRId64, vs[7].integer_value);
}
Ejemplo n.º 5
0
void test_sort_zset(Ardb& db)
{
    DBID dbid = 0;
    db.ZClear(dbid, "myzset");
    db.ZAdd(dbid, "myzset", ValueData((int64) 0), "v0");
    db.ZAdd(dbid, "myzset", ValueData((int64) 10), "v10");
    db.ZAdd(dbid, "myzset", ValueData((int64) 3), "v3");
    db.ZAdd(dbid, "myzset", ValueData((int64) 5), "v5");

    StringArray args;
    ValueDataArray vs;
    db.Sort(dbid, "myzset", args, vs);
    std::string str;
    CHECK_FATAL(vs.size() != 4, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "v0", "sort result[0]:%s", str.c_str());
    CHECK_FATAL(vs[1].ToString(str) != "v3", "sort result[1]:%s", str.c_str());
    CHECK_FATAL(vs[2].ToString(str) != "v5", "sort result[2]:%s", str.c_str());
    CHECK_FATAL(vs[3].ToString(str) != "v10", "sort result[3]:%s", str.c_str());

    vs.clear();
    string_to_string_array("limit 1 2", args);
    db.Sort(dbid, "myzset", args, vs);
    CHECK_FATAL(vs.size() != 2, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "v3", "sort result[0]:%s", str.c_str());
    CHECK_FATAL(vs[1].ToString(str) != "v5", "sort result[1]:%s", str.c_str());

    vs.clear();
    args.clear();
    string_to_string_array("by weight_*", args);
    db.Set(dbid, "weight_v0", "1000");
    db.Set(dbid, "weight_v3", "900");
    db.Set(dbid, "weight_v5", "800");
    db.Set(dbid, "weight_v10", "700");
    db.Sort(dbid, "myzset", args, vs);
    CHECK_FATAL(vs.size() != 4, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "v10", "sort result[0]:%s", str.c_str());
    CHECK_FATAL(vs[1].ToString(str) != "v5", "sort result[1]:%s", str.c_str());
    CHECK_FATAL(vs[2].ToString(str) != "v3", "sort result[2]:%s", str.c_str());
    CHECK_FATAL(vs[3].ToString(str) != "v0", "sort result[3]:%s", str.c_str());

    db.HSet(dbid, "myhash_v0", "field", "100");
    db.HSet(dbid, "myhash_v3", "field", "10");
    db.HSet(dbid, "myhash_v5", "field", "9");
    db.HSet(dbid, "myhash_v10", "field", "1000");

    string_to_string_array("by weight_* get myhash_*->field aggregate sum", args);
    db.Sort(dbid, "myzset", args, vs);
    CHECK_FATAL(vs.size() != 1, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "1119", "sort result[0]:%s", str.c_str());

    string_to_string_array("by weight_* get myhash_*->field aggregate min", args);
    db.Sort(dbid, "myzset", args, vs);
    CHECK_FATAL(vs.size() != 1, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "9", "sort result[0]:%s", str.c_str());

    string_to_string_array("by weight_* get myhash_*->field aggregate max", args);
    db.Sort(dbid, "myzset", args, vs);
    CHECK_FATAL(vs.size() != 1, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "1000", "sort result[0]:%s", str.c_str());

    string_to_string_array("by weight_* get myhash_*->field aggregate avg", args);
    db.Sort(dbid, "myzset", args, vs);
    CHECK_FATAL(vs.size() != 1, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "279.75", "sort result[0]:%s", str.c_str());

    string_to_string_array("by weight_* get myhash_*->field aggregate count", args);
    db.Sort(dbid, "myzset", args, vs);
    CHECK_FATAL(vs.size() != 1, "sort result size error:%zu", vs.size());
    CHECK_FATAL(vs[0].ToString(str) != "4", "sort result[0]:%s", str.c_str());
}