非关系型数据库c接口相关函数

最新推荐文章于 2024-05-04 10:21:28 发布
最新推荐文章于 2024-05-04 10:21:28 发布
阅读量159 收藏
点赞数
文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42190747/article/details/81218156
版权

/**
* @file redis_op.c
* @brief redis 操作基本接口和key的操作实现
*/

include “redis_op.h”

/* ——————————————-*/
/**
* @brief 选择redis一个数据库
*
* @param conn 已链接的数据库链接
* @param db_no redis数据库编号
*
* @returns
* -1 失败
* 0 成功
*/
/* ——————————————-*/
int rop_selectdata

igned int db_no)
{
int retn = 0;
redisReply *reply = NULL;

/* 选择一个数据库 */
reply = redisCommand(conn, "select %d", db_no);
if (reply == NULL) {
    fprintf(stderr, "[-][GMS_REDIS]Select database %d error!\n", db_no);
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Select database %d error!%s\n", db_no, conn->errstr);
    retn = -1;
    goto END;
}

printf("[+][GMS_REDIS]Select database %d SUCCESS!\n", db_no);
LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[+][GMS_REDIS]Select database %d SUCCESS!\n", db_no);

END:
freeReplyObject(reply);
return retn;
}

/* ——————————————-*/
/**
* @brief 清空当前数据库所有信息(慎用)
*
* @param conn 已链接的数据库链接
*
* @returns
* -1 失败
* 0 成功
*/
/* ——————————————-*/
int rop_flush_database(redisContext *conn)
{
int retn = 0;
redisReply *reply = NULL;

reply = redisCommand(conn, "FLUSHDB");
if (reply == NULL) {
    fprintf(stderr, "[-][GMS_REDIS]Clear all data error\n");
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Clear all data error\n");
    retn = -1;
    goto END;
}

printf("[+][GMS_REDIS]Clear all data!!\n");
LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC,"[+][GMS_REDIS]Clear all data!!\n");

END:
freeReplyObject(reply);
return retn;
}

/* ——————————————-*/
/**
* @brief 判断key值是否存在
*
* @param conn 已经建立的链接
* @param key 需要寻找的key值
*
* @returns
* -1 失败
* 1 存在
* 0 不存在
*/
/* ——————————————-*/
int rop_is_key_exist(redisContext conn, char key)
{
int retn = 0; 

redisReply *reply = NULL;

reply = redisCommand(conn, "EXISTS %s", key);
//rop_test_reply_type(reply);
if (reply->type != REDIS_REPLY_INTEGER) {
    fprintf(stderr, "[-][GMS_REDIS]is key exist get wrong type!\n");
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]is key exist get wrong type! %s\n", conn->errstr);
    retn = -1;
    goto END;
}

if (reply->integer == 1) {
    retn = 1;   
}
else {
    retn = 0;
}

END:
freeReplyObject(reply);
return retn;
}

/* ——————————————-*/
/**
* @brief 删除一个key
*
* @param conn 已经建立的链接
* @param key
*
* @returns
* -1 失败
* 0 成功
*/
/* ——————————————-*/
int rop_del_key(redisContext *conn, char *key)
{
int retn = 0;
redisReply *reply = NULL;

reply = redisCommand(conn, "DEL %s", key);
if (reply->type != REDIS_REPLY_INTEGER) {
    fprintf(stderr, "[-][GMS_REDIS] DEL key %s ERROR\n", key);
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS] DEL key %s ERROR %s\n", key, conn->errstr);
    retn = -1;
    goto END;
}

if (reply->integer > 0) {
    retn = 0;   
}
else {
    retn = -1;
}

END:
freeReplyObject(reply);
return retn;
}

/* ——————————————-*/
/**
* @brief 设置一个key的删除时间 ，系统到达一定时间
* 将会自动删除该KEY
*
* @param conn 已经建立好的链接
* @param delete_time 到期事件 time_t 日历时间
*
* @returns
* 0 SUCC
* -1 FAIL
*/
/* ——————————————-*/
int rop_set_key_lifecycle(redisContext *conn, char *key, time_t delete_time)
{
int retn = 0;
redisReply *reply = NULL; 

reply = redisCommand(conn, "EXPIREAT %s %d", key, delete_time);
if (reply->type != REDIS_REPLY_INTEGER) {
    fprintf(stderr, "[-][GMS_REDIS]Set key:%s delete time ERROR!\n", key);
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Set key:%s delete time ERROR! %s\n", key, conn->errstr);
    retn = -1;
}
if (reply->integer == 1) {
    /* 成功 */
    retn = 0;
}
else {
    /* 错误 */
    retn = -1;
}


freeReplyObject(reply); 
return retn;

}

