Example #1
0
OP_NAMESPACE_BEGIN

    int Comms::LIndex(Context& ctx, RedisCommandFrame& cmd)
    {
        int64 index;
        if (!GetInt64Value(ctx, cmd.GetArguments()[1], index))
        {
            return 0;
        }
        std::string v;
        int err = m_kv_store->LIndex(ctx.currentDB, cmd.GetArguments()[0], index, v);
        if (err >= 0)
        {
            fill_str_reply(ctx.reply, v);
        }
        else if (mmkv::ERR_OFFSET_OUTRANGE == err)
        {
            ctx.reply.type = REDIS_REPLY_NIL;
        }
        else
        {
            FillErrorReply(ctx, err);
        }
        return 0;
    }
Example #2
0
 int Ardb::BRPopLPush(Context& ctx, RedisCommandFrame& cmd)
 {
     uint32 timeout;
     if (!string_touint32(cmd.GetArguments()[cmd.GetArguments().size() - 1], timeout))
     {
         fill_error_reply(ctx.reply, "timeout is not an integer or out of range");
         return 0;
     }
     RPopLPush(ctx, cmd);
     if (ctx.reply.type == REDIS_REPLY_NIL)
     {
         //block;
         AddBlockKey(ctx, cmd.GetArguments()[0]);
         if (NULL != ctx.client)
         {
             ctx.client->DetachFD();
             if (timeout > 0)
             {
                 ctx.block->blocking_timer_task_id = ctx.client->GetService().GetTimer().ScheduleHeapTask(
                         new BlockConnectionTimeout(&ctx), timeout, -1, SECONDS);
             }
         }
         ctx.reply.type = 0;
     }
     return 0;
 }
Example #3
0
 int Comms::RPopLPush(Context& ctx, RedisCommandFrame& cmd)
 {
     std::string v;
     int err = m_kv_store->RPopLPush(ctx.currentDB, cmd.GetArguments()[0], cmd.GetArguments()[1], v);
     if (err >= 0)
     {
         fill_str_reply(ctx.reply, v);
         FireKeyChangedEvent(ctx, cmd.GetArguments()[0]);
         FireKeyChangedEvent(ctx, cmd.GetArguments()[1]);
         if (cmd.GetType() == REDIS_CMD_BRPOPLPUSH)
         {
             ctx.current_cmd->SetCommand("rpoplpush");
         }
     }
     else
     {
         if (err == mmkv::ERR_ENTRY_NOT_EXIST || err == mmkv::ERR_DB_NOT_EXIST)
         {
             ctx.reply.type = REDIS_REPLY_NIL;
         }
         else
         {
             FillErrorReply(ctx, err);
         }
     }
     return 0;
 }
Example #4
0
File: t_hash.cpp Project: cvan/ardb
 int Ardb::HMGet(Context& ctx, RedisCommandFrame& cmd)
 {
     ValueObject meta;
     int err = GetMetaValue(ctx, cmd.GetArguments()[0], HASH_META, meta);
     CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
     ctx.reply.type = REDIS_REPLY_ARRAY;
     if (err == 0)
     {
         for (uint32 i = 1; i < cmd.GetArguments().size(); i++)
         {
             Data value;
             Data field(cmd.GetArguments()[i]);
             RedisReply& r = ctx.reply.AddMember();
             if (0 == HashGet(ctx, meta, field, value))
             {
                 r.type = REDIS_REPLY_STRING;
                 value.GetDecodeString(r.str);
             }
             else
             {
                 r.type = REDIS_REPLY_NIL;
             }
         }
     }
     else
     {
         ctx.reply.ReserveMember(cmd.GetArguments().size());
     }
     return 0;
 }
