github.com/nutsdb/nutsdb@v1.0.4/examples/sortedSet/main.go (about) 1 package main 2 3 import ( 4 "fmt" 5 "io/ioutil" 6 "log" 7 "os" 8 9 "github.com/nutsdb/nutsdb" 10 ) 11 12 var ( 13 db *nutsdb.DB 14 err error 15 ) 16 17 func init() { 18 fileDir := "/tmp/nutsdb_example" 19 20 files, _ := ioutil.ReadDir(fileDir) 21 for _, f := range files { 22 name := f.Name() 23 if name != "" { 24 err := os.RemoveAll(fileDir + "/" + name) 25 if err != nil { 26 panic(err) 27 } 28 } 29 } 30 db, _ = nutsdb.Open( 31 nutsdb.DefaultOptions, 32 nutsdb.WithDir(fileDir), 33 nutsdb.WithSegmentSize(1024*1024), // 1MB 34 ) 35 if err != nil { 36 panic(err) 37 } 38 39 } 40 41 func main() { 42 testZAdd() 43 44 testZScore() 45 46 testZCard() 47 48 testZCount() 49 50 testZMembers() 51 52 testZPeekMax() 53 54 testZPeekMin() 55 56 testZPopMax() 57 58 testZPopMin() 59 60 testZRangeByRank() 61 62 testZRangeByScore() 63 64 testZRank() 65 66 testZRevRank() 67 68 testZRem() 69 70 testZRemRangeByRank() 71 } 72 73 func testZAdd() { 74 if err := db.Update( 75 func(tx *nutsdb.Tx) error { 76 bucket := "myZSet1" 77 key := []byte("key1") 78 return tx.ZAdd(bucket, key, 1, []byte("val1")) 79 }); err != nil { 80 log.Fatal(err) 81 } 82 } 83 84 func testZCard() { 85 if err := db.View( 86 func(tx *nutsdb.Tx) error { 87 bucket := "myZSet1" 88 key := []byte("key1") 89 num, err := tx.ZCard(bucket, key) 90 if err != nil { 91 return err 92 } 93 fmt.Println("ZCard num", num) 94 return nil 95 }); err != nil { 96 log.Fatal(err) 97 } 98 } 99 100 func testZCount() { 101 if err := db.Update( 102 func(tx *nutsdb.Tx) error { 103 bucket := "myZSet1" 104 key := []byte("key1") 105 return tx.ZAdd(bucket, key, 1, []byte("val2")) 106 }); err != nil { 107 log.Fatal(err) 108 } 109 110 if err := db.View( 111 func(tx *nutsdb.Tx) error { 112 bucket := "myZSet1" 113 key := []byte("key1") 114 num, err := tx.ZCount(bucket, key, 0, 1, nil) 115 if err != nil { 116 return err 117 } 118 fmt.Println("ZCount num", num) 119 return nil 120 }); err != nil { 121 log.Fatal(err) 122 } 123 } 124 125 func testZScore() { 126 if err := db.View( 127 func(tx *nutsdb.Tx) error { 128 bucket := "myZSet1" 129 key := []byte("key1") 130 score, err := tx.ZScore(bucket, key, []byte("val1")) 131 if err != nil { 132 return err 133 } 134 fmt.Println("val1 score: ", score) 135 return nil 136 }); err != nil { 137 log.Fatal(err) 138 } 139 } 140 141 func testZMembers() { 142 if err := db.View( 143 func(tx *nutsdb.Tx) error { 144 bucket := "myZSet1" 145 key := []byte("key1") 146 nodes, err := tx.ZMembers(bucket, key) 147 if err != nil { 148 return err 149 } 150 for node := range nodes { 151 fmt.Println("member:", node.Score, string(node.Value)) 152 } 153 return nil 154 }); err != nil { 155 log.Fatal(err) 156 } 157 } 158 159 func testZPeekMax() { 160 if err := db.Update( 161 func(tx *nutsdb.Tx) error { 162 bucket := "myZSet1" 163 key := []byte("key1") 164 return tx.ZAdd(bucket, key, 3, []byte("val3")) 165 }); err != nil { 166 log.Fatal(err) 167 } 168 169 if err := db.View( 170 func(tx *nutsdb.Tx) error { 171 bucket := "myZSet1" 172 key := []byte("key1") 173 node, err := tx.ZPeekMax(bucket, key) 174 if err != nil { 175 return err 176 } 177 fmt.Println("ZPeekMax:", node.Score) // val3 178 return nil 179 }); err != nil { 180 log.Fatal(err) 181 } 182 } 183 184 func testZPeekMin() { 185 if err := db.View( 186 func(tx *nutsdb.Tx) error { 187 bucket := "myZSet1" 188 key := []byte("key1") 189 node, err := tx.ZPeekMin(bucket, key) 190 if err != nil { 191 return err 192 } 193 fmt.Println("ZPeekMin:", node.Score) // val1 194 return nil 195 }); err != nil { 196 log.Fatal(err) 197 } 198 } 199 200 func testZPopMax() { 201 if err := db.Update( 202 func(tx *nutsdb.Tx) error { 203 bucket := "myZSet1" 204 key := []byte("key1") 205 node, err := tx.ZPopMax(bucket, key) 206 if err != nil { 207 return err 208 } 209 fmt.Println("ZPopMax:", node.Score) // val3 210 return nil 211 }); err != nil { 212 log.Fatal(err) 213 } 214 } 215 216 func testZPopMin() { 217 if err := db.Update( 218 func(tx *nutsdb.Tx) error { 219 bucket := "myZSet1" 220 key := []byte("key1") 221 node, err := tx.ZPopMin(bucket, key) 222 if err != nil { 223 return err 224 } 225 fmt.Println("ZPopMin:", node.Score) // val1 226 return nil 227 }); err != nil { 228 log.Fatal(err) 229 } 230 } 231 232 func testZRangeByRank() { 233 if err := db.Update( 234 func(tx *nutsdb.Tx) error { 235 bucket := "myZSet1" 236 key := []byte("key1") 237 return tx.ZAdd(bucket, key, 1, []byte("val1")) 238 }); err != nil { 239 log.Fatal(err) 240 } 241 242 if err := db.Update( 243 func(tx *nutsdb.Tx) error { 244 bucket := "myZSet1" 245 key := []byte("key1") 246 return tx.ZAdd(bucket, key, 2, []byte("val2")) 247 }); err != nil { 248 log.Fatal(err) 249 } 250 251 if err := db.Update( 252 func(tx *nutsdb.Tx) error { 253 bucket := "myZSet1" 254 key := []byte("key1") 255 return tx.ZAdd(bucket, key, 3, []byte("val3")) 256 }); err != nil { 257 log.Fatal(err) 258 } 259 260 if err := db.View( 261 func(tx *nutsdb.Tx) error { 262 bucket := "myZSet1" 263 key := []byte("key1") 264 nodes, err := tx.ZRangeByRank(bucket, key, 1, 3) 265 if err != nil { 266 return err 267 } 268 for _, node := range nodes { 269 fmt.Println("item:", string(node.Value), node.Score) 270 } 271 return nil 272 }); err != nil { 273 log.Fatal(err) 274 } 275 } 276 277 func testZRangeByScore() { 278 if err := db.Update( 279 func(tx *nutsdb.Tx) error { 280 bucket := "myZSet1" 281 key := []byte("key1") 282 return tx.ZAdd(bucket, key, 70, []byte("val1")) 283 }); err != nil { 284 log.Fatal(err) 285 } 286 287 if err := db.Update( 288 func(tx *nutsdb.Tx) error { 289 bucket := "myZSet1" 290 key := []byte("key1") 291 return tx.ZAdd(bucket, key, 90, []byte("val2")) 292 }); err != nil { 293 log.Fatal(err) 294 } 295 296 if err := db.Update( 297 func(tx *nutsdb.Tx) error { 298 bucket := "myZSet1" 299 key := []byte("key1") 300 return tx.ZAdd(bucket, key, 86, []byte("val3")) 301 }); err != nil { 302 log.Fatal(err) 303 } 304 305 if err := db.View( 306 func(tx *nutsdb.Tx) error { 307 bucket := "myZSet1" 308 key := []byte("key1") 309 nodes, err := tx.ZRangeByScore(bucket, key, 80, 100, nil) 310 if err != nil { 311 return err 312 } 313 for _, node := range nodes { 314 fmt.Println("item:", node.Value, node.Score) 315 } 316 return nil 317 }); err != nil { 318 log.Fatal(err) 319 } 320 } 321 322 func testZRank() { 323 if err := db.View( 324 func(tx *nutsdb.Tx) error { 325 bucket := "myZSet1" 326 key := []byte("key1") 327 rank, err := tx.ZRank(bucket, key, []byte("val1")) 328 if err != nil { 329 return err 330 } 331 fmt.Println("val1 ZRank :", rank) 332 return nil 333 }); err != nil { 334 log.Fatal(err) 335 } 336 337 if err := db.View( 338 func(tx *nutsdb.Tx) error { 339 bucket := "myZSet1" 340 key := []byte("key1") 341 rank, err := tx.ZRank(bucket, key, []byte("val2")) 342 if err != nil { 343 return err 344 } 345 fmt.Println("val2 ZRank :", rank) 346 return nil 347 }); err != nil { 348 log.Fatal(err) 349 } 350 351 if err := db.View( 352 func(tx *nutsdb.Tx) error { 353 bucket := "myZSet1" 354 key := []byte("key1") 355 rank, err := tx.ZRank(bucket, key, []byte("val3")) 356 if err != nil { 357 return err 358 } 359 fmt.Println("val3 ZRank :", rank) 360 return nil 361 }); err != nil { 362 log.Fatal(err) 363 } 364 } 365 366 func testZRevRank() { 367 if err := db.View( 368 func(tx *nutsdb.Tx) error { 369 bucket := "myZSet1" 370 key := []byte("key1") 371 rank, err := tx.ZRank(bucket, key, []byte("val1")) 372 if err != nil { 373 return err 374 } 375 fmt.Println("ZRevRank val1 rank:", rank) // ZRevRank key1 rank: 3 376 return nil 377 }); err != nil { 378 log.Fatal(err) 379 } 380 if err := db.View( 381 func(tx *nutsdb.Tx) error { 382 bucket := "myZSet1" 383 key := []byte("key1") 384 rank, err := tx.ZRank(bucket, key, []byte("val2")) 385 if err != nil { 386 return err 387 } 388 fmt.Println("ZRevRank val2 rank:", rank) // ZRevRank key2 rank: 2 389 return nil 390 }); err != nil { 391 log.Fatal(err) 392 } 393 if err := db.View( 394 func(tx *nutsdb.Tx) error { 395 bucket := "myZSet1" 396 key := []byte("key1") 397 rank, err := tx.ZRank(bucket, key, []byte("val3")) 398 if err != nil { 399 return err 400 } 401 fmt.Println("ZRevRank val3 rank:", rank) // ZRevRank key3 rank: 1 402 return nil 403 }); err != nil { 404 log.Fatal(err) 405 } 406 } 407 408 func testZRem() { 409 if err := db.Update( 410 func(tx *nutsdb.Tx) error { 411 bucket := "myZSet1" 412 key := []byte("key1") 413 return tx.ZRem(bucket, key, []byte("val3")) 414 }); err != nil { 415 log.Fatal(err) 416 } 417 418 if err := db.View( 419 func(tx *nutsdb.Tx) error { 420 bucket := "myZSet1" 421 key := []byte("key1") 422 nodes, err := tx.ZMembers(bucket, key) 423 if err != nil { 424 return err 425 } 426 fmt.Println("after ZRem key1, ZMembers nodes") 427 for node := range nodes { 428 fmt.Println("item:", node.Score, string(node.Value)) 429 } 430 return nil 431 }); err != nil { 432 log.Fatal(err) 433 } 434 } 435 436 func testZRemRangeByRank() { 437 if err := db.Update( 438 func(tx *nutsdb.Tx) error { 439 bucket := "myZSet1" 440 key := []byte("key1") 441 return tx.ZRemRangeByRank(bucket, key, 1, 2) 442 }); err != nil { 443 log.Fatal(err) 444 } 445 446 if err := db.View( 447 func(tx *nutsdb.Tx) error { 448 bucket := "myZSet1" 449 key := []byte("key1") 450 nodes, err := tx.ZMembers(bucket, key) 451 if err != nil { 452 return err 453 } 454 fmt.Println("after ZRemRangeByRank, ZMembers nodes is 0") 455 for node := range nodes { 456 fmt.Println("item:", node.Score, string(node.Value)) 457 } 458 return nil 459 }); err != nil { 460 log.Fatal(err) 461 } 462 }