/* ——————————————-*/
/**
* @brief 打印库中所有匹配pattern的key
*
* @param conn 已建立好的链接
* @param pattern 匹配模式，pattern支持glob-style的通配符格式，
* 如 *表示任意一个或多个字符，
* ?表示任意字符，
* [abc]表示方括号中任意一个字母。
*/
/* ——————————————-*/
void rop_show_keys(redisContext conn, char pattern)
{
int i = 0;
redisReply *reply = NULL;

reply = redisCommand(conn, "keys %s", pattern);
if (reply->type != REDIS_REPLY_ARRAY) {
    fprintf(stderr, "[-][GMS_REDIS]show all keys and data wrong type!\n");
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]show all keys and data wrong type! %s\n", conn->errstr);
    goto END;
}

for (i = 0; i < reply->elements; ++i) {
    printf("======[%s]======\n", reply->element[i]->str);
}

END:
freeReplyObject(reply);
}

/* ——————————————-*/
/**
* @brief 批量执行已经封装好的redis 命令
*
* @param conn 已建立好的链接
* @param cmds 封装好的命令数组
* @param cmd_num 命令个数
*
* @returns
* 0 succ
* -1 FAIL
*/
/* ——————————————-*/
int rop_redis_append(redisContext *conn, RCOMMANDS cmds, int cmd_num)
{
int retn = 0;
int i = 0;
redisReply *reply = NULL;

/* 批量插入命令到缓冲命令管道 */
for (i = 0; i < cmd_num; ++i) {
    retn = redisAppendCommand(conn, cmds[i]);
    if (retn != REDIS_OK) {
        fprintf(stderr, "[-][GMS_REDIS]Append Command: %s ERROR!\n", cmds[i]);
        LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Append Command: %s ERROR! %s\n", cmds[i], conn->errstr);
        retn = -1;
        goto END;
    }
    retn = 0;
}

/* 提交命令 */
for (i = 0; i < cmd_num; ++i) {
    retn = redisGetReply(conn, (void**)&reply);
    if (retn != REDIS_OK) {
        retn = -1;
        fprintf(stderr, "[-][GMS_REDIS]Commit Command:%s ERROR!\n", cmds[i]);
        LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Commit Command:%s ERROR! %s\n", cmds[i], conn->errstr);
        freeReplyObject(reply);
        break;
    }
    freeReplyObject(reply);
    retn = 0;
}

END:
return retn;
}

/* ——————————————-*/
/**
* @brief 执行单向命令 无返回值 命令自行输入
*
* @param conn 已建立的链接
* @param cmd 封装好的命令
*
* @returns
* 0 succ
* -1 FAIL
*/
/* ——————————————-*/
int rop_redis_command(redisContext *conn, char *cmd)
{
int retn = 0;

redisReply *reply = NULL;

reply = redisCommand(conn, cmd);
if (reply == NULL) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Command : %s ERROR!%s\n", cmd, conn->errstr);
    retn = -1;
}

freeReplyObject(reply);

return retn;

}

/* ——————————————-*/
/**
* @brief 测试一个reply的结果类型
* 得到对应的类型用对应的方法获取数据
*
* @param reply 返回的命令结果
*/
/* ——————————————-*/
void rop_test_reply_type(redisReply *reply)
{
switch (reply->type) {
case REDIS_REPLY_STATUS:
LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, “[+][GMS_REDIS]=REDIS_REPLY_STATUS=[string] use reply->str to get data, reply->len get data len\n”);
break;
case REDIS_REPLY_ERROR:
LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, “[+][GMS_REDIS]=REDIS_REPLY_ERROR=[string] use reply->str to get data, reply->len get date len\n”);
break;
case REDIS_REPLY_INTEGER:
LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, “[+][GMS_REDIS]=REDIS_REPLY_INTEGER=[long long] use reply->integer to get data\n”);
break;
case REDIS_REPLY_NIL:
LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, “[+][GMS_REDIS]=REDIS_REPLY_NIL=[] data not exist\n”);
break;
case REDIS_REPLY_ARRAY:
LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, “[+][GMS_REDIS]=REDIS_REPLY_ARRAY=[array] use reply->elements to get number of data, reply->element[index] to get (struct redisReply*) Object\n”);
break;
case REDIS_REPLY_STRING:
LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, “[+][GMS_REDIS]=REDIS_REPLY_string=[string] use reply->str to get data, reply->len get data len\n”);
break;
default:
LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, “[-][GMS_REDIS]Can’t parse this type\n”);
break;
}
}