Example #5
0
 int Comms::Del(Context& ctx, RedisCommandFrame& cmd)
 {
     mmkv::DataArray fs;
     for (uint32 i = 0; i < cmd.GetArguments().size(); i++)
     {
         fs.push_back(cmd.GetArguments()[i]);
     }
     int err = m_kv_store->Del(ctx.currentDB, fs);
     if (err >= 0)
     {
         if (err > 0)
         {
             for (uint32 i = 0; i < cmd.GetArguments().size(); i++)
             {
                 FireKeyChangedEvent(ctx, cmd.GetArguments()[i]);
             }
         }
         fill_int_reply(ctx.reply, err);
     }
     else
     {
         FillErrorReply(ctx, err);
     }
     return 0;
 }
Example #6
0
File: t_hash.cpp Project: cvan/ardb
 int Ardb::HMSet(Context& ctx, RedisCommandFrame& cmd)
 {
     if (m_cfg.replace_for_hmset)
     {
         HReplace(ctx, cmd);
         return 0;
     }
     if ((cmd.GetArguments().size() - 1) % 2 != 0)
     {
         fill_error_reply(ctx.reply, "wrong number of arguments for HMSet");
         return 0;
     }
     ValueObject meta;
     int err = GetMetaValue(ctx, cmd.GetArguments()[0], HASH_META, meta);
     CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
     DataMap fs;
     for (uint32 i = 1; i < cmd.GetArguments().size(); i += 2)
     {
         Data f(cmd.GetArguments()[i]), v(cmd.GetArguments()[i + 1]);
         fs[f] = v;
     }
     HashMultiSet(ctx, meta, fs);
     fill_status_reply(ctx.reply, "OK");
     return 0;
 }
Example #7
0
File: t_hash.cpp Project: cvan/ardb
 int Ardb::HIncrbyFloat(Context& ctx, RedisCommandFrame& cmd)
 {
     double increment, val = 0;
     if (!GetDoubleValue(ctx, cmd.GetArguments()[2], increment))
     {
         return 0;
     }
     ValueObject meta;
     int err = GetMetaValue(ctx, cmd.GetArguments()[0], HASH_META, meta);
     CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
     Data value;
     Data field(cmd.GetArguments()[1]);
     if (0 == err)
     {
         HashGet(ctx, meta, field, value);
         if (!value.GetDouble(val))
         {
             fill_error_reply(ctx.reply, "value is not a float or out of range");
             return 0;
         }
     }
     val += increment;
     std::string tmp;
     fast_dtoa(val, 10, tmp);
     value.SetString(tmp, false);
     HashSet(ctx, meta, field, value);
     fill_str_reply(ctx.reply, tmp);
     return 0;
 }
Example #8
0
File: t_hash.cpp Project: cvan/ardb
 int Ardb::HIncrby(Context& ctx, RedisCommandFrame& cmd)
 {
     int64 increment, val = 0;
     if (!GetInt64Value(ctx, cmd.GetArguments()[2], increment))
     {
         return 0;
     }
     ValueObject meta;
     int err = GetMetaValue(ctx, cmd.GetArguments()[0], HASH_META, meta);
     CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
     Data field(cmd.GetArguments()[1]);
     Data value;
     if (err == 0)
     {
         err = HashGet(ctx, meta, field, value);
     }
     if (err == ERR_NOT_EXIST)
     {
         value.SetInt64(increment);
     }
     else
     {
         if (!value.GetInt64(val))
         {
             fill_error_reply(ctx.reply, "value is not a integer or out of range");
             return 0;
         }
         value.SetInt64(val + increment);
     }
     HashSet(ctx, meta, field, value);
     fill_int_reply(ctx.reply, val + increment);
     return 0;
 }
