test/unit/type/hash.tcl

   1 start_server default.conf {} {
   2     test {HSET/HLEN - Small hash creation} {
   3         array set smallhash {}
   4         for {set i 0} {$i < 8} {incr i} {
   5             set key [randstring 0 8 alpha]
   6             set val [randstring 0 8 alpha]
   7             if {[info exists smallhash($key)]} {
   8                 incr i -1
   9                 continue
  10             }
  11             r hset smallhash $key $val
  12             set smallhash($key) $val
  13         }
  14         list [r hlen smallhash]
  15     } {8}
  16
  17     test {Is the small hash encoded with a zipmap?} {
  18         r debug object smallhash
  19     } {*zipmap*}
  20
  21     test {HSET/HLEN - Big hash creation} {
  22         array set bighash {}
  23         for {set i 0} {$i < 1024} {incr i} {
  24             set key [randstring 0 8 alpha]
  25             set val [randstring 0 8 alpha]
  26             if {[info exists bighash($key)]} {
  27                 incr i -1
  28                 continue
  29             }
  30             r hset bighash $key $val
  31             set bighash($key) $val
  32         }
  33         list [r hlen bighash]
  34     } {1024}
  35
  36     test {Is the big hash encoded with a zipmap?} {
  37         r debug object bighash
  38     } {*hashtable*}
  39
  40     test {HGET against the small hash} {
  41         set err {}
  42         foreach k [array names smallhash *] {
  43             if {$smallhash($k) ne [r hget smallhash $k]} {
  44                 set err "$smallhash($k) != [r hget smallhash $k]"
  45                 break
  46             }
  47         }
  48         set _ $err
  49     } {}
  50
  51     test {HGET against the big hash} {
  52         set err {}
  53         foreach k [array names bighash *] {
  54             if {$bighash($k) ne [r hget bighash $k]} {
  55                 set err "$bighash($k) != [r hget bighash $k]"
  56                 break
  57             }
  58         }
  59         set _ $err
  60     } {}
  61
  62     test {HGET against non existing key} {
  63         set rv {}
  64         lappend rv [r hget smallhash __123123123__]
  65         lappend rv [r hget bighash __123123123__]
  66         set _ $rv
  67     } {{} {}}
  68
  69     test {HSET in update and insert mode} {
  70         set rv {}
  71         set k [lindex [array names smallhash *] 0]
  72         lappend rv [r hset smallhash $k newval1]
  73         set smallhash($k) newval1
  74         lappend rv [r hget smallhash $k]
  75         lappend rv [r hset smallhash __foobar123__ newval]
  76         set k [lindex [array names bighash *] 0]
  77         lappend rv [r hset bighash $k newval2]
  78         set bighash($k) newval2
  79         lappend rv [r hget bighash $k]
  80         lappend rv [r hset bighash __foobar123__ newval]
  81         lappend rv [r hdel smallhash __foobar123__]
  82         lappend rv [r hdel bighash __foobar123__]
  83         set _ $rv
  84     } {0 newval1 1 0 newval2 1 1 1}
  85
  86     test {HSETNX target key missing - small hash} {
  87         r hsetnx smallhash __123123123__ foo
  88         r hget smallhash __123123123__
  89     } {foo}
  90
  91     test {HSETNX target key exists - small hash} {
  92         r hsetnx smallhash __123123123__ bar
  93         set result [r hget smallhash __123123123__]
  94         r hdel smallhash __123123123__
  95         set _ $result
  96     } {foo}
  97
  98     test {HSETNX target key missing - big hash} {
  99         r hsetnx bighash __123123123__ foo
 100         r hget bighash __123123123__
 101     } {foo}
 102
 103     test {HSETNX target key exists - big hash} {
 104         r hsetnx bighash __123123123__ bar
 105         set result [r hget bighash __123123123__]
 106         r hdel bighash __123123123__
 107         set _ $result
 108     } {foo}
 109
 110     test {HMSET wrong number of args} {
 111         catch {r hmset smallhash key1 val1 key2} err
 112         format $err
 113     } {*wrong number*}
 114
 115     test {HMSET - small hash} {
 116         set args {}
 117         foreach {k v} [array get smallhash] {
 118             set newval [randstring 0 8 alpha]
 119             set smallhash($k) $newval
 120             lappend args $k $newval
 121         }
 122         r hmset smallhash {*}$args
 123     } {OK}
 124
 125     test {HMSET - big hash} {
 126         set args {}
 127         foreach {k v} [array get bighash] {
 128             set newval [randstring 0 8 alpha]
 129             set bighash($k) $newval
 130             lappend args $k $newval
 131         }
 132         r hmset bighash {*}$args
 133     } {OK}
 134
 135     test {HMGET against non existing key and fields} {
 136         set rv {}
 137         lappend rv [r hmget doesntexist __123123123__ __456456456__]
 138         lappend rv [r hmget smallhash __123123123__ __456456456__]
 139         lappend rv [r hmget bighash __123123123__ __456456456__]
 140         set _ $rv
 141     } {{{} {}} {{} {}} {{} {}}}
 142
 143     test {HMGET - small hash} {
 144         set keys {}
 145         set vals {}
 146         foreach {k v} [array get smallhash] {
 147             lappend keys $k
 148             lappend vals $v
 149         }
 150         set err {}
 151         set result [r hmget smallhash {*}$keys]
 152         if {$vals ne $result} {
 153             set err "$vals != $result"
 154             break
 155         }
 156         set _ $err
 157     } {}
 158
 159     test {HMGET - big hash} {
 160         set keys {}
 161         set vals {}
 162         foreach {k v} [array get bighash] {
 163             lappend keys $k
 164             lappend vals $v
 165         }
 166         set err {}
 167         set result [r hmget bighash {*}$keys]
 168         if {$vals ne $result} {
 169             set err "$vals != $result"
 170             break
 171         }
 172         set _ $err
 173     } {}
 174
 175     test {HKEYS - small hash} {
 176         lsort [r hkeys smallhash]
 177     } [lsort [array names smallhash *]]
 178
 179     test {HKEYS - big hash} {
 180         lsort [r hkeys bighash]
 181     } [lsort [array names bighash *]]
 182
 183     test {HVALS - small hash} {
 184         set vals {}
 185         foreach {k v} [array get smallhash] {
 186             lappend vals $v
 187         }
 188         set _ [lsort $vals]
 189     } [lsort [r hvals smallhash]]
 190
 191     test {HVALS - big hash} {
 192         set vals {}
 193         foreach {k v} [array get bighash] {
 194             lappend vals $v
 195         }
 196         set _ [lsort $vals]
 197     } [lsort [r hvals bighash]]
 198
 199     test {HGETALL - small hash} {
 200         lsort [r hgetall smallhash]
 201     } [lsort [array get smallhash]]
 202
 203     test {HGETALL - big hash} {
 204         lsort [r hgetall bighash]
 205     } [lsort [array get bighash]]
 206
 207     test {HDEL and return value} {
 208         set rv {}
 209         lappend rv [r hdel smallhash nokey]
 210         lappend rv [r hdel bighash nokey]
 211         set k [lindex [array names smallhash *] 0]
 212         lappend rv [r hdel smallhash $k]
 213         lappend rv [r hdel smallhash $k]
 214         lappend rv [r hget smallhash $k]
 215         unset smallhash($k)
 216         set k [lindex [array names bighash *] 0]
 217         lappend rv [r hdel bighash $k]
 218         lappend rv [r hdel bighash $k]
 219         lappend rv [r hget bighash $k]
 220         unset bighash($k)
 221         set _ $rv
 222     } {0 0 1 0 {} 1 0 {}}
 223
 224     test {HEXISTS} {
 225         set rv {}
 226         set k [lindex [array names smallhash *] 0]
 227         lappend rv [r hexists smallhash $k]
 228         lappend rv [r hexists smallhash nokey]
 229         set k [lindex [array names bighash *] 0]
 230         lappend rv [r hexists bighash $k]
 231         lappend rv [r hexists bighash nokey]
 232     } {1 0 1 0}
 233
 234     test {Is a zipmap encoded Hash promoted on big payload?} {
 235         r hset smallhash foo [string repeat a 1024]
 236         r debug object smallhash
 237     } {*hashtable*}
 238
 239     test {HINCRBY against non existing database key} {
 240         r del htest
 241         list [r hincrby htest foo 2]
 242     } {2}
 243
 244     test {HINCRBY against non existing hash key} {
 245         set rv {}
 246         r hdel smallhash tmp
 247         r hdel bighash tmp
 248         lappend rv [r hincrby smallhash tmp 2]
 249         lappend rv [r hget smallhash tmp]
 250         lappend rv [r hincrby bighash tmp 2]
 251         lappend rv [r hget bighash tmp]
 252     } {2 2 2 2}
 253
 254     test {HINCRBY against hash key created by hincrby itself} {
 255         set rv {}
 256         lappend rv [r hincrby smallhash tmp 3]
 257         lappend rv [r hget smallhash tmp]
 258         lappend rv [r hincrby bighash tmp 3]
 259         lappend rv [r hget bighash tmp]
 260     } {5 5 5 5}
 261
 262     test {HINCRBY against hash key originally set with HSET} {
 263         r hset smallhash tmp 100
 264         r hset bighash tmp 100
 265         list [r hincrby smallhash tmp 2] [r hincrby bighash tmp 2]
 266     } {102 102}
 267
 268     test {HINCRBY over 32bit value} {
 269         r hset smallhash tmp 17179869184
 270         r hset bighash tmp 17179869184
 271         list [r hincrby smallhash tmp 1] [r hincrby bighash tmp 1]
 272     } {17179869185 17179869185}
 273
 274     test {HINCRBY over 32bit value with over 32bit increment} {
 275         r hset smallhash tmp 17179869184
 276         r hset bighash tmp 17179869184
 277         list [r hincrby smallhash tmp 17179869184] [r hincrby bighash tmp 17179869184]
 278     } {34359738368 34359738368}
 279
 280     test {HINCRBY fails against hash value with spaces} {
 281         r hset smallhash str "    11    "
 282         r hset bighash str "    11    "
 283         catch {r hincrby smallhash str 1} smallerr
 284         catch {r hincrby smallhash str 1} bigerr
 285         set rv {}
 286         lappend rv [string match "ERR*not an integer*" $smallerr]
 287         lappend rv [string match "ERR*not an integer*" $bigerr]
 288     } {1 1}
 289 }