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); } } }