int OnKeyValue(KeyObject* k, ValueObject* v, uint32 cursor)
{
ZSetKeyObject* zsk = (ZSetKeyObject*) k;
bool inrange = false;
inrange =
z_containmin ?
zsk->score >= z_min_score :
zsk->score > z_min_score;
if (inrange)
{
inrange =
z_containmax ?
zsk->score <= z_max_score :
zsk->score < z_max_score;
}
if (inrange)
{
if (z_options.withlimit)
{
if (z_count >= z_options.limit_offset
&& z_count
<= (z_options.limit_count
+ z_options.limit_offset))
{
inrange = true;
} else
{
inrange = false;
}
}
z_count++;
if (inrange)
{
z_values.push_back(zsk->value);
if (z_options.withscores)
{
z_values.push_back(ValueObject(zsk->score));
}
}
}
if (zsk->score == z_min_score
|| (z_options.withlimit
&& z_count
> (z_options.limit_count
+ z_options.limit_offset)))
{
return -1;
}
return 0;
}
int OnKeyValue(KeyObject* k, ValueObject* v, uint32 cursor)
{
ZSetKeyObject* zsk = (ZSetKeyObject*) k;
if (rank >= z_start && rank <= z_stop)
{
z_values.push_back(zsk->value);
if (z_options.withscores)
{
z_values.push_back(ValueObject(zsk->score));
}
count++;
}
rank++;
if (rank > z_stop)
{
return -1;
}
return 0;
}
IValue *ValueObject::copy()
{
return SCALES_NEW ValueObject(obj, mask);
}
extern byte *
ValueToBinary(
ValueStruct *val)
{
byte *ret;
ENTER_FUNC;
if ( val == NULL ) {
ret = NULL;
} else {
dbgprintf("type = %X\n",(int)ValueType(val));
if ( ValueStr(val) == NULL ) {
ValueStr(val) = NewLBS();
}
LBS_EmitStart(ValueStr(val));
if ( IS_VALUE_NIL(val) ) {
LBS_EmitChar(ValueStr(val),CHAR_NIL);
} else {
switch (ValueType(val)) {
case GL_TYPE_CHAR:
case GL_TYPE_VARCHAR:
case GL_TYPE_DBCODE:
case GL_TYPE_TEXT:
case GL_TYPE_SYMBOL:
if ( ValueString(val) != NULL ) {
LBS_ReserveSize(ValueStr(val),strlen(ValueString(val))+1,FALSE);
strcpy(ValueStrBody(val),ValueString(val));
} else {
LBS_EmitChar(ValueStr(val),CHAR_NIL);
}
break;
case GL_TYPE_BYTE:
case GL_TYPE_BINARY:
LBS_ReserveSize(ValueStr(val),ValueByteLength(val),FALSE);
memcpy(ValueStrBody(val),ValueByte(val),ValueByteLength(val));
break;
case GL_TYPE_NUMBER:
LBS_ReserveSize(ValueStr(val),sizeof(Fixed),FALSE);
memcpy(ValueStrBody(val),&ValueFixed(val),sizeof(Fixed));
break;
case GL_TYPE_INT:
LBS_ReserveSize(ValueStr(val),sizeof(int),FALSE);
memcpy(ValueStrBody(val),&ValueInteger(val),sizeof(int));
break;
case GL_TYPE_OBJECT:
LBS_ReserveSize(ValueStr(val),sizeof(MonObjectType),FALSE);
memcpy(ValueStrBody(val),&ValueObject(val),sizeof(MonObjectType));
break;
case GL_TYPE_FLOAT:
LBS_ReserveSize(ValueStr(val),sizeof(double),FALSE);
memcpy(ValueStrBody(val),&ValueFloat(val),sizeof(double));
break;
case GL_TYPE_BOOL:
LBS_ReserveSize(ValueStr(val),sizeof(Bool),FALSE);
memcpy(ValueStrBody(val),&ValueBool(val),sizeof(Bool));
break;
case GL_TYPE_TIMESTAMP:
case GL_TYPE_DATE:
case GL_TYPE_TIME:
LBS_ReserveSize(ValueStr(val),sizeof(int)*9,FALSE);
memcpy(ValueStrBody(val),&ValueDateTime(val),sizeof(int)*9);
break;
default:
break;
}
}
ret = ValueStrBody(val);
}
LEAVE_FUNC;
return (ret);
}
KeyObject* decode_key(const Slice& key, KeyObject* expected)
{
Buffer buf(const_cast<char*>(key.data()), 0, key.size());
uint32 header;
if (!BufferHelper::ReadFixUInt32(buf, header))
{
return NULL;
}
uint8 type = header & 0xFF;
uint32 db = header >> 8;
if (NULL != expected)
{
if (type != expected->type || db != expected->db)
{
return NULL;
}
}
Slice keystr;
if (!BufferHelper::ReadVarSlice(buf, keystr))
{
return NULL;
}
if (NULL != expected)
{
if (keystr != expected->key)
{
return NULL;
}
}
switch (type)
{
case HASH_FIELD:
{
Slice field;
if (!BufferHelper::ReadVarSlice(buf, field))
{
return NULL;
}
return new HashKeyObject(keystr, field, db);
}
case LIST_ELEMENT:
{
float score;
if (!BufferHelper::ReadFixFloat(buf, score))
{
return NULL;
}
return new ListKeyObject(keystr, score, db);
}
case SET_ELEMENT:
{
SetKeyObject* sk = new SetKeyObject(keystr, Slice(), db);
if (!decode_value(buf, sk->value, false))
{
DELETE(sk);
return sk;
}
return sk;
}
case ZSET_ELEMENT:
{
ZSetKeyObject* zsk = new ZSetKeyObject(keystr, Slice(), 0, db);
double score;
if (!BufferHelper::ReadFixDouble(buf, score)
|| !decode_value(buf, zsk->value))
{
DELETE(zsk);
return NULL;
}
zsk->score = score;
return zsk;
}
case ZSET_ELEMENT_SCORE:
{
ZSetScoreKeyObject* zsk = new ZSetScoreKeyObject(keystr,
Slice(), db);
if (!decode_value(buf, zsk->value))
{
DELETE(zsk);
return NULL;
}
return zsk;
}
case TABLE_INDEX:
{
Slice kname;
if (!BufferHelper::ReadVarSlice(buf, kname))
{
return NULL;
}
TableIndexKeyObject* ik = new TableIndexKeyObject(keystr, kname,
ValueObject(), db);
if (!decode_value(buf, ik->colvalue))
{
DELETE(ik);
return NULL;
}
uint32 len;
if (!BufferHelper::ReadVarUInt32(buf, len))
{
DELETE(ik);
return NULL;
}
for (uint32 i = 0; i < len; i++)
{
ValueObject v;
if (!decode_value(buf, v))
{
DELETE(ik);
return NULL;
}
ik->index.push_back(v);
}
return ik;
}
case TABLE_COL:
{
TableColKeyObject* tk = new TableColKeyObject(keystr, Slice(),
db);
Slice col;
if (!BufferHelper::ReadVarSlice(buf, col))
{
DELETE(tk);
return NULL;
}
tk->colname = col;
uint32 len;
if (!BufferHelper::ReadVarUInt32(buf, len))
{
DELETE(tk);
return NULL;
}
for (uint32 i = 0; i < len; i++)
{
ValueObject v;
if (!decode_value(buf, v))
{
DELETE(tk);
return NULL;
}
tk->index.push_back(v);
}
return tk;
}
case BITSET_ELEMENT:
{
uint64 index;
if (!BufferHelper::ReadVarUInt64(buf, index))
{
return NULL;
}
return new BitSetKeyObject(keystr, index, db);
}
case KEY_EXPIRATION_ELEMENT:
{
uint64 ts;
if (!BufferHelper::ReadVarUInt64(buf, ts))
{
return NULL;
}
return new ExpireKeyObject(keystr, ts, db);
}
case SET_META:
case ZSET_META:
case LIST_META:
case TABLE_META:
case TABLE_SCHEMA:
case BITSET_META:
case KEY_EXPIRATION_MAPPING:
case KV:
case SCRIPT:
default:
{
return new KeyObject(keystr, (KeyType) type, db);
}
}
}
