Exemplo n.º 1
0
static bool test_zinterstore(acl::redis_zset& redis ,int n)
{
	acl::string dest_key, src1_key, src2_key;
	std::vector<acl::string> src_keys;

	for (int i = 0; i < n; i++)
	{
		dest_key.format("zset_dest_key_%d", i);
		src1_key.format("zset_src1_key_%d", i);
		src_keys.push_back(src1_key);
		src2_key.format("zset_src2_key_%d", i);
		src_keys.push_back(src2_key);

		redis.clear();
		int ret = redis.zinterstore(dest_key.c_str(), src_keys);
		if (ret < 0)
		{
			printf("zinterstore error, dest: %s\r\n",
				dest_key.c_str());
			return false;
		}
		src_keys.clear();
	}

	return true;
}
Exemplo n.º 2
0
static bool test_zincrby(acl::redis_zset& redis, int n)
{
	acl::string key;
	double inc = 2.5, result;
	acl::string member;

	for (int i = 0; i < n; i++)
	{
		key.format("%s_%d", __keypre.c_str(), i);

		for (int j = 0; j < 1000; j++)
		{
			member.format("member_%d", j);
			redis.clear();
			if (redis.zincrby(key.c_str(), inc, member.c_str(),
				&result) == false)
			{
				printf("zincrby error, key: %s\r\n", key.c_str());
				return false;
			}
			else if (j < 10 && i * j < 100)
				printf("zincrby ok key: %s, result: %.2f\r\n",
					key.c_str(), result);
		}
	}

	return true;
}
Exemplo n.º 3
0
static bool test_zrangebylex(acl::redis_zset& redis, int n)
{
	acl::string key;
	const char* min = "[aaa", *max = "(g";
	std::vector<acl::string> result;

	for (int i = 0; i < n; i++)
	{
		key.format("%s_%d", __keypre.c_str(), i);
		redis.clear();
		int ret = redis.zrangebylex(key.c_str(), min, max, &result);
		if (ret < 0)
		{
			printf("zrangebylex error(%s), key: %s\r\n",
				redis.result_error(), key.c_str());
			return false;
		}
		if (i >= 10)
		{
			result.clear();
			continue;
		}

		std::vector<acl::string>::const_iterator cit;
		for (cit = result.begin(); cit != result.end(); ++cit)
		{
			if (cit != result.begin())
				printf(", ");
			printf("%s", (*cit).c_str());
		}
		printf("\r\n");
	}

	return true;
}
Exemplo n.º 4
0
static bool test_zadd(acl::redis_zset& redis, int n)
{
	acl::string key;
	std::map<acl::string, double> members;
	acl::string member;

	for (int i = 0; i < n; i++)
	{
		key.format("%s_%d", __keypre.c_str(), i);

		for (int j = 0; j < 1000; j++)
		{
			member.format("member_%d", j);
			members[member] = j;
		}

		redis.clear();
		int ret = redis.zadd(key, members);
		if (ret < 0)
		{
			printf("add key: %s error\r\n", key.c_str());
			return false;
		}
		else if (i < 10)
			printf("add ok, key: %s, ret: %d\r\n",
				key.c_str(), ret);
		members.clear();
	}

	return true;
}
Exemplo n.º 5
0
static bool test_zscore(acl::redis_zset& redis, int n)
{
	acl::string key;
	acl::string member;
	bool ret;
	double result;

	for (int i = 0; i < n; i++)
	{
		key.format("%s_%d", __keypre.c_str(), i);

		for (int j = 0; j < 1000; j++)
		{
			member.format("member_%d", j);
			redis.clear();
			ret = redis.zscore(key.c_str(), member.c_str(),
				result);
			if (ret == false)
			{
				printf("zscore error, key: %s\r\n",
					key.c_str());
				return false;
			}
			else if (j > 0 && j * i < 100)
				printf("zscore ok, key: %s, member:%s, "
					"score: %.2f\r\n", key.c_str(),
					member.c_str(), result);
		}
	}

	return true;
}
Exemplo n.º 6
0
static bool test_zrem(acl::redis_zset& redis, int n)
{
	acl::string key;
	acl::string member;
	std::vector<acl::string> members;

	for (int i = 0; i < n; i++)
	{
		key.format("%s_%d", __keypre.c_str(), i);

		for (int j = 900; j < 1000; j++)
		{
			member.format("member_%d", j);
			members.push_back(member);
		}

		redis.clear();
		int ret = redis.zrem(key.c_str(), members);
		if (ret < 0)
		{
			printf("zrem error, key: %s\r\n", key.c_str());
			return false;
		}
		else if (i < 10)
			printf("zrem ok, key: %s, ret: %d\r\n",
				key.c_str(), ret);
	}

	return true;
}
Exemplo n.º 7
0
static bool test_zrank(acl::redis_zset& redis, int n)
{
	acl::string key;
	acl::string member;

	for (int i = 0; i < n; i++)
	{
		key.format("%s_%d", __keypre.c_str(), i);

		for (int j = 0; j < 1000; j++)
		{
			member.format("member_%d", j);
			redis.clear();
			int ret = redis.zrank(key.c_str(), member.c_str());
			if (ret < 0)
			{
				printf("zrank error, key: %s\r\n", key.c_str());
				return false;
			}
			else if (j > 0 && j * i < 100)
				printf("zrank ok, key: %s, member:%s, "
					"rank: %d\r\n", key.c_str(),
					member.c_str(), ret);
		}
	}

	return true;
}
Exemplo n.º 8
0
static bool test_zscan(acl::redis_zset& redis, int n)
{
	acl::string key;
	int   ret = 0;
	std::vector<std::pair<acl::string, double> > result;
	std::vector<std::pair<acl::string, double> >::const_iterator cit;

	for (int i = 0; i < n; i++)
	{
		key.format("%s_%d", __keypre.c_str(), i);
		while (true)
		{
			redis.clear();
			ret = redis.zscan(key.c_str(), ret, result);
			if (ret < 0)
			{
				printf("zscan failed, key: %s\r\n",
					key.c_str());
				return false;
			}
			
			if (i >= 10)
			{
				if (ret == 0)
					break;
			}

			for (cit = result.begin(); cit != result.end(); ++cit)
			{
				printf("%s: %.2f\r\n", cit->first.c_str(),
					cit->second);
			}

			if (ret == 0)
			{
				printf("zscan over, key: %s\r\n", key.c_str());
				break;
			}
		}
	}

	return true;
}
Exemplo n.º 9
0
static bool test_zcard(acl::redis_zset& redis, int n)
{
	acl::string key;

	for (int i = 0; i < n; i++)
	{
		key.format("%s_%d", __keypre.c_str(), i);
		redis.clear();
		int ret = redis.zcard(key.c_str());
		if (ret < 0)
		{
			printf("zcard key: %s error\r\n", key.c_str());
			return false;
		}
		else if (i < 10)
			printf("zcard ok, key: %s, count: %d\r\n",
				key.c_str(), ret);
	}

	return true;
}
Exemplo n.º 10
0
static bool test_zlexcount(acl::redis_zset& redis, int n)
{
	acl::string key;
	const char* min = "[aaa", *max = "(g";

	for (int i = 0; i < n; i++)
	{
		key.format("%s_%d", __keypre.c_str(), i);
		redis.clear();
		int ret = redis.zlexcount(key.c_str(), min, max);
		if (ret < 0)
		{
			printf("zlexcount error, key: %s\r\n", key.c_str());
			return false;
		}
		if (i >= 10)
			continue;
		printf("key: %s, count: %d\r\n", key.c_str(), ret);
	}

	return true;
}
Exemplo n.º 11
0
static bool test_zrangebyscore(acl::redis_zset& redis, int n)
{
	acl::string key;
	double min = 2, max = 10;

	printf("================test zrangebyscore=====================\r\n");
	std::vector<acl::string> result;

	for (int i = 0; i < n; i++)
	{
		key.format("%s_%d", __keypre.c_str(), i);
		redis.clear();
		result.clear();

		int ret = redis.zrangebyscore(key.c_str(), min, max, &result);
		if (ret < 0)
		{
			printf("zrangebyscore error, key: %s\r\n", key.c_str());
			return false;
		}
		else if (i >= 10)
		{
			result.clear();
			continue;
		}

		printf("zrangebyscore ok, key: %s, ret: %d\r\n",
			key.c_str(), ret);
		std::vector<acl::string>::const_iterator cit;
		for (cit = result.begin(); cit != result.end(); ++cit)
		{
			if (cit != result.begin())
				printf(", ");
			printf("%s", (*cit).c_str());
		}
		printf("\r\n");
		result.clear();
	}

	printf("===========test zrangebyscore_with_scores==============\r\n");
	std::vector<std::pair<acl::string, double> > result2;

	for (int i = 0; i < n; i++)
	{
		key.format("%s_%d", __keypre.c_str(), i);
		redis.clear();
		result.clear();

		int ret = redis.zrangebyscore_with_scores(key.c_str(),
			min, max, result2);
		if (ret < 0)
		{
			printf("zrangebyscore_with_scores error, key: %s\r\n",
				key.c_str());
			return false;
		}
		else if (i >= 10)
		{
			result2.clear();
			continue;
		}

		printf("zrangebyscore_with_scores ok, key: %s, ret: %d\r\n",
			key.c_str(), ret);
		std::vector<std::pair<acl::string, double> >::const_iterator cit;
		for (cit = result2.begin(); cit != result2.end(); ++cit)
		{
			if (cit != result2.begin())
				printf(", ");
			printf("%s: %.2f", cit->first.c_str(),
				cit->second);
		}
		printf("\r\n");
		result2.clear();
	}

	return true;
}