Function setWithKey

src/t_nhash.cpp:127–181

Returns one if we overwrote a value

// Returns one if we overwrote a value
bool setWithKey(redisDb *db, robj_roptr key, robj *val, bool fCreateBuckets) {
    const char *pchCur = szFromObj(key);
    const char *pchStart = pchCur;
    const char *pchMax = pchCur + sdslen(pchCur);
    robj *o = nullptr;

    while (pchCur <= pchMax) {
        if (pchCur == pchMax || *pchCur == '.') {
            // WARNING: Don't deref pchCur as it may be pchMax

            // New word
            if ((pchCur - pchStart) < 1) {
                throw shared.syntaxerr; // malformed
            }

            DbDictWrapper src;
            if (o == nullptr)
                src = db;
            else
                src = (dict*)ptrFromObj(o);
            
            sdsstring str(pchStart, pchCur - pchStart);
            dict_iter di = src.find(str.get());

            if (pchCur == pchMax) {
                val->addref();
                if (di.val() != nullptr) {
                    decrRefCount(di.val());
                    di.setval(val);
                    return true;
                } else {
                    src.add(str.release(), val);
                    return false;
                }
            } else {
                o = di.val();

                if (o == nullptr) {
                    if (!fCreateBuckets)
                        throw shared.nokeyerr;   // Not Found
                    o = createNestHashBucket();
                    serverAssert(src.add(str.release(), o));
                } else if (o->type != OBJ_NESTEDHASH) {
                    decrRefCount(o);
                    o = createNestHashBucket();
                    di.setval(o);
                }
            }

            pchStart = pchCur + 1;
        }
        ++pchCur;
    }
    throw "Internal Error";
}

void writeNestedHashToClient(client *c, robj_roptr o) {
    if (o == nullptr) {