public RedisBool HMSet(RedisParam key, Hashtable values) { if (key.IsNull) { throw new ArgumentNullException("key"); } if (values.IsEmpty()) { throw new ArgumentNullException("values"); } ValidateNotDisposed(); var parameters = new byte[1 + (2 * values.Count)][]; parameters[0] = key; var i = 1; foreach (DictionaryEntry de in values) { parameters[i++] = de.Key.ToBytes(); parameters[i++] = de.Value.ToBytes(); } return(ExpectOK(RedisCommandList.HMSet, parameters)); }
public RedisBool HMSet(RedisParam key, RedisParam field, RedisParam value, RedisParam[] fields = null, RedisParam[] values = null) { if (key.IsNull) { throw new ArgumentNullException("key"); } if (field.IsEmpty) { throw new ArgumentNullException("field"); } ValidateNotDisposed(); if (value.Length > RedisConstants.MaxValueLength) { throw new ArgumentException("value is limited to 1GB", "value"); } if (fields.Length > 0) { if (values == null || values.Length != fields.Length) { throw new ArgumentException("Field and values length does not match", "field"); } var parameters = key .Join(field) .Join(value) .Join(fields.Merge(values)); return(ExpectOK(RedisCommandList.HMSet, parameters)); } return(ExpectOK(RedisCommandList.HMSet, key, field, value)); }
public RedisBool Restore(RedisParam key, long ttl, RedisParam value) { ValidateNotDisposed(); ValidateKeyAndValue(key, value); return(ExpectOK(RedisCommandList.Rename, key, ttl.ToBytes(), value)); }
public RedisBool HMSet(RedisParam key, IDictionary <RedisParam, RedisParam> values) { if (key.IsNull) { throw new ArgumentNullException("key"); } if (values == null || values.Count == 0) { throw new ArgumentNullException("values"); } ValidateNotDisposed(); var parameters = new byte[1 + (2 * values.Count)][]; parameters[0] = key; var i = 1; foreach (var kvp in values) { parameters[i++] = kvp.Key; parameters[i++] = kvp.Value; } return(ExpectOK(RedisCommandList.HMSet, parameters)); }
public bool Watch(RedisParam key, params RedisParam[] keys) { ValidateNotDisposed(); if (Interlocked.Read(ref m_State) == (long)RedisBatchState.Executing) { throw new RedisException("Transaction is being executed", RedisErrorCode.ExecutionError); } var queue = m_WatchQ; if (queue == null) { queue = m_WatchQ = new ConcurrentQueue <RedisParam>(); } if (!key.IsEmpty) { queue.Enqueue(key); } var length = keys.Length; if (length > 0) { foreach (var k in keys) { if (!k.IsEmpty) { queue.Enqueue(k); } } } return(true); }
public RedisResult <IDictionary <string, string> > ConfigGet(RedisParam parameter) { if (parameter.IsNull) { throw new ArgumentNullException("parameter"); } var lines = ExpectMultiDataStrings(RedisCommandList.Config, RedisCommandList.Get, parameter.ToBytes()); if (lines != null) { var linesLength = lines.Length; if (lines.Length > 0) { var result = new Dictionary <string, string>(linesLength / 2); for (var i = 0; i < linesLength; i += 2) { var key = (lines[i] ?? String.Empty).Trim(); if (!key.IsEmpty()) { result[key] = (lines[i + 1] ?? String.Empty).Trim(); } } return(new RedisResult <IDictionary <string, string> >(result)); } } return(new RedisResult <IDictionary <string, string> >(null)); }
public RedisInteger GeoAdd(RedisParam key, RedisGeospatialItem member, params RedisGeospatialItem[] members) { if (key.IsEmpty) { throw new ArgumentNullException("key"); } if (member.IsEmpty) { throw new ArgumentNullException("member"); } if (members.IsEmpty()) { return(ExpectInteger(RedisCommandList.GeoAdd, key, member.Longitude.ToBytes(), member.Latitude.ToBytes(), member.Name.ToBytes())); } var parameters = key .Join(member.Longitude.ToBytes()) .Join(member.Latitude.ToBytes()) .Join(member.Name.ToBytes()); foreach (var m in members) { parameters = parameters .Join(m.Longitude.ToBytes()) .Join(m.Latitude.ToBytes()) .Join(m.Name.ToBytes()); } return(ExpectInteger(RedisCommandList.GeoAdd, parameters)); }
public RedisMultiBytes GeoHash(RedisParam key, RedisParam member, params RedisParam[] members) { if (key.IsEmpty) { throw new ArgumentNullException("key"); } if (member.IsEmpty) { throw new ArgumentNullException("member"); } if (members.IsEmpty()) { return(ExpectMultiDataBytes(RedisCommandList.GeoHash, key, member)); } var parameters = key.Join(member); foreach (var m in members) { if (!m.IsEmpty) { parameters = parameters.Join(m); } } return(ExpectMultiDataBytes(RedisCommandList.GeoHash, parameters)); }
public RedisScanStrings HScanString(RedisParam key, ulong cursor = 0uL, int count = 10, RedisParam?match = null) { if (key.IsNull) { throw new ArgumentNullException("key"); } ValidateNotDisposed(); var parameters = new byte[][] { key.Data, cursor.ToBytes() }; if (match.HasValue) { var value = match.Value; if (!value.IsEmpty) { parameters = parameters.Join(RedisCommandList.Match); parameters = parameters.Join(value.Data); } } if (count > 0) { parameters = parameters.Join(RedisCommandList.Count); parameters = parameters.Join(count.ToBytes()); } return(RedisCommandUtils.ToScanStrings(ExpectArray(RedisCommandList.HScan, parameters))); }
public void UnregisterSubscription(RedisParam channel, Action <RedisPubSubMessage> callback) { lock (m_SubscriptionLock) { m_PendingSubscriptions.Unregister(channel, callback); m_Subscriptions.Unregister(channel, callback); } }
public RedisString Ping(RedisParam msg) { if (msg.IsEmpty) { return(ExpectSimpleString(RedisCommandList.Ping)); } return(ExpectBulkString(RedisCommandList.Ping, msg)); }
public RedisBool LInsert(RedisParam key, bool insertBefore, RedisParam pivot, RedisParam value) { ValidateKeyAndValue(key, value); var prePost = insertBefore ? RedisCommandList.Before : RedisCommandList.After; return(ExpectOK(RedisCommandList.LInsert, key, prePost, pivot, value)); }
public RedisString GetRangeString(RedisParam key, int start, int end) { if (key.IsEmpty) { throw new ArgumentNullException("key"); } return(ExpectBulkString(RedisCommandList.GetRange, key, start.ToBytes(), end.ToBytes())); }
public RedisDouble IncrByFloat(RedisParam key, double increment) { if (key.IsEmpty) { throw new ArgumentNullException("key"); } return(ExpectDouble(RedisCommandList.IncrBy, key, increment.ToBytes())); }
public RedisInteger HLen(RedisParam key) { if (key.IsNull) { throw new ArgumentNullException("key"); } return(ExpectInteger(RedisCommandList.HLen, key)); }
public RedisMultiString BRPopString(RedisParam key, int timeout) { if (key.IsNull) { throw new ArgumentNullException("key"); } return(ExpectMultiDataStrings(RedisCommandList.BRPop, key, timeout.ToBytes())); }
public RedisString RPopString(RedisParam key) { if (key.IsNull) { throw new ArgumentNullException("key"); } return(ExpectBulkString(RedisCommandList.RPop, key)); }
public RedisBool LTrim(RedisParam key, int start, int end) { if (key.IsNull) { throw new ArgumentNullException("key"); } return(ExpectOK(RedisCommandList.LTrim, key, start.ToBytes(), end.ToBytes())); }
public RedisInteger Decr(RedisParam key) { if (key.IsEmpty) { throw new ArgumentNullException("key"); } return(ExpectInteger(RedisCommandList.Decr, key)); }
public RedisString LIndexString(RedisParam key, int index) { if (key.IsNull) { throw new ArgumentNullException("key"); } return(ExpectBulkString(RedisCommandList.LIndex, key, index.ToBytes())); }
public RedisInteger SetBit(RedisParam key, int offset, int value) { if (key.IsEmpty) { throw new ArgumentNullException("key"); } return(ExpectInteger(RedisCommandList.SetBit, key, offset.ToBytes(), value.ToBytes())); }
public RedisMultiString HValStrings(RedisParam key) { if (key.IsNull) { throw new ArgumentNullException("key"); } return(ExpectMultiDataStrings(RedisCommandList.HVals, key)); }
public RedisBytes Get(RedisParam key) { if (key.IsEmpty) { throw new ArgumentNullException("key"); } return(ExpectBulkStringBytes(RedisCommandList.Get, key)); }
public RedisInteger DecrBy(RedisParam key, long count) { if (key.IsEmpty) { throw new ArgumentNullException("key"); } return(ExpectInteger(RedisCommandList.DecrBy, key, count.ToBytes())); }
public RedisMultiString Keys(RedisParam pattern) { if (pattern.IsNull) { throw new ArgumentNullException("pattern"); } return(ExpectMultiDataStrings(RedisCommandList.Keys, pattern)); }
public RedisMultiString LRangeString(RedisParam key, int start, int end) { if (key.IsNull) { throw new ArgumentNullException("key"); } return(ExpectMultiDataStrings(RedisCommandList.LRange, key, start.ToBytes(), end.ToBytes())); }
public RedisBool Auth(RedisParam password) { if (password.IsEmpty) { throw new ArgumentNullException("password"); } return(ExpectOK(RedisCommandList.Auth, password)); }
public RedisInteger BitCount(RedisParam key, int start, int end) { if (key.IsEmpty) { throw new ArgumentNullException("key"); } return(ExpectInteger(RedisCommandList.BitCount, key, start.ToBytes(), end.ToBytes())); }
public RedisMultiBytes HGetAll(RedisParam key) { if (key.IsNull) { throw new ArgumentNullException("key"); } return(ExpectMultiDataBytes(RedisCommandList.HGetAll, key)); }
public RedisString Echo(RedisParam msg) { if (msg.IsNull) { throw new ArgumentNullException("msg"); } return(ExpectBulkString(RedisCommandList.Echo, msg)); }