public void LuaScriptPrefixedKeys()
{
const string Script = "redis.call('set', @key, @value)";
var prepared = LuaScript.Prepare(Script);
var key = Me();
var p = new { key = (RedisKey)key, value = "hello" };
// no super clean way to extract this; so just abuse InternalsVisibleTo
prepared.ExtractParameters(p, "prefix-", out RedisKey[] keys, out RedisValue[] args);
public static RedisResult DoEvalSetOnLargeString()
{
var db = GetDatabase();
const string script = "redis.call('set', @key, @value)";
var uniqueKeyText = Guid.NewGuid().ToString();
var prepared = LuaScript.Prepare(script);
return(db.ScriptEvaluate(prepared, new { key = (RedisKey)uniqueKeyText, value = ReallyBigString }));
}
public void Simple()
{
using (var conn = Create())
{
var key = Me();
var session = new ProfilingSession();
conn.RegisterProfiler(() => session);
var dbId = TestConfig.GetDedicatedDB();
var db = conn.GetDatabase(dbId);
db.StringSet(key, "world");
var result = db.ScriptEvaluate(LuaScript.Prepare("return redis.call('get', @key)"), new { key = (RedisKey)key });
Assert.Equal("world", result.AsString());
var val = db.StringGet(key);
Assert.Equal("world", (string)val);
var s = (string)db.Execute("ECHO", "fii");
Assert.Equal("fii", s);
var cmds = session.FinishProfiling();
var i = 0;
foreach (var cmd in cmds)
{
Log("Command {0} (DB: {1}): {2}", i++, cmd.Db, cmd.ToString().Replace("\n", ", "));
}
var all = string.Join(",", cmds.Select(x => x.Command));
Assert.Equal("SET,EVAL,GET,ECHO", all);
Log("Checking for SET");
var set = cmds.SingleOrDefault(cmd => cmd.Command == "SET");
Assert.NotNull(set);
Log("Checking for GET");
var get = cmds.SingleOrDefault(cmd => cmd.Command == "GET");
Assert.NotNull(get);
Log("Checking for EVAL");
var eval = cmds.SingleOrDefault(cmd => cmd.Command == "EVAL");
Assert.NotNull(eval);
Log("Checking for ECHO");
var echo = cmds.SingleOrDefault(cmd => cmd.Command == "ECHO");
Assert.NotNull(echo);
Assert.Equal(4, cmds.Count());
Assert.True(set.CommandCreated <= eval.CommandCreated);
Assert.True(eval.CommandCreated <= get.CommandCreated);
AssertProfiledCommandValues(set, conn, dbId);
AssertProfiledCommandValues(get, conn, dbId);
AssertProfiledCommandValues(eval, conn, dbId);
AssertProfiledCommandValues(echo, conn, dbId);
}
}
public static void ClearKeys(this IRedisDBConnect redis, string keypattern)
{
redis.GetDatabase().ScriptEvaluate(LuaScript.Prepare(
" local ks = redis.call('KEYS', @keypattern) " +
" for i=1,#ks,5000 do " +
" redis.call('del', unpack(ks, i, math.min(i+4999, #ks))) " +
" end " +
" return true "
), new { keypattern = keypattern });
}
private LoadedLuaScript LoadLuaScriptForGetRule(string scriptUrl)
{
string script = File.ReadAllText(scriptUrl);
LuaScript luaScript = LuaScript.Prepare(script);
var endpoints = Connection.GetEndPoints();
var endpoint = endpoints[0];
IServer server = Connection.GetServer(endpoint);
return(luaScript.Load(server));
}
/// <summary>
/// 模糊查询key的集合
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public string[] ScriptEvaluateKeys(string key)
{
var redisResult = database.ScriptEvaluate(LuaScript.Prepare(
//Redis的keys模糊查询：
" local res = redis.call('KEYS', @keypattern) " +
" return res "), new { @keypattern = key });
string[] preSult = (string[])redisResult;//将返回的结果集转为数组
return(preSult);
}
/// <summary>
/// 删除指定通配的所有key
/// </summary>
/// <param name="pattern"></param>
public void RemoveAllByScript(string pattern)
{
var keys = new List <string>();
var redisResult = _database.ScriptEvaluateAsync(LuaScript.Prepare(@" local res = redis.call('KEYS', @keypattern) " + " return res "), new { @keypattern = pattern + "*" }).GetAwaiter().GetResult();
if (!redisResult.IsNull)
{
_database.KeyDelete((RedisKey[])redisResult);
}
}
public static bool SetId(string id, double latitude, double longitude)
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect(ConnectionString);
IDatabase db = redis.GetDatabase();
var prepared = LuaScript.Prepare(_setScript);
var result = db.ScriptEvaluate(prepared, new { key = (RedisKey)_redisKey, value1 = longitude, value2 = latitude, value3 = id });
return(true);
}
/// <summary> 批量更新 </summary>
/// <typeparam name="T"></typeparam>
/// <param name="database"></param>
/// <param name="pattern"></param>
/// <param name="value"></param>
/// <returns></returns>
public static async Task BatchUpdateAsync <T>(this IDatabase database, string pattern, T value)
{
await database.ScriptEvaluateAsync(LuaScript.Prepare(
" local ks = redis.call('KEYS', @keypattern) " +
" for i=1,#ks do " +
" redis.call('set', ks[i], @value) " +
" end " +
" return true "),
new { keypattern = pattern, value = Serialize(value) });
}
public void SuccessfulCommandTestWithKey(string value)
{
var connectionOptions = new ConfigurationOptions
{
AbortOnConnectFail = true,
};
connectionOptions.EndPoints.Add(RedisEndPoint);
using var connection = ConnectionMultiplexer.Connect(connectionOptions);
var db = connection.GetDatabase();
db.KeyDelete("key1");
var activityProcessor = new Mock <BaseProcessor <Activity> >();
var sampler = new TestSampler();
using (Sdk.CreateTracerProviderBuilder()
.AddProcessor(activityProcessor.Object)
.SetSampler(sampler)
.AddRedisInstrumentation(connection, c => c.SetVerboseDatabaseStatements = true)
.Build())
{
var prepared = LuaScript.Prepare("redis.call('set', @key, @value)");
db.ScriptEvaluate(prepared, new { key = (RedisKey)"mykey", value = 123 });
var redisValue = db.StringGet("key1");
Assert.False(redisValue.HasValue);
bool set = db.StringSet("key1", value, TimeSpan.FromSeconds(60));
Assert.True(set);
redisValue = db.StringGet("key1");
Assert.True(redisValue.HasValue);
Assert.Equal(value, redisValue.ToString());
}
// Disposing SDK should flush the Redis profiling session immediately.
Assert.Equal(11, activityProcessor.Invocations.Count);
var scriptActivity = (Activity)activityProcessor.Invocations[1].Arguments[0];
Assert.Equal("EVAL", scriptActivity.DisplayName);
Assert.Equal("EVAL redis.call('set', ARGV[1], ARGV[2])", scriptActivity.GetTagValue(SemanticConventions.AttributeDbStatement));
VerifyActivityData((Activity)activityProcessor.Invocations[3].Arguments[0], false, connection.GetEndPoints()[0], true);
VerifyActivityData((Activity)activityProcessor.Invocations[5].Arguments[0], true, connection.GetEndPoints()[0], true);
VerifyActivityData((Activity)activityProcessor.Invocations[7].Arguments[0], false, connection.GetEndPoints()[0], true);
VerifySamplingParameters(sampler.LatestSamplingParameters);
}
/// <summary>
/// 使用lua脚本模糊查询key后批量删除
/// </summary>
/// <param name="pattern"></param>
public static void DeleteKeys(string pattern)
{
db.ScriptEvaluate(LuaScript.Prepare(
//Redis的keys模糊查询：
" local ks = redis.call('KEYS', @keypattern) " + //local ks为定义一个局部变量，其中用于存储获取到的keys
" for i=1,#ks,5000 do " + //#ks为ks集合的个数, 语句的意思： for(int i = 1; i <= ks.Count; i+=5000)
" redis.call('del', unpack(ks, i, math.min(i+4999, #ks))) " + //Lua集合索引值从1为起始，unpack为解包，获取ks集合中的数据，每次5000，然后执行删除
" end " +
" return true "),
new { keypattern = pattern + "*" });
}
public string[] GetAllJSONKeysBySlideId(string value)
{
string script = "local data = redis.call('keys', '*" + value + "') " +
"local result = {} " +
"for i, item in ipairs(data) do " +
"result[i] = redis.call('json.get', data[i]) end " +
"return result ";
LuaScript prepared = LuaScript.Prepare(script);
return((string[])this.m_DataBase.ScriptEvaluate(prepared));
}
private async Task CreateScriptsOnAllServers()
{
var luaScript = LuaScript.Prepare(Lua.PublishLatest);
foreach (var endpoint in _connection.GetEndPoints())
{
var hostname = GetServerHostnameAndPort(endpoint);
var server = _connection.GetServer(hostname);
_publishLatestScript = await luaScript.LoadAsync(server).ConfigureAwait(false);
}
}
public string[] GetAllStrings()
{
string script = "local data = redis.call('keys', '*') " +
"local result = {} " +
"for i, item in ipairs(data) do " +
"result[i] = data[i] .. ' ' .. redis.call('Get', data[i]) " +
"end " +
"return result ";
LuaScript prepared = LuaScript.Prepare(script);
return((string[])this.m_DataBase.ScriptEvaluate(prepared));
}
public RedisResult[] GetAllHashes()
{
string script = "local data = redis.call('keys', '*') " +
"local result = {} " +
"for i, item in ipairs(data) do " +
"result[i] = redis.call('HGetAll', data[i]) " +
"end " +
"return result ";
LuaScript prepared = LuaScript.Prepare(script);
return((RedisResult[])this.m_DataBase.ScriptEvaluate(prepared));
}
/// <summary>
/// 获取指定通配的所有key
/// </summary>
/// <param name="pattern"></param>
/// <returns></returns>
public IList <string> GetAllKeysByScript(string pattern)
{
var keys = new List <string>();
var redisResult = _database.ScriptEvaluateAsync(LuaScript.Prepare(@" local res = redis.call('KEYS', @keypattern) " + " return res "), new { @keypattern = pattern + "*" }).GetAwaiter().GetResult();
if (!redisResult.IsNull)
{
keys.AddRange((string[])redisResult);
}
return(keys);
}
/// <summary>
/// 模糊搜索Keys
/// </summary>
/// <param name="keyPattern"></param>
/// <returns></returns>
internal string[] KeySearch(string keyPattern)
{
var script = "return redis.call('keys',@pattern)";
var prepared = LuaScript.Prepare(script);
var redisResult = _db.ScriptEvaluate(prepared, new { pattern = keyPattern });
if (redisResult.IsNull)
{
return(new string[0]);
}
return((string[])redisResult);
}
/// <summary>
/// 判断是否存在包含keyPattern的key
/// </summary>
/// <param name="keyPattern"></param>
/// <returns></returns>
public void ExistPatternKey(string keyPattern)
{
RedisHelper.Manager.GetDatabase().ScriptEvaluate(LuaScript.Prepare(
//Redis的keys模糊查询：
" local ks = redis.call('KEYS', @keypattern) " + //local ks为定义一个局部变量，其中用于存储获取到的keys
" for i=1,#ks,5000 do " + //#ks为ks集合的个数, 语句的意思： for(int i = 1; i <= ks.Count; i+=5000)
" redis.call('del', unpack(ks, i, math.min(i+4999, #ks))) " + //Lua集合索引值从1为起始，unpack为解包，获取ks集合中的数据，每次5000，然后执行删除
" end " +
" return true "
),
new { keypattern = keyPattern });
}
public async Task <List <string> > GetKeysAsync(string likeKey)
{
if (likeKey.IsNullOrEmpty())
{
throw new QKException("Redis Key 不能为空");
}
const string Script = "return redis.call('KEYS', @key)";
var prepared = LuaScript.Prepare(Script);
var result = (string[])await Db.ScriptEvaluateAsync(prepared, new { key = likeKey + "*" });
return(result.ToList());
}
/// <inheritdoc />
public async Task Init(CancellationToken cancellationToken)
{
var timer = Stopwatch.StartNew();
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
var initMsg = string.Format("Init: Name={0} ServiceId={1} DatabaseNumber={2} UseJson={3} DeleteOnClear={4}",
_name, _serviceId, _options.DatabaseNumber, _options.UseJson, _options.DeleteOnClear);
_logger.LogDebug($"RedisGrainStorage {_name} is initializing: {initMsg}");
}
_redisOptions = ConfigurationOptions.Parse(_options.ConnectionString);
_connection = await ConnectionMultiplexer.ConnectAsync(_redisOptions);
if (_options.DatabaseNumber.HasValue)
{
_db = _connection.GetDatabase(_options.DatabaseNumber.Value);
}
else
{
_db = _connection.GetDatabase();
}
_preparedWriteScript = LuaScript.Prepare(_writeScript);
var loadTasks = new Task[_redisOptions.EndPoints.Count];
for (int i = 0; i < _redisOptions.EndPoints.Count; i++)
{
var endpoint = _redisOptions.EndPoints.ElementAt(i);
var server = _connection.GetServer(endpoint);
loadTasks[i] = _preparedWriteScript.LoadAsync(server);
}
await Task.WhenAll(loadTasks);
if (_logger.IsEnabled(LogLevel.Debug))
{
timer.Stop();
_logger.LogDebug("Init: Name={0} ServiceId={1}, initialized in {2} ms",
_name, _serviceId, timer.Elapsed.TotalMilliseconds.ToString("0.00"));
}
}
catch (Exception ex)
{
timer.Stop();
_logger.LogError(ex, "Init: Name={0} ServiceId={1}, errored in {2} ms. Error message: {3}",
_name, _serviceId, timer.Elapsed.TotalMilliseconds.ToString("0.00"), ex.Message);
throw ex;
}
}
/// <summary>
/// Prepares the scripts.
/// </summary>
/// <param name="server">The server.</param>
/// <exception cref="System.ArgumentNullException">server</exception>
private void PrepareScripts(IServer server)
{
if (server == null)
{
throw new ArgumentNullException("server");
}
const string deleteKeyPrefixScript = "local keys = redis.call('keys', ARGV[1]) for i=1,#keys,5000 do redis.call('del', unpack(keys, i, math.min(i+4999, #keys))) end return keys";
LuaScript deleteKeyPrefixPreparedScript = LuaScript.Prepare(deleteKeyPrefixScript);
_deleteKeyPrefixScript = deleteKeyPrefixPreparedScript.Load(server);
}
public void PurgeLuaScriptCache()
{
const string Script = "redis.call('set', @PurgeLuaScriptCacheKey, @PurgeLuaScriptCacheValue)";
var first = LuaScript.Prepare(Script);
var fromCache = LuaScript.Prepare(Script);
Assert.IsTrue(object.ReferenceEquals(first, fromCache));
LuaScript.PurgeCache();
var shouldBeNew = LuaScript.Prepare(Script);
Assert.IsFalse(object.ReferenceEquals(first, shouldBeNew));
}
public void SimpleLua()
{
// ARRANGe
const string Script = "redis.call('set', @key, @value)";
var prepared = LuaScript.Prepare(Script);
// ACT
db.ScriptEvaluate(prepared, new { key = (RedisKey)"mykey", value = 123 });
// ASSERT
var value = db.StringGet("mykey");
Assert.AreEqual("123", value.ToString());
}
/// <summary>
/// 模糊删除key
/// </summary>
/// <param name="pattern"></param>
public static RedisResult KeyBatchDelete(string pattern)
{
pattern = MergeKey(pattern);
return(GetDatabase().ScriptEvaluate(LuaScript.Prepare(
//Redis的keys模糊查询：
" local ks = redis.call('KEYS', @keypattern) " + //local ks为定义一个局部变量，其中用于存储获取到的keys
" for i=1,#ks,5000 do " + //#ks为ks集合的个数, 语句的意思： for(int i = 1; i <= ks.Count; i+=5000)
" redis.call('del', unpack(ks, i, math.min(i+4999, #ks))) " + //Lua集合索引值从1为起始，unpack为解包，获取ks集合中的数据，每次5000，然后执行删除
" end " +
" return true "
),
new { keypattern = pattern }));//mykey*
}
/// <summary> 批量删除 </summary>
/// <param name="database"></param>
/// <param name="pattern"></param>
/// <param name="batch">批次</param>
/// <returns></returns>
public static async Task BatchDeleteAsync(this IDatabase database, string pattern, int batch = 5000)
{
await database.ScriptEvaluateAsync(LuaScript.Prepare(
" local ks = redis.call('KEYS', @keypattern) " +
" for i=1,#ks,@batch do " +
" redis.call('del', unpack(ks, i, math.min(i+@batch-1, #ks))) " + //Lua集合索引值从1为起始，unpack为解包，获取ks集合中的数据，每次5000，然后执行删除
" end " +
" return true "), new
{
keypattern = pattern,
batch
});
}
public void SimpleLoadedLuaScript()
{
const string Script = "return @ident";
using (var conn = Create(allowAdmin: true))
{
Skip.IfMissingFeature(conn, nameof(RedisFeatures.Scripting), f => f.Scripting);
var server = conn.GetServer(TestConfig.Current.PrimaryServerAndPort);
server.ScriptFlush();
var prepared = LuaScript.Prepare(Script);
var loaded = prepared.Load(server);
var db = conn.GetDatabase();
{
var val = loaded.Evaluate(db, new { ident = "hello" });
Assert.Equal("hello", (string)val);
}
{
var val = loaded.Evaluate(db, new { ident = 123 });
Assert.Equal(123, (int)val);
}
{
var val = loaded.Evaluate(db, new { ident = 123L });
Assert.Equal(123L, (long)val);
}
{
var val = loaded.Evaluate(db, new { ident = 1.1 });
Assert.Equal(1.1, (double)val);
}
{
var val = loaded.Evaluate(db, new { ident = true });
Assert.True((bool)val);
}
{
var val = loaded.Evaluate(db, new { ident = new byte[] { 4, 5, 6 } });
Assert.True(new byte[] { 4, 5, 6 }.SequenceEqual((byte[])val));
}
{
var val = loaded.Evaluate(db, new { ident = new ReadOnlyMemory <byte>(new byte[] { 4, 5, 6 }) });
Assert.True(new byte[] { 4, 5, 6 }.SequenceEqual((byte[])val));
}
}
}
internal Consumer(RingBuffer queue, ConsumerOptions options = null)
{
Queue = queue;
if (options == null)
{
options = new ConsumerOptions();
}
_options = options;
_subscriptionPositionKey = Queue.DbKey.GetSubscriptionKey(_options.SubscriptionId);
_script = LuaScript.Prepare(ScriptPreprocessor(File.ReadAllText("Scripts/consume.lua"))).Load(Queue.Server);
}
private LoadedLuaScript LoadScript(string script)
{
var preparedScript = LuaScript.Prepare(script);
LoadedLuaScript loadedScript = null;
// load script on all servers
// note: only need to store single instance of loaded script as it is a wrapper around the original prepared script
foreach (var server in _redis.Value.GetEndPoints().Select(x => _redis.Value.GetServer(x)))
{
loadedScript = preparedScript.Load(server);
}
return(loadedScript);
}
/// <summary>
/// 查百科
/// </summary>
/// <param name="question">关键词</param>
/// <returns></returns>
public void GetWiki(string question, IMessageBuilder builder)
{
try
{
if (_db.KeyType(question).Equals(RedisType.String))
{
builder.AddPlainMessage(_db.StringGet(question));
}
else if (_db.KeyType(question).Equals(RedisType.Hash))
{
RedisValue[] kv = _db.HashValues(question);
foreach (var item in kv)
{
var answer = JsonConvert.DeserializeObject <MsgModel>(item);
if (answer.type == PlainMessage.MsgType)
{
builder.AddPlainMessage(answer.content);
}
else if (answer.type == ImageMessage.MsgType)
{
builder.AddImageMessage(url: answer.content);
}
}
}
else
{
//未找到的提示信息
builder.AddPlainMessage(string.Format(_command["WikiCommand:NotFound"], _command["WikiCommand:Add"]) + "\r\n");
#region 相似词汇提醒
//redis模糊查询， redis-cli:keys *{question}*
var redisResult = _db.ScriptEvaluate(LuaScript.Prepare(
//Redis的keys模糊查询：
" local res = redis.call('KEYS', @keypattern) return res "), new { @keypattern = $"*{question}*" });
if (!redisResult.IsNull)
{
builder.AddPlainMessage("===以下为相似关键词===\r\n");
foreach (var dic in (string[])redisResult)
{
builder.AddPlainMessage($" {dic}\r\n");
}
}
#endregion
}
}
catch
{
}
}
public List <string> SetScan(string key, int cursor, string pattern, int count)
{
List <string> list = new List <string>();
var result = db.ScriptEvaluate(LuaScript.Prepare("return redis.call('SSCAN',@key,@cursor,'MATCH',@pattern,'COUNT',@count)"), new { key = key, cursor = cursor, pattern = pattern, count = count });
if (!result.IsNull)
{
var vals = ((StackExchange.Redis.RedisResult[])((StackExchange.Redis.RedisResult[])result)[1]);
foreach (var item in vals)
{
list.Add(item.ToString());
}
}
return(list);
}
