Comment faire fonctionner Redis via le script Lua en langage Go

Avant-propos

Afin de réduire le coût de communication avec Redis dans une de mes bibliothèques de base, j'ai encapsulé une série d'opérations dans un script LUA et utilisé la commande EVAL fournie par Redis pour simplifier les opérations.

Fonctionnalités qu'EVAL peut fournir :

• Vous pouvez encapsuler plusieurs opérations dans un script LUA S'il y a plusieurs instructions Redis, après l'encapsulation, il vous suffit d'envoyer tous les paramètres à Redis en même temps pour obtenir le résultat.

• Redis peut garantir qu'aucune autre commande ne sera insérée et exécutée pendant l'exécution du script Lua, fournissant une atomicité comme les transactions de base de données

• Redis mettra en cache le script en fonction de la valeur SHA du script en cache. n'a pas besoin de transmettre à nouveau le code Lua. Les coûts de communication sont réduits. De plus, si vous modifiez le script Lua dans votre propre code, Redis utilisera certainement le dernier code lors de l'exécution.

Importez des bibliothèques Go courantes telles que "github.com/go-redis/redis" pour implémenter le code suivant.

Générer un script Lua

// KEYS: key for record
// ARGV: fieldName, currentUnixTimestamp, recordTTL
// Update expire field of record key to current timestamp, and renew key expiration
var updateRecordExpireScript = redis.NewScript(`
redis.call("EXPIRE", KEYS[1], ARGV[3])
redis.call("HSET", KEYS[1], ARGV[1], ARGV[2])
return 1
`)

Lorsque cette variable est créée, le code Lua ne sera pas exécuté et il n'est pas nécessaire d'avoir une connexion Redis existante.

La prise en charge du script Lua fournie par Redis comporte deux tableaux, KEYS et ARGV, par défaut. KEYS représente plusieurs valeurs de clé transmises lors de l'exécution du script, et ARGV représente plusieurs paramètres transmis. Étant donné que le code Lua doit rester concis et difficile à lire, il est préférable d'écrire quelques commentaires pour ces paramètres

Remarque :Le code ci-dessus utilise `` sur les lignes même si la ligne où ` est laissée est vide. et entre, cela sera considéré comme une ligne, ne lisez pas le mauvais numéro de ligne de code lorsque vous signalez une erreur.

Exécuter un script Lua

 updateRecordExpireScript.Run(c.Client, []string{recordKey(key)}, 
         expireField,
         time.Now().UTC().UnixNano(), int64(c.opt.RecordTTL/time.Second)).Err()

Lors de l'exécution, Run essaiera d'abord d'exécuter le script via le cache via EVALSHA. S'il n'y a pas de cache, utilisez EVAL pour l'exécuter, puis l'intégralité du script Lua sera transmise à Redis.

Limitations des scripts Lua

• Redis ne fournit pas l'introduction de packages supplémentaires, tels que os, etc. Seul le package redis est disponible.

• Le script Lua s'exécutera dans une fonction, toutes les variables doivent être déclarées en utilisant local

• return Lorsque plusieurs valeurs sont renvoyées, Redis ne vous donnera que la première

Restrictions de type dans les scripts

• Lorsque le script renvoie zéro, ce que vous obtenez dans Go est err = redis.Nil (le même que Get ne trouve pas la valeur) err = redis.Nil（与Get找不到值相同）

• 脚本返回false时，Go中得到的是nil，脚本返回true时，Go中得到的是int64类型的1

• 脚本返回{"ok": ...}时，Go中得到的是redis的status类型（true/false)

• 脚本返回{"err": ...}时，Go中得到的是err值，也可以通过return redis.error_reply("My Error")

• Lorsque le script renvoie faux, qu'est-ce que vous obtenez dans Go est nul, lorsque le script renvoie vrai, Go obtient le type int64 1

• Lorsque le script renvoie {"ok": ...}, Go obtient le type de statut redis (vrai/faux)

Lorsque le script renvoie {"err": ...}, la valeur de l'erreur est obtenue dans Go. Elle peut également être obtenue par return redis.error_reply("My Error")

.

Le script renvoie le type numérique, ce qui est obtenu dans Go est le type int64

Dans le script, si vous devez convertir la valeur dans les KEYS/ARGV entrants du type chaîne au type numérique, vous devez utiliser le fonction to_number

🎜🎜Si Que se passe-t-il si le script s'exécute pendant une longue période ? 🎜🎜🎜Pendant l'exécution du script Lua, afin d'éviter la contamination des données par d'autres opérations, d'autres commandes ne peuvent pas être exécutées pendant cette période, et les autres requêtes ne peuvent pas être poursuivies jusqu'à ce que l'exécution soit terminée. Lorsque le temps d'exécution du script Lua dépasse la limite de temps lua, les autres requêtes recevront des erreurs Busy, sauf si ces requêtes sont SCRIPT KILL (tuer le script) ou SHUTDOWN NOSAVE (fermer Redis sans enregistrer les résultats) 🎜🎜Plus de contenu Reportez-vous à ce qui suit Ici, je fournis principalement quelques résumés basés sur mon expérience dans l'utilisation de Go. https://redis.io/commands/eval🎜🎜Un script plus "complexe", qui nécessite que lors de l'obtention d'une valeur clé, si la valeur est accédée plus souvent, le cycle de vie sera prolongé. De plus, le temps de mise à jour doit être comparé. Si aucune mise à jour n'est requise, la valeur obtenue sera renvoyée directement, sinon redis.Nil sera renvoyé🎜🎜

// KEYS: rec:key, key
// ARGV: currentUnixTimestamp, hotHit, recordTTL, ttl
// When there's a hit,
var fetchRecordScript = redis.NewScript(local value = redis.call("GET", KEYS[2]) if(value == nil) then return nil end local hit = redis.call("HINCRBY", KEYS[1], "hit", 1) redis.call("EXPIRE", KEYS[1], ARGV[3]) local minHotHit = tonumber(ARGV[2]) local keyTTL = tonumber(ARGV[4]) if(hit > minHotHit)then keyTTL = keyTTL * 2 end redis.call("EXPIRE", KEYS[2], keyTTL) local expire = tonumber(redis.call("HGET", KEYS[1], "expire")) local unixTime = tonumber(ARGV[1]) if(expire == nil or expire < unixTime) then return nil else return value end)
// KEYS: key for record
// ARGV: fieldName, currentUnixTimestamp, recordTTL
// Update expire field of record key to current timestamp, and renew key expiration
var updateRecordExpireScript = redis.NewScript(redis.call("EXPIRE", KEYS[1], ARGV[3]) redis.call("HSET", KEYS[1], ARGV[1], ARGV[2]) return 1)

.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!