int Ardb::DeleteKey(Context& ctx, const Slice& key) { ValueObject meta; meta.key.type = KEY_META; meta.key.db = ctx.currentDB; meta.key.key = key; if (0 != GetKeyValue(ctx, meta.key, &meta)) { return 0; } switch (meta.type) { case SET_META: { SClear(ctx, meta); break; } case LIST_META: { LClear(ctx, meta); break; } case ZSET_META: { ZClear(ctx, meta); break; } case HASH_META: { HClear(ctx, meta); break; } case STRING_META: { DelKeyValue(ctx, meta.key); break; } case BITSET_META: { BitClear(ctx, meta); break; } default: { return 0; } } if (meta.meta.expireat > 0) { KeyObject expire; expire.type = KEY_EXPIRATION_ELEMENT; expire.db = ctx.currentDB; expire.key = key; expire.score.SetInt64(meta.meta.expireat); DelKeyValue(ctx, expire); } return 1; }
int Ardb::Sort(const DBID& db, const Slice& key, const StringArray& args, ValueArray& values) { SortOptions options; if (parse_sort_options(options, args) < 0) { DEBUG_LOG("Failed to parse sort options."); return ERR_INVALID_ARGS; } int type = Type(db, key); ValueArray sortvals; switch (type) { case LIST_META: { LRange(db, key, 0, -1, sortvals); break; } case SET_ELEMENT: { SMembers(db, key, sortvals); break; } case ZSET_ELEMENT_SCORE: { QueryOptions tmp; ZRange(db, key, 0, -1, sortvals, tmp); if(NULL == options.by) { options.nosort = true; } break; } default: { return ERR_INVALID_TYPE; } } if (sortvals.empty()) { return 0; } if (options.with_limit) { if (options.limit_offset < 0) { options.limit_offset = 0; } if ((uint32) options.limit_offset > sortvals.size()) { values.clear(); return 0; } if (options.limit_count < 0) { options.limit_count = sortvals.size(); } } std::vector<SortValue> sortvec; if (!options.nosort) { if (NULL != options.by) { sortvec.reserve(sortvals.size()); } for (uint32 i = 0; i < sortvals.size(); i++) { if (NULL != options.by) { sortvec.push_back(SortValue(&sortvals[i])); if (GetValueByPattern(db, options.by, sortvals[i], sortvec[i].cmp) < 0) { DEBUG_LOG("Failed to get value by pattern:%s", options.by); sortvec[i].cmp.Clear(); continue; } } if (options.with_alpha) { if (NULL != options.by) { value_convert_to_raw(sortvec[i].cmp); } else { value_convert_to_raw(sortvals[i]); } } else { if (NULL != options.by) { value_convert_to_number(sortvec[i].cmp); } else { value_convert_to_number(sortvals[i]); } } } if (NULL != options.by) { if (!options.is_desc) { std::sort(sortvec.begin(), sortvec.end(), less_value<SortValue>); } else { std::sort(sortvec.begin(), sortvec.end(), greater_value<SortValue>); } } else { if (!options.is_desc) { std::sort(sortvals.begin(), sortvals.end(), less_value<ValueObject>); } else { std::sort(sortvals.begin(), sortvals.end(), greater_value<ValueObject>); } } } if (!options.with_limit) { options.limit_offset = 0; options.limit_count = sortvals.size(); } uint32 count = 0; for (uint32 i = options.limit_offset; i < sortvals.size() && count < (uint32) options.limit_count; i++, count++) { ValueObject* patternObj = NULL; if (NULL != options.by) { patternObj = sortvec[i].value; } else { patternObj = &(sortvals[i]); } if (options.get_patterns.empty()) { values.push_back(*patternObj); } else { for (uint32 j = 0; j < options.get_patterns.size(); j++) { ValueObject vo; if (GetValueByPattern(db, options.get_patterns[j], *patternObj, vo) < 0) { DEBUG_LOG("Failed to get value by pattern for:%s", options.get_patterns[j]); vo.Clear(); } values.push_back(vo); } } } if (options.store_dst != NULL && !values.empty()) { BatchWriteGuard guard(GetEngine()); LClear(db, options.store_dst); ValueArray::iterator it = values.begin(); uint64 score = 0; while (it != values.end()) { if (it->type != EMPTY) { ListKeyObject lk(options.store_dst, score, db); SetValue(lk, *it); score++; } it++; } ListMetaValue meta; meta.min_score = 0; meta.max_score = (score - 1); meta.size = score; SetListMetaValue(db, options.store_dst, meta); } return 0; }