/* ——————————————-*/
/**
* @brief redis tcp模式链接
*
* @param ip_str redis服务器ip
* @param port_str redis服务器port
*
* @returns
* 成功返回链接句柄
* 失败返回NULL
*/
/* ——————————————-*/
redisContext* rop_connectdb_nopwd(char ip_str, char port_str)
{
redisContext *conn = NULL;
uint16_t port = atoi(port_str);

conn = redisConnect(ip_str, port);

if (conn  == NULL) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Connect %s:%d Error:Can't allocate redis context!\n", ip_str, port);       
    goto END;
}

if (conn->err) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Connect %s:%d Error:%s\n", ip_str, port, conn->errstr);    
    redisFree(conn);
    conn = NULL;
    goto END;
}

LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC,"[+][GMS_REDIS]Connect %s:%d SUCCESS!\n", ip_str, port);

END:
return conn;
}

/* ——————————————-*/
/**
* @brief redis tcp模式链接
*
* @param ip_str redis服务器ip
* @param port_str redis服务器port
*
* @returns
* 成功返回链接句柄
* 失败返回NULL
*/
/* ——————————————-*/
redisContext* rop_connectdb(char ip_str, char port_str, char *pwd)
{
redisContext *conn = NULL;
uint16_t port = atoi(port_str);
char auth_cmd[REDIS_COMMAND_SIZE];

conn = redisConnect(ip_str, port);

if (conn  == NULL) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Connect %s:%d Error:Can't allocate redis context!\n", ip_str, port);       
    goto END;
}

if (conn->err) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Connect %s:%d Error:%s\n", ip_str, port, conn->errstr);    
    redisFree(conn);
    conn = NULL;
    goto END;
}

redisReply *reply = NULL;
sprintf(auth_cmd, "auth %s", pwd);

reply = redisCommand(conn, auth_cmd);
if (reply == NULL) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Command : auth %s ERROR!\n", pwd);
    conn = NULL;
    goto END;
}
freeReplyObject(reply);


LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC,"[+][GMS_REDIS]Connect %s:%d SUCCESS!\n", ip_str, port);

END:
return conn;
}

/* ——————————————-*
**
* @brief redis unix域模式链接
*
* @param ip_str unix域sock文件
*
* @returns
* 成功返回链接句柄
* 失败返回NULL
*/
/* ——————————————-*/
redisContext* rop_connectdb_unix(char *sock_path, char *pwd)
{
redisContext *conn = NULL;
char auth_cmd[REDIS_COMMAND_SIZE];

conn = redisConnectUnix(sock_path);
if (conn  == NULL) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Connect domain-unix:%s Error:Can't allocate redis context!\n", sock_path);     
    goto END;
}

if (conn->err) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Connect domain-unix:%s Error:%s\n", sock_path, conn->errstr);  
    redisFree(conn);
    conn = NULL;
    goto END;
}

redisReply *reply = NULL;
sprintf(auth_cmd, "auth %s", pwd);
reply = redisCommand(conn, auth_cmd);
if (reply == NULL) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Command : auth %s ERROR!\n", pwd);
    conn = NULL;
    goto END;
}
freeReplyObject(reply);

LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC,"[+][GMS_REDIS]Connect domain-unix:%s SUCCESS!\n", sock_path);

END:
return conn;
}

/* ——————————————-*/
/**
* @brief tcp 链接redis超时等待模式，timeval链接超时
* 返回
*
* @param ip_str redis 服务器ip
* @param port_str redis 服务器端口
* @param timeval 最大超时等待时间
*
* @returns
* 成功返回链接句柄
* 失败返回NULL
*/
/* ——————————————-*/
redisContext* rop_connectdb_timeout(char* ip_str, char *port_str, struct timeval *timeout)
{
redisContext *conn = NULL;
uint16_t port = atoi(port_str);

conn = redisConnectWithTimeout(ip_str, port, *timeout);

if (conn  == NULL) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Connect %s:%d Error:Can't allocate redis context!\n", ip_str, port);
    goto END;
}

if (conn->err) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Connect %s:%d Error:%s\n", ip_str, port, conn->errstr);    
    redisFree(conn);
    conn = NULL;
    goto END;
}

LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC,"[+][GMS_REDIS]Connect %s:%d SUCCESS!\n", ip_str, port);

END:
return conn;
}

/* ——————————————-*/
/**
* @brief 关闭指定的链接句柄
*
* @param conn 已建立好的链接
*/
/* ——————————————-*/
void rop_disconnect(redisContext* conn)
{
if (conn == NULL) {
return ;
}
redisFree(conn);

LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC,"[+][GMS_REDIS]Disconnect SUCCESS!\n");

}