Example #9
0
 int Comms::LInsert(Context& ctx, RedisCommandFrame& cmd)
 {
     bool before_or_after = false;
     if (!strcasecmp(cmd.GetArguments()[1].c_str(), "before"))
     {
         before_or_after = true;
     }
     else if (!strcasecmp(cmd.GetArguments()[1].c_str(), "after"))
     {
         before_or_after = false;
     }
     else
     {
         fill_error_reply(ctx.reply, "Syntax error");
         return 0;
     }
     int err = m_kv_store->LInsert(ctx.currentDB, cmd.GetArguments()[0], before_or_after, cmd.GetArguments()[2],
             cmd.GetArguments()[3]);
     if (err >= 0 || -1 == err)
     {
         fill_int_reply(ctx.reply, err);
         if (err > 0)
         {
             FireKeyChangedEvent(ctx, cmd.GetArguments()[0]);
         }
     }
     else
     {
         FillErrorReply(ctx, err);
     }
     return 0;
 }
Example #10
0
File: geo.cpp Project: cvan/ardb
    /*
     *  GEOADD key MERCATOR|WGS84 x y value [x y value....]
     */
    int Ardb::GeoAdd(Context& ctx, RedisCommandFrame& cmd)
    {
        GeoAddOptions options;
        std::string err;
        if (0 != options.Parse(cmd.GetArguments(), err, 1))
        {
            fill_error_reply(ctx.reply, "%s", err.c_str());
            return 0;
        }
        GeoHashRange lat_range, lon_range;
        GeoHashHelper::GetCoordRange(options.coord_type, lat_range, lon_range);

        KeyLockerGuard keylock(m_key_lock, ctx.currentDB, cmd.GetArguments()[0]);
        ValueObject meta;
        int ret = GetMetaValue(ctx, cmd.GetArguments()[0], ZSET_META, meta);
        CHECK_ARDB_RETURN_VALUE(ctx.reply, ret);

        RedisCommandFrame zadd("zadd");
        zadd.AddArg(cmd.GetArguments()[0]);
        BatchWriteGuard guard(GetKeyValueEngine());
        GeoPointArray::iterator git = options.points.begin();
        uint32 count = 0;
        while (git != options.points.end())
        {
            GeoPoint& point = *git;
            if (point.x < lon_range.min || point.x > lon_range.max || point.y < lat_range.min
                    || point.y > lat_range.max)
            {
                guard.MarkFailed();
                break;
            }
            GeoHashBits hash;
            geohash_encode(&lat_range, &lon_range, point.y, point.x, 30, &hash);
            GeoHashFix60Bits score = hash.bits;
            Data score_value;
            score_value.SetInt64((int64) score);
            Data element;
            element.SetString(point.value, true);
            count += ZSetAdd(ctx, meta, element, score_value, NULL);

            std::string tmp;
            score_value.GetDecodeString(tmp);
            zadd.AddArg(tmp);
            element.GetDecodeString(tmp);
            zadd.AddArg(tmp);
            git++;
        }
        if (guard.Success())
        {
            SetKeyValue(ctx, meta);
            RewriteClientCommand(ctx, zadd);
            fill_int_reply(ctx.reply, count);
        }
        else
        {
            fill_error_reply(ctx.reply, "Invalid arguments");
        }
        return 0;
    }
Example #11
0
 int Ardb::PSubscribe(Context& ctx, RedisCommandFrame& cmd)
 {
     ctx.client->GetWritableOptions().max_write_buffer_size = (int32)(m_cfg.pubsub_client_output_buffer_limit);
     for (uint32 i = 0; i < cmd.GetArguments().size(); i++)
     {
         PSubscribeChannel(ctx, cmd.GetArguments()[i], true);
     }
     return 0;
 }
Example #12
0
File: t_hash.cpp Project: cvan/ardb
 int Ardb::HSet(Context& ctx, RedisCommandFrame& cmd)
 {
     ValueObject meta;
     int err = GetMetaValue(ctx, cmd.GetArguments()[0], HASH_META, meta);
     CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
     Data field(cmd.GetArguments()[1]), value(cmd.GetArguments()[2]);
     HashSet(ctx, meta, field, value);
     //fill_int_reply(ctx.reply, err);
     return 0;
 }
