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  }