redis操作
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

269 lines
4.3 KiB

  1. package redis
  2. import (
  3. "errors"
  4. redisdb "github.com/gomodule/redigo/redis"
  5. )
  6. /**
  7. * 集合成员数量
  8. */
  9. func ZCard(key interface{}) (int64, error) {
  10. c := GetConn()
  11. reply, err := c.Do("ZCARD", key)
  12. CloseConn(c)
  13. if err != nil {
  14. return 0, err
  15. } else {
  16. return redisdb.Int64(reply, nil)
  17. }
  18. }
  19. /*
  20. * 存值
  21. * key
  22. * member 成员
  23. * score 分值
  24. */
  25. func ZAdd(key string, score, member interface{}) (int64, error) {
  26. c := GetConn()
  27. reply, err := c.Do("ZADD", key, score, member)
  28. CloseConn(c)
  29. if err != nil {
  30. return 0, err
  31. } else {
  32. return redisdb.Int64(reply, nil)
  33. }
  34. }
  35. /*
  36. * 存值
  37. * key
  38. * member 成员
  39. * score 分值
  40. */
  41. func ZAddFloat(key string, score, member interface{}) (float64, error) {
  42. c := GetConn()
  43. reply, err := c.Do("ZADD", key, score, member)
  44. CloseConn(c)
  45. if err != nil {
  46. return 0, err
  47. } else {
  48. return redisdb.Float64(reply, nil)
  49. }
  50. }
  51. /*
  52. * 删除hash值
  53. */
  54. func ZRem(key, member interface{}) (int64, error) {
  55. c := GetConn()
  56. reply, err := c.Do("ZREM", key, member)
  57. CloseConn(c)
  58. if err != nil {
  59. return 0, err
  60. } else {
  61. return redisdb.Int64(reply, nil)
  62. }
  63. }
  64. /*
  65. * 区间数量
  66. * key
  67. * min/max 最小/最大值
  68. */
  69. func ZCount(key string, min, max interface{}) (int64, error) {
  70. c := GetConn()
  71. reply, err := c.Do("ZCOUNT", key, min, max)
  72. CloseConn(c)
  73. if err != nil {
  74. return 0, err
  75. } else {
  76. return redisdb.Int64(reply, nil)
  77. }
  78. }
  79. /*
  80. * 自增
  81. * key
  82. * member 成员
  83. * inc 分值
  84. */
  85. func ZIncrBy(key string, inc, member interface{}) (int64, error) {
  86. c := GetConn()
  87. reply, err := c.Do("ZINCRBY", key, inc, member)
  88. CloseConn(c)
  89. if err != nil {
  90. return 0, err
  91. } else {
  92. return redisdb.Int64(reply, nil)
  93. }
  94. }
  95. /*
  96. * 自增
  97. * key
  98. * member 成员
  99. * inc 分值
  100. */
  101. func ZIncrByFloat(key string, inc, member interface{}) (float64, error) {
  102. c := GetConn()
  103. reply, err := c.Do("ZINCRBY", key, inc, member)
  104. CloseConn(c)
  105. if err != nil {
  106. return 0, err
  107. } else {
  108. return redisdb.Float64(reply, nil)
  109. }
  110. }
  111. func ZRange(key string, start, stop int64) ([]map[string]string, error) {
  112. c := GetConn()
  113. defer CloseConn(c)
  114. values, err := redisdb.Values(c.Do("ZRANGE", key, start, stop, "WITHSCORES"))
  115. if err != nil {
  116. return nil, err
  117. }
  118. if len(values)%2 != 0 {
  119. return nil, errors.New("redigo: ZRange expects even number of values result")
  120. }
  121. var l []map[string]string
  122. for i := 0; i < len(values); i += 2 {
  123. key, okKey := values[i].([]byte)
  124. value, okValue := values[i+1].([]byte)
  125. if !okKey || !okValue {
  126. return nil, errors.New("redigo: ZRange key not a bulk string value")
  127. }
  128. l = append(l, map[string]string{
  129. "member": string(key),
  130. "score": string(value),
  131. })
  132. }
  133. return l, nil
  134. }
  135. func ZScan(key, field string, len int64) ([]string, error) {
  136. c := GetConn()
  137. defer CloseConn(c)
  138. zscanResult, err := redisdb.Values(c.Do("ZSCAN", key, "0", "MATCH", field, "COUNT", len))
  139. if err != nil {
  140. return nil, err
  141. }
  142. var cursor int
  143. var membersAndScores []string
  144. var member []string
  145. redisdb.Scan(zscanResult, &cursor, &membersAndScores)
  146. for i, v := range membersAndScores {
  147. if i%2 == 0 {
  148. member = append(member, v)
  149. }
  150. }
  151. return member, nil
  152. }
  153. /*
  154. * 回有序集合中指定成员的索引(从小到大排名)
  155. * key
  156. * member 成员
  157. */
  158. func ZRank(key string, member interface{}) (int64, error) {
  159. c := GetConn()
  160. reply, err := c.Do("ZRANK", key, member)
  161. CloseConn(c)
  162. if err != nil {
  163. return 0, err
  164. } else {
  165. return redisdb.Int64(reply, nil)
  166. }
  167. }
  168. /*
  169. * 有序集合中指定成员的索引(从大到小排名)
  170. * key
  171. * member 成员
  172. */
  173. func ZRevrank(key string, member interface{}) (int64, error) {
  174. c := GetConn()
  175. reply, err := c.Do("ZREVRANK", key, member)
  176. CloseConn(c)
  177. if err != nil {
  178. return 0, err
  179. } else {
  180. return redisdb.Int64(reply, nil)
  181. }
  182. }
  183. /*
  184. * 指定成员的分数
  185. * key
  186. * member 成员
  187. */
  188. func ZScore(key string, member interface{}) (float64, error) {
  189. c := GetConn()
  190. reply, err := c.Do("ZSCORE", key, member)
  191. CloseConn(c)
  192. if err != nil {
  193. return 0, err
  194. } else {
  195. return redisdb.Float64(reply, nil)
  196. }
  197. }
  198. /*
  199. * 指定成员的分数, 返回int64
  200. * key
  201. * member 成员
  202. */
  203. func ZScoreInt64(key string, member interface{}) (int64, error) {
  204. c := GetConn()
  205. reply, err := c.Do("ZSCORE", key, member)
  206. CloseConn(c)
  207. if err != nil {
  208. return 0, err
  209. } else {
  210. return redisdb.Int64(reply, nil)
  211. }
  212. }