Example #13
0
 int Ardb::LRange(Context& ctx, RedisCommandFrame& cmd)
 {
     int64 start, end;
     if (!GetInt64Value(ctx, cmd.GetArguments()[1], start) || !GetInt64Value(ctx, cmd.GetArguments()[2], end))
     {
         return 0;
     }
     ctx.reply.type = REDIS_REPLY_ARRAY;
     ListRange(ctx, cmd.GetArguments()[0], start, end);
     return 0;
 }
Example #14
0
 int Ardb::Expire(Context& ctx, RedisCommandFrame& cmd)
 {
     uint64 v = 0;
     if (!check_uint64_arg(ctx.reply, cmd.GetArguments()[1], v))
     {
         return 0;
     }
     int err = GenericExpire(ctx, cmd.GetArguments()[0], v * 1000 + get_current_epoch_millis());
     fill_int_reply(ctx.reply, err == 0 ? 1 : 0);
     return 0;
 }
Example #15
0
File: keys.cpp Project: boreys/ardb
 int Ardb::Expireat(Context& ctx, RedisCommandFrame& cmd)
 {
     uint32 v = 0;
     if (!check_uint32_arg(ctx.reply, cmd.GetArguments()[1], v))
     {
         return 0;
     }
     int err = GenericExpire(ctx, cmd.GetArguments()[0], v * 1000);
     fill_int_reply(ctx.reply, err == 0 ? 1 : 0);
     return 0;
 }
Example #16
0
 int ArdbServer::MGet(ArdbConnContext& ctx, RedisCommandFrame& cmd)
 {
     SliceArray keys;
     for (uint32 i = 0; i < cmd.GetArguments().size(); i++)
     {
         keys.push_back(cmd.GetArguments()[i]);
     }
     StringArray res;
     m_db->MGet(ctx.currentDB, keys, res);
     fill_str_array_reply(ctx.reply, res);
     return 0;
 }
Example #17
0
 int ArdbServer::PSetEX(ArdbConnContext& ctx, RedisCommandFrame& cmd)
 {
     uint32 mills;
     if (!string_touint32(cmd.GetArguments()[1], mills))
     {
         fill_error_reply(ctx.reply, "value is not an integer or out of range");
         return 0;
     }
     m_db->PSetEx(ctx.currentDB, cmd.GetArguments()[0], cmd.GetArguments()[2], mills);
     fill_status_reply(ctx.reply, "OK");
     return 0;
 }
Example #18
0
    void Slave::HandleRedisCommand(Channel* ch, RedisCommandFrame& cmd)
    {
        int flag = ARDB_PROCESS_REPL_WRITE;
        if (m_slave_state == SLAVE_STATE_SYNCED || m_slave_state == SLAVE_STATE_LOADING_DUMP_DATA)
        {
            flag |= ARDB_PROCESS_FORCE_REPLICATION;
        }
        else
        {
            flag |= ARDB_PROCESS_WITHOUT_REPLICATION;
        }
        DEBUG_LOG("Recv master cmd %s at %lld at flag:%d at state:%d", cmd.ToString().c_str(),
                m_backlog.GetReplEndOffset(), flag, m_slave_state);
        if (m_slave_state == SLAVE_STATE_WAITING_PSYNC_REPLY && m_server_type == ARDB_DB_SERVER_TYPE)
        {
            if (!strcasecmp(cmd.GetCommand().c_str(), "FULLSYNCED"))
            {
                uint64 offset, cksm;
                string_touint64(cmd.GetArguments()[0], offset);
                string_touint64(cmd.GetArguments()[1], cksm);
                m_backlog.SetChecksum(cksm);
                ASSERT(offset == m_backlog.GetReplEndOffset());
                //m_backlog.SetReplOffset(offset);
                m_slave_state = SLAVE_STATE_SYNCED;
                //Disconnect all slaves when all data resynced
                m_serv->m_master_serv.DisconnectAllSlaves();
                return;
            }
        }

        if (!strcasecmp(cmd.GetCommand().c_str(), "PING"))
        {
            m_ping_recved_time = time(NULL);
        }
        else if (!strcasecmp(cmd.GetCommand().c_str(), "SELECT"))
        {
            DBID id = 0;
            string_touint32(cmd.GetArguments()[0], id);
            m_backlog.SetCurrentDBID(id);
        }
        GetArdbConnContext();
        m_actx->is_slave_conn = true;
        m_actx->conn = ch;

        if (strcasecmp(cmd.GetCommand().c_str(), "SELECT") && strcasecmp(cmd.GetCommand().c_str(), "__SET__")
                && strcasecmp(cmd.GetCommand().c_str(), "__DEL__"))
        {
            if (!m_include_dbs.empty() && m_include_dbs.count(m_actx->currentDB) == 0)
            {
                flag |= ARDB_PROCESS_FEED_REPLICATION_ONLY;
            }
            if (!m_exclude_dbs.empty() && m_exclude_dbs.count(m_actx->currentDB) > 0)
            {
                flag |= ARDB_PROCESS_FEED_REPLICATION_ONLY;
            }
        }
        m_serv->ProcessRedisCommand(*m_actx, cmd, flag);
    }