/* 封装一个 hmset 命令 */
static char* make_hmset_command(char* key, unsigned int element_num, RFIELDS fields, RVALUES values)
{
char *cmd = NULL;
unsigned int buf_size = 0;
unsigned int use_size = 0;
unsigned int i = 0;

cmd = (char*)malloc(1024*1024);
if (cmd == NULL) {
    goto END;
}
memset(cmd, 0, 1024*1024);
buf_size += 1024*1024;

strncat(cmd, "hmset", 6);
use_size += 5;
strncat(cmd, " ", 1);
use_size += 1;

strncat(cmd, key, 200);
use_size += 200;

for (i = 0; i < element_num; ++i) {

    strncat(cmd, " ", 1);
    use_size += 1;
    if (use_size >= buf_size) {
        cmd = realloc(cmd, use_size + 1024*1024);
        if (cmd == NULL) {
            goto END;
        }
        buf_size += 1024*1024;
    }

    strncat(cmd, fields[i], FIELD_ID_SIZE);
    use_size += strlen(fields[i]);
    if (use_size >= buf_size) {
        cmd = realloc(cmd, use_size + 1024*1024);
        if (cmd == NULL) {
            goto END;
        }
        buf_size += 1024*1024;
    }


    strncat(cmd, " ", 1);
    use_size += 1;
    if (use_size >= buf_size) {
        cmd = realloc(cmd, use_size + 1024*1024);
        if (cmd == NULL) {
            goto END;
        }
        buf_size += 1024*1024;
    }

    strncat(cmd, values[i], VALUES_ID_SIZE);
    use_size += strlen(values[i]);
    if (use_size >= buf_size) {
        cmd = realloc(cmd, use_size + 1024*1024);
        if (cmd == NULL) {
            goto END;
        }
        buf_size += 1024*1024;
    }

}

END:
return cmd;
}

/* ——————————————-*/
/**
* @brief 批量执行链表插入命令 插入链表头部
*
* @param conn 已建立好的链接
* @param key 链表名
* @param values 封装好的值数组
* @param val_num 值个数
*
* @returns
* 0 succ
* -1 FAIL
*/
/* ——————————————-*/
int rop_hash_set_append(redisContext *conn, char *key, RFIELDS fields, RVALUES values, int val_num)
{
int retn = 0;
int i = 0;
redisReply *reply = NULL;

/* 批量插入命令到缓冲命令管道 */
for (i = 0; i < val_num; ++i) {
    retn = redisAppendCommand(conn, "hset %s %s %s", key, fields[i], values[i]);
    if (retn != REDIS_OK) {
        LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]HSET %s %s %s ERROR![%s]\n", key, fields[i], values[i], conn->errstr);
        retn = -1;
        goto END;
    }
    retn = 0;
}

/* 提交命令 */
for (i = 0; i < val_num; ++i) {
    retn = redisGetReply(conn, (void**)&reply);
    if (retn != REDIS_OK) {
        retn = -1;
        LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Commit HSET %s %s %s ERROR![%s]\n", key, fields[i], values[i], conn->errstr);
        freeReplyObject(reply);
        break;
    }
    freeReplyObject(reply);
    retn = 0;
}

END:
return retn;
}

/* ——————————————-*/
/**
* @brief 想一个hash表中添加一条 key-value 数据
*
* @param conn redis连接
* @param key 哈希表名
* @param field
* @param value
*
* @returns
* 0 succ
* -1 FAIL
*/
/* ——————————————-*/
int rop_hash_set(redisContext *conn, char *key, char *field, char *value)
{
int retn = 0;
redisReply *reply = NULL;

reply =  redisCommand(conn, "hset %s %s %s", key, field, value);
if (reply == NULL || reply->type != REDIS_REPLY_INTEGER) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]hset %s %s %s error %s\n", key, field, value,conn->errstr);
    retn =  -1;
    goto END;
}

END:
freeReplyObject(reply);

return retn;

}

/* ——————————————-*/
/**
* @brief 从一个hash表中取出一条 key-value 数据
*
* @param conn redis连接
* @param key 哈希表名
* @param field 字段名称
* @param value 得到的数据， 需要先开辟内存
*
* @returns
* 0 succ
* -1 FAIL
*/
/* ——————————————-*/
int rop_hash_get(redisContext *conn, char *key, char *field, char *value)
{
int retn = 0;
int len = 0;

redisReply *reply = NULL;

reply =  redisCommand(conn, "hget %s %s", key, field);
if (reply == NULL || reply->type != REDIS_REPLY_STRING) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]hget %s %s  error %s\n", key, field, conn->errstr);
    retn =  -1;
    goto END;
}


len = reply->len > VALUES_ID_SIZE? VALUES_ID_SIZE:reply->len ;

strncpy(value, reply->str, len);

value[len] = '\0';

END:
freeReplyObject(reply);

