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;
}
void LADSPA_next( LADSPA *unit, int inNumSamples ) {
if(!unit->desc) return;
unit->desc->run(unit->handle, inNumSamples);
int i = unit->plugin_channels;
while(i<unit->requested_channels) {
ZClear(inNumSamples, ZOUT(i));
i++;
}
}
int Ardb::ZUnionStore(const DBID& db, const Slice& dst, SliceArray& keys,
WeightArray& weights, AggregateType type)
{
while (weights.size() < keys.size())
{
weights.push_back(1);
}
ValueScoreMap vm;
struct ZUnionWalk: public WalkHandler
{
uint32_t z_weight;
ValueScoreMap& z_vm;
AggregateType z_aggre_type;
ZUnionWalk(uint32_t ws, ValueScoreMap& vm, AggregateType type) :
z_weight(ws), z_vm(vm), z_aggre_type(type)
{
}
int OnKeyValue(KeyObject* k, ValueObject* value, uint32 cursor)
{
ZSetKeyObject* zsk = (ZSetKeyObject*) k;
double score = 0;
switch (z_aggre_type)
{
case AGGREGATE_MIN:
{
score = z_weight * zsk->score;
if (score < z_vm[zsk->value])
{
z_vm[zsk->value] = score;
}
break;
}
case AGGREGATE_MAX:
{
score = z_weight * (zsk->score);
if (score > z_vm[zsk->value])
{
z_vm[zsk->value] = score;
}
break;
}
case AGGREGATE_SUM:
default:
{
score = z_weight * (zsk->score) + z_vm[zsk->value];
z_vm[zsk->value] = score;
break;
}
}
return 0;
}
};
SliceArray::iterator kit = keys.begin();
uint32_t idx = 0;
while (kit != keys.end())
{
ZSetMetaValue meta;
if (0 == GetZSetMetaValue(db, *kit, meta))
{
Slice empty;
ZSetKeyObject tmp(*kit, empty, meta.min_score, db);
ZUnionWalk walk(weights[idx], vm, type);
Walk(tmp, false, &walk);
}
idx++;
kit++;
}
if (vm.size() > 0)
{
double min_score = 0, max_score = 0;
BatchWriteGuard guard(GetEngine());
ZClear(db, dst);
KeyLockerGuard keyguard(m_key_locker, db, dst);
ZSetMetaValue meta;
meta.size = vm.size();
while (!vm.empty())
{
ValueScoreMap::iterator it = vm.begin();
ZSetKeyObject zsk(dst, it->first, it->second, db);
ValueObject zsv;
zsv.type = EMPTY;
ZSetScoreKeyObject zk(dst, it->first, db);
ValueObject zv;
zv.type = DOUBLE;
zv.v.double_v = it->second;
if (zv.v.double_v < min_score)
{
min_score = zv.v.double_v;
}
if (zv.v.double_v > max_score)
{
max_score = zv.v.double_v;
}
SetValue(zsk, zsv);
SetValue(zk, zv);
//reduce memory footprint for huge data set
vm.erase(it);
}
meta.min_score = min_score;
meta.max_score = max_score;
SetZSetMetaValue(db, dst, meta);
}
return vm.size();
}
int Ardb::ZInterStore(const DBID& db, const Slice& dst, SliceArray& keys,
WeightArray& weights, AggregateType type)
{
while (weights.size() < keys.size())
{
weights.push_back(1);
}
uint32_t min_size = 0;
ZSetMetaValueArray metas;
uint32_t min_idx = 0;
uint32_t idx = 0;
SliceArray::iterator kit = keys.begin();
while (kit != keys.end())
{
ZSetMetaValue meta;
if (0 == GetZSetMetaValue(db, *kit, meta))
{
if (min_size == 0 || min_size > meta.size)
{
min_size = meta.size;
min_idx = idx;
}
}
metas.push_back(meta);
kit++;
idx++;
}
struct ZInterWalk: public WalkHandler
{
uint32_t z_weight;
ValueScoreMap& z_cmp;
ValueScoreMap& z_result;
AggregateType z_aggre_type;
ZInterWalk(uint32_t weight, ValueScoreMap& cmp,
ValueScoreMap& result, AggregateType type) :
z_weight(weight), z_cmp(cmp), z_result(result), z_aggre_type(
type)
{
}
int OnKeyValue(KeyObject* k, ValueObject* value, uint32 cursor)
{
ZSetKeyObject* zsk = (ZSetKeyObject*) k;
if ((&z_cmp != &z_result) && z_cmp.count(zsk->value) == 0)
{
return 0;
}
switch (z_aggre_type)
{
case AGGREGATE_MIN:
{
double score = z_weight * zsk->score;
ValueScoreMap::iterator it = z_cmp.find(zsk->value);
if (it == z_cmp.end() || score < it->second)
{
z_result[zsk->value] = score;
}
break;
}
case AGGREGATE_MAX:
{
double score = z_weight * zsk->score;
ValueScoreMap::iterator it = z_cmp.find(zsk->value);
if (it == z_cmp.end() || score > it->second)
{
z_result[zsk->value] = score;
}
break;
}
case AGGREGATE_SUM:
default:
{
if (z_cmp.count(zsk->value) == 0)
{
z_result[zsk->value] = z_weight * (zsk->score);
} else
{
z_result[zsk->value] = z_weight * (zsk->score)
+ z_cmp[zsk->value];
}
break;
}
}
return 0;
}
};
ValueScoreMap cmp1, cmp2;
Slice empty;
ZSetKeyObject cmp_start(keys[min_idx], empty, metas[min_idx].min_score,
db);
ZInterWalk walk(weights[min_idx], cmp1, cmp1, type);
Walk(cmp_start, false, &walk);
ValueScoreMap* cmp = &cmp1;
ValueScoreMap* result = &cmp2;
for (uint32_t i = 0; i < keys.size(); i++)
{
if (i != min_idx)
{
Slice empty;
ZSetKeyObject tmp(keys.at(i), empty, metas[i].min_score, db);
ZInterWalk walk(weights[i], *cmp, *result, type);
Walk(tmp, false, &walk);
cmp->clear();
ValueScoreMap* old = cmp;
cmp = result;
result = old;
}
}
if (cmp->size() > 0)
{
double min_score = 0, max_score = 0;
BatchWriteGuard guard(GetEngine());
ZClear(db, dst);
KeyLockerGuard keyguard(m_key_locker, db, dst);
ZSetMetaValue meta;
meta.size = cmp->size();
while (!cmp->empty())
{
ValueScoreMap::iterator it = cmp->begin();
ZSetKeyObject zsk(dst, it->first, it->second, db);
ValueObject zsv;
zsv.type = EMPTY;
ZSetScoreKeyObject zk(dst, it->first, db);
ValueObject zv;
zv.type = DOUBLE;
zv.v.double_v = it->second;
if (zv.v.double_v < min_score)
{
min_score = zv.v.double_v;
}
if (zv.v.double_v > max_score)
{
max_score = zv.v.double_v;
}
SetValue(zsk, zsv);
SetValue(zk, zv);
//reduce memory footprint for huge data set
cmp->erase(it);
}
meta.min_score = min_score;
meta.max_score = max_score;
SetZSetMetaValue(db, dst, meta);
}
return cmp->size();
}