Example #19
0
 int ArdbServer::SetRange(ArdbConnContext& ctx, RedisCommandFrame& cmd)
 {
     int32 offset;
     if (!string_toint32(cmd.GetArguments()[1], offset))
     {
         fill_error_reply(ctx.reply, "value is not an integer or out of range");
         return 0;
     }
     int ret = m_db->SetRange(ctx.currentDB, cmd.GetArguments()[0], offset, cmd.GetArguments()[2]);
     fill_int_reply(ctx.reply, ret);
     return 0;
 }
Example #20
0
 int ArdbServer::GetRange(ArdbConnContext& ctx, RedisCommandFrame& cmd)
 {
     int32 start, end;
     if (!string_toint32(cmd.GetArguments()[1], start) || !string_toint32(cmd.GetArguments()[2], end))
     {
         fill_error_reply(ctx.reply, "value is not an integer or out of range");
         return 0;
     }
     std::string v;
     m_db->GetRange(ctx.currentDB, cmd.GetArguments()[0], start, end, v);
     fill_str_reply(ctx.reply, v);
     return 0;
 }
Example #21
0
File: keys.cpp Project: boreys/ardb
 int Ardb::PExpire(Context& ctx, RedisCommandFrame& cmd)
 {
     uint32 v = 0;
     if (!check_uint32_arg(ctx.reply, cmd.GetArguments()[1], v))
     {
         return 0;
     }
     ValueObject meta;
     int err = GenericExpire(ctx, cmd.GetArguments()[0], v + get_current_epoch_millis());
     CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
     fill_int_reply(ctx.reply, err == 0 ? 1 : 0);
     return 0;
 }
Example #22
0
File: t_hash.cpp Project: cvan/ardb
 int Ardb::HDel(Context& ctx, RedisCommandFrame& cmd)
 {
     ValueObject meta;
     int err = GetMetaValue(ctx, cmd.GetArguments()[0], HASH_META, meta);
     CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
     int count = 0;
     if (err == 0)
     {
         BatchWriteGuard guard(GetKeyValueEngine());
         for (uint32 i = 1; i < cmd.GetArguments().size(); i++)
         {
             Data field(cmd.GetArguments()[i]);
             Data value;
             err = HashGet(ctx, meta, field, value);
             if (err == 0)
             {
                 if (meta.meta.encoding != COLLECTION_ECODING_ZIPMAP)
                 {
                     KeyObject k;
                     k.db = ctx.currentDB;
                     k.key = cmd.GetArguments()[0];
                     k.type = HASH_FIELD;
                     k.element = field;
                     DelKeyValue(ctx, k);
                     if (meta.meta.len > 0)
                     {
                         meta.meta.len--;
                     }
                 }
                 else
                 {
                     meta.meta.zipmap.erase(field);
                 }
                 count++;
             }
         }
         if (count > 0)
         {
             if (meta.meta.Length() != 0)
             {
                 SetKeyValue(ctx, meta);
             }
             else
             {
                 DelKeyValue(ctx, meta.key);
             }
         }
     }
     fill_int_reply(ctx.reply, count);
     return 0;
 }