return retn;

}

/* ——————————————-*/
/**
* @brief 创建或者覆盖一个HASH表
*
* @param conn 已建立好的链接
* @param key hash 表名
* @param element_num hash 表区域个数
* @param fields hash 表区域名称数组char(*)[FIELD_ID_SIZE]
* @param values hash 表区域值数组 char(*)[VALUES_ID_SIZE]
*
* @returns
* 0 成功
* -1 失败
*/
/* ——————————————-*/
int rop_create_or_replace_hash_table(redisContext* conn,
char* key,
unsigned int element_num,
RFIELDS fields,
RVALUES values)
{
int retn = 0;
redisReply *reply = NULL; 

char *cmd = make_hmset_command(key, element_num, fields, values);       
if (cmd == NULL) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]create hash table %s error\n", key);
    retn = -1;
    goto END_WITHOUT_FREE;
}

reply = redisCommand(conn, cmd);

// rop_test_reply_type(reply);
if (strcmp(reply->str, “OK”) != 0) {
LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, “[-][GMS_REDIS]Create hash table %s Error:%s,%s\n”, key, reply->str, conn->errstr);

    retn = -1;
    goto END;
}

END:
free(cmd);
freeReplyObject(reply);

END_WITHOUT_FREE:

return retn;

}

/* ——————————————-*/
/**
* @brief 给指定的hash表 指定的field对应的value自增num
*
* @param conn 已建立好的链接
* @param key hash表名
* @param field hash表下的区域名
*
* @returns
* 0 succ
* -1 fail
*/
/* ——————————————-*/
int rop_hincrement_one_field(redisContext *conn, char *key, char *field, unsigned int num)
{
int retn = 0;

redisReply *reply = NULL;

reply = redisCommand(conn, "HINCRBY %s %s %d", key, field, num);
if (reply == NULL) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]increment %s %s error %s\n", key, field, conn->errstr);    
    retn =  -1;
    goto END;
}

END:
freeReplyObject(reply);

return retn;

}

/* ——————————————-*/
/**
* @brief 批量执行链表插入命令 插入链表头部
*
* @param conn 已建立好的链接
* @param key 链表名
* @param values 封装好的值数组
* @param val_num 值个数
*
* @returns
* 0 succ
* -1 FAIL
*/
/* ——————————————-*/
int rop_list_push_append(redisContext *conn, char *key, RVALUES values, int val_num)
{
int retn = 0;
int i = 0;
redisReply *reply = NULL;

/* 批量插入命令到缓冲命令管道 */
for (i = 0; i < val_num; ++i) {
    retn = redisAppendCommand(conn, "lpush %s %s", key, values[i]);
    if (retn != REDIS_OK) {
        LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]PLUSH %s %s ERROR! %s\n", key, values[i], conn->errstr);
        retn = -1;
        goto END;
    }
    retn = 0;
}

/* 提交命令 */
for (i = 0; i < val_num; ++i) {
    retn = redisGetReply(conn, (void**)&reply);
    if (retn != REDIS_OK) {
        retn = -1;
        LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Commit LPUSH %s %s ERROR! %s\n", key, values[i], conn->errstr);
        freeReplyObject(reply);
        break;
    }
    freeReplyObject(reply);
    retn = 0;
}

END:
return retn;
}

/* ——————————————-*/
/**
* @brief 单条数据插入链表
*
* @param conn 已建立好的链接
* @param key 链表名
* @param value 数据
*
* @returns
*/
/* ——————————————-*/
int rop_list_push(redisContext *conn, char *key, char *value)
{
int retn = 0;
redisReply *reply = NULL;

reply = redisCommand(conn, "LPUSH %s %s", key, value);
//rop_test_reply_type(reply);   
if (reply->type != REDIS_REPLY_INTEGER) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]LPUSH %s %s error!%s\n", key, value, conn->errstr);
    retn = -1;
}

freeReplyObject(reply);
return retn;

}

/* ——————————————-*/
/**
* @brief 得到链表中元素的个数
*
* @param conn 链接句柄
* @param key 链表名
*
* @returns
* >=0 个数
* -1 fail
*/
/* ——————————————-*/
int rop_get_list_cnt(redisContext *conn, char *key)
{
int cnt = 0;

redisReply *reply = NULL;

reply = redisCommand(conn, "LLEN %s", key);
if (reply->type != REDIS_REPLY_INTEGER) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]LLEN %s error %s\n", key, conn->errstr);
    cnt = -1;
    goto END;
}

cnt = reply->integer;

END:
freeReplyObject(reply);
return cnt;
}