Example #23
0
 int ArdbServer::GetSet(ArdbConnContext& ctx, RedisCommandFrame& cmd)
 {
     std::string v;
     int ret = m_db->GetSet(ctx.currentDB, cmd.GetArguments()[0], cmd.GetArguments()[1], v);
     if (ret < 0)
     {
         ctx.reply.type = REDIS_REPLY_NIL;
     }
     else
     {
         fill_str_reply(ctx.reply, v);
     }
     return 0;
 }
Example #24
0
 int Ardb::LPush(Context& ctx, RedisCommandFrame& cmd)
 {
     ValueObject meta;
     int err = GetMetaValue(ctx, cmd.GetArguments()[0], LIST_META, meta);
     CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
     KeyLockerGuard lock(m_key_lock, ctx.currentDB, cmd.GetArguments()[0]);
     BatchWriteGuard guard(GetKeyValueEngine(), cmd.GetArguments().size() > 2);
     for (uint32 i = 1; i < cmd.GetArguments().size(); i++)
     {
         ListInsert(ctx, meta, NULL, cmd.GetArguments()[i], true, false);
     }
     SetKeyValue(ctx, meta);
     return 0;
 }
Example #25
0
void test_lists_pushx(Context& ctx, Ardb& db)
{
    db.GetConfig().list_max_ziplist_entries = 10;
    RedisCommandFrame del;
    del.SetFullCommand("del mylist");
    db.Call(ctx, del, 0);
    RedisCommandFrame lpushx;
    lpushx.SetFullCommand("lpushx mylist value");
    db.Call(ctx, lpushx, 0);
    CHECK_FATAL(ctx.reply.type != REDIS_REPLY_INTEGER, "lpushx mylist failed");
    CHECK_FATAL(ctx.reply.integer != 0, "lpushx mylist failed");
    RedisCommandFrame rpushx;
    rpushx.SetFullCommand("rpushx mylist value");
    db.Call(ctx, rpushx, 0);
    CHECK_FATAL(ctx.reply.type != REDIS_REPLY_INTEGER, "rpushx mylist failed");
    CHECK_FATAL(ctx.reply.integer != 0, "rpushx mylist failed");

    RedisCommandFrame mlpush;
    mlpush.SetFullCommand(
            "lpush mylist value10 value11 value12 value13 value10 value10 value10 value10 value10 value10");
    db.Call(ctx, mlpush, 0);
    db.Call(ctx, lpushx, 0);
    CHECK_FATAL(ctx.reply.type != REDIS_REPLY_INTEGER, "lpushx mylist failed");
    CHECK_FATAL(ctx.reply.integer != 11, "lpushx mylist failed");
    db.Call(ctx, rpushx, 0);
    CHECK_FATAL(ctx.reply.type != REDIS_REPLY_INTEGER, "rpushx mylist failed");
    CHECK_FATAL(ctx.reply.integer != 12, "rpushx mylist failed");
}
Example #26
0
void test_lists_llen(Context& ctx, Ardb& db)
{
    db.GetConfig().list_max_ziplist_entries = 16;
    RedisCommandFrame del;
    del.SetFullCommand("del mylist");
    db.Call(ctx, del, 0);
    //ziplist push
    for (int i = 0; i < 10; i++)
    {
        RedisCommandFrame lpush;
        lpush.SetFullCommand("lpush mylist value%d", i);
        db.Call(ctx, lpush, 0);
    }
    RedisCommandFrame llen;
    llen.SetFullCommand("llen mylist");
    db.Call(ctx, llen, 0);
    CHECK_FATAL(ctx.reply.type != REDIS_REPLY_INTEGER, "llen mylist failed");
    CHECK_FATAL(ctx.reply.integer != 10, "llen mylist failed");

    //non ziplist lpush
    for (int i = 0; i < 10; i++)
    {
        RedisCommandFrame lpush;
        lpush.SetFullCommand("lpush mylist xvalue%d", i);
        db.Call(ctx, lpush, 0);
    }
    db.Call(ctx, llen, 0);
    CHECK_FATAL(ctx.reply.type != REDIS_REPLY_INTEGER, "llen mylist failed");
    CHECK_FATAL(ctx.reply.integer != 20, "llen mylist failed");
}
Example #27
0
 int Ardb::Watch(Context& ctx, RedisCommandFrame& cmd)
 {
     if (ctx.InTransc())
     {
         fill_error_reply(ctx.reply, "WATCH inside MULTI is not allowed");
         return 0;
     }
     for (uint32 i = 0; i < cmd.GetArguments().size(); i++)
     {
         WatchForKey(ctx, cmd.GetArguments()[i]);
     }
     fill_status_reply(ctx.reply, "OK");
     return 0;
 }