/* ——————————————-*/
/**
* @brief 按照一定范围截断链表中的数据
*
* @param conn 已经建立的链接
* @param key 链表名
* @param begin 阶段启示位置 从 0 开始
* @param end 阶段结束位置 从 -1 开始
*
* 这里的范围定义举例
* 如果得到全部范围(0, -1)
* 除了最后一个元素范围(0, -2)
* 前20各数据范围(0, 19)
*
* @returns
* 0 SUCC
* -1 FAIL
*/
/* ——————————————-*/
int rop_trim_list(redisContext *conn, char *key, int begin, int end)
{
int retn = 0;
redisReply *reply = NULL;

reply = redisCommand(conn, "LTRIM %s %d %d", key, begin, end);
if (reply->type != REDIS_REPLY_STATUS) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]LTRIM %s %d %d error!%s\n", key, begin, end, conn->errstr);
    retn = -1;
}

freeReplyObject(reply);
return retn;

}

/* ——————————————-*/
/**
* @brief rop_range_list 得到链表中的数据
*
* 返回数据为 区间为
* [from_pos, end_pos)
*
* @param conn
* @param key 表名
* @param from_pos 查找表的起始数据下标
* @param end_pos 查找表的结尾数据下标
* @param values 得到表中的value数据
* @param get_num 得到结果value的个数
*
* @returns
* 0 succ, -1 fail
*/
/* ——————————————-*/
int rop_range_list(redisContext *conn, char *key, int from_pos, int end_pos, RVALUES values, int *get_num)
{
int retn = 0;
int i = 0;
redisReply *reply = NULL;
int max_count = 0;

int count = end_pos - from_pos + 1;

reply = redisCommand(conn, "LRANGE %s %d %d", key, from_pos, end_pos);
if (reply->type != REDIS_REPLY_ARRAY || reply->elements == 0) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]LRANGE %s  error!%s\n", key, conn->errstr);
    retn = -1;
    goto END;
}


max_count = (reply->elements > count) ? count: reply->elements;
*get_num = max_count;


for (i = 0; i < max_count; ++i) {
    strncpy(values[i], reply->element[i]->str, VALUES_ID_SIZE-1);
}

END:
if(reply != NULL)
{
freeReplyObject(reply);
}

return retn;

}

/* ——————————————-*/
/**
* @brief 将指定的zset表，对应的成员，值自增1
* （key 或 成员不存在 则创建）
*
* @param conn 已建立的链接
* @param key zset表名
* @param member zset成员名
*
* @returns
* 0 succ
* -1 fail
*/
/* ——————————————-*/
int rop_zset_increment(redisContext conn, char key, char* member)
{
int retn = 0; 

redisReply *reply = NULL;

reply = redisCommand(conn, "ZINCRBY %s 1 %s", key, member);
//rop_test_reply_type(reply);
if (strcmp(reply->str, "OK") != 0) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Add or increment table: %s,member: %s Error:%s,%s\n", key, member,reply->str, conn->errstr);

    retn = -1;
    goto END;
}

END:
freeReplyObject(reply);
return retn;
}

/* ——————————————-*/
/**
* @brief 批量将指定的zset表，对应的成员，值自增1
* （key 或 成员不存在 则创建）
*
* @param conn 已建立好的链接
* @param key 有序集合名称
* @param values 封装好的成员数组
* @param val_num 数据个数
*
* @returns
* 0 succ
* -1 FAIL
*/
/* ——————————————-*/
int rop_zset_increment_append(redisContext *conn, char *key, RVALUES values, int val_num)
{
int retn = 0;
int i = 0;
redisReply *reply = NULL;

/* 批量命令到缓冲管道 */
for (i = 0; i < val_num; ++i) {
    retn = redisAppendCommand(conn, "ZINCRBY %s 1 %s", key, values[i]);
    if (retn != REDIS_OK) {
        LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]ZINCRBY %s 1 %s ERROR! %s\n", key, values[i], conn->errstr);
        retn = -1;
        goto END;
    }
    retn = 0;
}

/* 提交命令 */
for (i = 0; i < val_num; ++i) {
    retn = redisGetReply(conn, (void**)&reply);
    if (retn != REDIS_OK) {
        retn = -1;
        LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]Commit ZINCRBY %s 1 %s ERROR!%s\n", key, values[i], conn->errstr);
        freeReplyObject(reply);
        break;
    }
    freeReplyObject(reply);
    retn = 0;
}

END:
return retn;
}

int rop_zset_get_score(redisContext *conn, char *key, char *member)
{
int score = 0;

redisReply *reply = NULL;

reply = redisCommand(conn, "ZSCORE %s %s", key, member);
rop_test_reply_type(reply);

if (reply->type != REDIS_REPLY_STRING) {
    LOG(REDIS_LOG_MODULE, REDIS_LOG_PROC, "[-][GMS_REDIS]ZSCORE %s %s error %s\n", key, member,conn->errstr);
    score = -1;
    goto END;
}

score = atoi(reply->str);

END:
freeReplyObject(reply);

return score;

}