Example #28
0
void test_lists_rpoplpush(Context& ctx, Ardb& db)
{
    db.GetConfig().list_max_ziplist_entries = 16;
    RedisCommandFrame del;
    del.SetFullCommand("del mylist mylist1");
    db.Call(ctx, del, 0);
    //ziplist push
    for (int i = 0; i < 10; i++)
    {
        RedisCommandFrame lpush;
        lpush.SetFullCommand("lpush mylist value%d", i);
        db.Call(ctx, lpush, 0);
    }
    RedisCommandFrame rpoplpush;
    rpoplpush.SetFullCommand("rpoplpush mylist mylist1");
    db.Call(ctx, rpoplpush, 0);
    CHECK_FATAL(ctx.reply.type != REDIS_REPLY_STRING, "rpoplpush mylist failed");
    CHECK_FATAL(ctx.reply.str != "value0", "rpoplpush mylist failed");

    //non ziplist lpush
    for (int i = 0; i < 20; i++)
    {
        RedisCommandFrame lpush;
        lpush.SetFullCommand("lpush mylist xvalue%d", i);
        db.Call(ctx, lpush, 0);
    }
    db.Call(ctx, rpoplpush, 0);
    CHECK_FATAL(ctx.reply.type != REDIS_REPLY_STRING, "rpoplpush mylist failed");
    CHECK_FATAL(ctx.reply.str != "value1", "rpoplpush mylist failed");
}
Example #29
0
File: keys.cpp Project: boreys/ardb
 int Ardb::Del(Context& ctx, RedisCommandFrame& cmd)
 {
     if (ctx.IsSlave() && m_cfg.slave_ignore_del)
     {
         return 0;
     }
     BatchWriteGuard guard(GetKeyValueEngine());
     int count = 0;
     for (uint32 i = 0; i < cmd.GetArguments().size(); i++)
     {
         count += DeleteKey(ctx, cmd.GetArguments()[i]);
     }
     fill_int_reply(ctx.reply, count);
     return 0;
 }
Example #30
0
 int ArdbServer::GeoSearch(ArdbConnContext& ctx, RedisCommandFrame& cmd)
 {
     GeoSearchOptions options;
     std::string err;
     if (0 != options.Parse(cmd.GetArguments(), err, 1))
     {
         fill_error_reply(ctx.reply, "%s", err.c_str());
         return 0;
     }
     ValueDataDeque res;
     int ret = m_db->GeoSearch(ctx.currentDB, cmd.GetArguments()[0], options, res);
     CHECK_ARDB_RETURN_VALUE(ctx.reply, ret);
     fill_array_reply(ctx.reply, res);
     return 0;
 }