weixin_42190747
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
postgresql:PostgreSQL-对象关系数据库系统
04-07
PostgreSQL-高级对象关系数据库系统是一个功能齐全的对象关系数据库，具有许多企业功能：ACID事务，继承，Unicode和对SQL-92标准的强大支持，包括子查询，视图，外部联接，外键，序列和触发器。 它也是高度可扩展的...
Redis HASH 操作类型封装
忘世麒麟的专栏
08-28 2859
如下是我项目中用到的,redis操作hash表时的类,自我封装了所有对hash的操作.经过测试通过 头文件 #pragma once class redisOperator { private: //一个操作redis数据库的句柄 redisContext *c; public: redisOperator(void); //HDELL 删除key中的一个或者多个域,成功
NoSQL（非关系型数据库）简单介绍
m0_48596828的博客
10-12 736
一、NoSQL简介 1、简介 NoSQL最常见的解释是“non-relational”， “Not Only SQL”也被很多人接受。NoSQL仅仅是一个概念，泛指非关系型的数据库，区别于关系数据库，它们不保证关系数据的ACID特性。NoSQL是一项全新的数据库革命性运动，其拥护者们提倡运用非关系型的数据存储，相对于铺天盖地的关系型数据库运用，这一概念无疑是一种全新的思维的注入。 NoSQL有如下优点：易扩展，NoSQL数据库种类繁多，但是一个共同的特点都是去掉关系数据库的关系型特性。数据之间无关系，这样就
Rop开发手册(1):最简单的服务开放平台框架
stamen的程序员之路
08-08 509
[b][size=x-large] Rop概述[/size][/b] Rop是Rapid Open Platform的简称，它不同于一般纯技术型的Web Service框架（如CXF，Jersey等），Rop致力于构建开放服务平台的框架，您可以使用Rop开发类似于淘宝开放服务平台这样的服务平台。Rop充分借鉴了当前大型网站的开放服务平台的设计思路，汲取了它们成功的实践经验，对开放服务平台的很...
常见非关系型数据库(NoSQL)推荐介绍
MaLeo
11-12 2万+
随着互联网web2.0网站的兴起，非关系型的数据库现在成了一个极其热门的新领域， 非关系数据库产品的发展非常迅速。而传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不 从心，暴露了很多难以克服的问题，例如： 1、High performance – 对数据库高并发读写的需求  web2.0网站要根据用户个性化信息来实时生成动态页面和提
[云盘]（二）我的文件和共享列表后台实现
weixin_44417042的博客
07-01 384
我的列表 业务逻辑是，点击我的文件，会在展示界面展示出该用户所有文件 单机图标会显示选项下载，分享，删除，属性 单机空白处会显示选型，会显示选项：按下载量排序/按下载量排序/刷新/上传 其中上传操作也可以点击界面中的上传图标，然后会弹出窗口选择要上传的文件，上传过程是一个toolbar会显示进度在传输列表中 Mian 读取配置文件 read_cfg();拿到数据库连接 while (FCGI_Accept() >= 0)等待连接 业务主要分两种，一是只想知道用户有多少个文件，另一个是普通排序，
5.4空间数据库管理系统.pdf
02-27
空间数据库管理系统 空间数据库管理系统 本节 内容 文件与关系数据库混合管理 5.4.1 全关系型空间数据库管理 5.4.2 对象关系数据库管理 5.4.3 面向对象空间数据库管理 5.4.4 空间数据管理 5.4 文件与关系数据库混合...
Firebird数据库3.0 源码 -易语言
06-14
5、扩展函数我们可以使用C语言，C++，DELPHI写UDF,使用UDF（用户定义函数库）可以很容易的挂入数据库引擎中以扩展我们需要的功能6、字符集Firebird实现了很多国际标准的字符集，包括Unicode。7、SQL标准兼容Firebird...
4735-数据库系统原理.doc
02-27
在数据库阶段，数据占据了中心位置 4 数据库管理系统(DBMS)的类型：(1) 层次型[1:N] (2) 网状型[M:N] (3) 关系型 (4) 面向对象型 5 数据描述的三个阶段：(1) 概念设计 (2) 逻辑设计 (3) 物理设计 6 数据联系的三种...
[deal_cache.c]分析
weixin_44417042的博客
07-07 229
deal_cache.c封装了所有处理缓存数据库存储业务 int deal_cache_setLifecycle(cJSON *root) 给缓存中的sessionid设置生命周期 底层调用的也是封装好的redis接口 int deal_cache_setLifecycle(cJSON *root) { /* { cmd: "setLifcycle", key: "online-drive
Redis中的数据类型及其应用场景
unwrapping的博客
10-26 274
**redis中有哪些数据类型？**这个问题我被面试官问过好多次了，下面总结下这5种数据类型的特点，命令，还有应用场景 redis客户端的一些通用命令： ping # 测试redis是否链接 如果已链接返回 PONG echo message # 测试redis是否链接 如果已链接返回给定的message字符串 keys * # 返回所有的 key 可以加*通配 exists key # 判断key是否存在 如果存在返回1，否则返回0 expire key time(s) # 设置一个 key
redis Op
weixin_43251291的博客
10-24 350
Redis简介缓存中间件--Memcache和Redis的区别为什么Redis能这么快多路IO复用模型常用数据类型StringHashListSetSorted Set用于计数的HyperLogLog用于支持存储地理位置信息的Geo底层数据类型基础海量数据查询从海量Key里查询出某一固定前缀的Key**KEYS patterrn**: 查找所有符合给定模式pattern的key**SCAN** ...
Ｒｅｄｉｓ的５种数据类型及操作数据的命令
qq_51476492的博客
05-27 619
１.字符串类型 可以存储任何形式的字符串，包括二进制数据、序列化后的数据，JSON化的对象甚至是一张图片，最大５１２M． ２．哈希类型ｈａｓｈ ｈａｓｈ是一个ｓｔｒｉｎｇ类型的ｆｉｅｌｄ和ｖａｌｕｅ的映射表，ｈａｓｈ特别适合用于存储对象。 可以通过上述例子来理解，ｈａｓｈ类型一个实例为：ｋｅｙ是上图中“ｌｏｇｉｎｕｓｅｒ”，ｖａｌｕｅ是上图中的ｄａｔａ，儿“ｕｎａｍｅ”，“ｔｉｍｅｓ”，“ｒｅｇｉｏｎ”即为ｆｉｅｌｄ，“张三”，“５”，“北京”即为ｆｉｅｌｄ对应的ｖａｌｕｅ． ３.列表类型ｌｉｓｔ ｌｉｓ
静态服务器和api服务器的区别以及非关系型数据库的操作
Nicholas_Rainbow的博客
07-22 289
静态服务器 目的：做后端渲染，浏览器中显示 api服务器 目的：为了做接口，不能在浏览器中展示，需要用测试工具来测试接口 数据库 分类： 关系型数据库：（以行和列的形式存储数据）sql、mysql 非关系型数据库（nosql–用于超大规模的存储）：mongoDB----存储格式bson，bson是json格式的超集，增加了二进制流，集合-文档 MongoDB是基于分布式文件存储的数...
几种主要的非关系型数据库
热门推荐
qq_34116402的博客
03-16 9万+
Hbase    列式存储以流的方式在列中存储所有的数据。对于任何记录，索引都可以快速地获取列上的数据；列式存储支持行检索，但这需要从每个列获取匹配的列值，并重新组成行。HBase（Hadoop Database）是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，利用HBase技术可在廉价PC Server上搭建起大规模结构化存储集群。HBase是Google BigTable的开源实现，模...
Redis 实战之压缩列表
奔走的蚂蚁的博客
05-04 1006
压缩列表是一种为节约内存而开发的顺序型数据结构。压缩列表被用作列表键和哈希键的底层实现之一。压缩列表可以包含多个节点，每个节点可以保存一个字节数组或者整数值。添加新节点到压缩列表， 或者从压缩列表中删除节点， 可能会引发连锁更新操作， 但这种操作出现的几率并不高。
Redis 实战之对象
最新发布
奔走的蚂蚁的博客
05-04 1095
Redis 数据库中的每个键值对的键和值都是一个对象。Redis 共有字符串、列表、哈希、集合、有序集合五种类型的对象， 每种类型的对象至少都有两种或以上的编码方式， 不同的编码可以在不同的使用场景上优化对象的使用效率。服务器在执行某些命令之前， 会先检查给定键的类型能否执行指定的命令， 而检查一个键的类型就是检查键的值对象的类型。Redis 的对象系统带有引用计数实现的内存回收机制， 当一个对象不再被使用时， 该对象所占用的内存就会被自动释放。Redis 会共享值为 0 到 9999 的字符串对象。
C语言实现数据库接口
08-21
2. MySQL：MySQL是一种流行的关系型数据库，可以使用MySQL的C语言连接器（Connector/C）来访问。你需要安装MySQL Connector/C，并使用它提供的函数来连接数据库、执行查询和处理结果。 3. PostgreSQL：PostgreSQL是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值