mirror of
https://github.com/HDT3213/godis.git
synced 2025-10-05 08:46:56 +08:00
refactor project structure
This commit is contained in:
hdt3213
91
datastruct/sortedset/border.go
Normal file
91
datastruct/sortedset/border.go
Normal file
@@ -0,0 +1,91 @@
|
||||
package sortedset
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
/*
|
||||
* ScoreBorder is a struct represents `min` `max` parameter of redis command `ZRANGEBYSCORE`
|
||||
* can accept:
|
||||
* int or float value, such as 2.718, 2, -2.718, -2 ...
|
||||
* exclusive int or float value, such as (2.718, (2, (-2.718, (-2 ...
|
||||
* infinity: +inf, -inf， inf(same as +inf)
|
||||
*/
|
||||
|
||||
const (
|
||||
negativeInf int8 = -1
|
||||
positiveInf int8 = 1
|
||||
)
|
||||
|
||||
type ScoreBorder struct {
|
||||
Inf int8
|
||||
Value float64
|
||||
Exclude bool
|
||||
}
|
||||
|
||||
// if max.greater(score) then the score is within the upper border
|
||||
// do not use min.greater()
|
||||
func (border *ScoreBorder) greater(value float64) bool {
|
||||
if border.Inf == negativeInf {
|
||||
return false
|
||||
} else if border.Inf == positiveInf {
|
||||
return true
|
||||
}
|
||||
if border.Exclude {
|
||||
return border.Value > value
|
||||
} else {
|
||||
return border.Value >= value
|
||||
}
|
||||
}
|
||||
|
||||
func (border *ScoreBorder) less(value float64) bool {
|
||||
if border.Inf == negativeInf {
|
||||
return true
|
||||
} else if border.Inf == positiveInf {
|
||||
return false
|
||||
}
|
||||
if border.Exclude {
|
||||
return border.Value < value
|
||||
} else {
|
||||
return border.Value <= value
|
||||
}
|
||||
}
|
||||
|
||||
var positiveInfBorder = &ScoreBorder{
|
||||
Inf: positiveInf,
|
||||
}
|
||||
|
||||
var negativeInfBorder = &ScoreBorder{
|
||||
Inf: negativeInf,
|
||||
}
|
||||
|
||||
func ParseScoreBorder(s string) (*ScoreBorder, error) {
|
||||
if s == "inf" || s == "+inf" {
|
||||
return positiveInfBorder, nil
|
||||
}
|
||||
if s == "-inf" {
|
||||
return negativeInfBorder, nil
|
||||
}
|
||||
if s[0] == '(' {
|
||||
value, err := strconv.ParseFloat(s[1:], 64)
|
||||
if err != nil {
|
||||
return nil, errors.New("ERR min or max is not a float")
|
||||
}
|
||||
return &ScoreBorder{
|
||||
Inf: 0,
|
||||
Value: value,
|
||||
Exclude: true,
|
||||
}, nil
|
||||
} else {
|
||||
value, err := strconv.ParseFloat(s, 64)
|
||||
if err != nil {
|
||||
return nil, errors.New("ERR min or max is not a float")
|
||||
}
|
||||
return &ScoreBorder{
|
||||
Inf: 0,
|
||||
Value: value,
|
||||
Exclude: false,
|
||||
}, nil
|
||||
}
|
||||
}
|
||||
344
datastruct/sortedset/skiplist.go
Normal file
344
datastruct/sortedset/skiplist.go
Normal file
@@ -0,0 +1,344 @@
|
||||
package sortedset
|
||||
|
||||
import "math/rand"
|
||||
|
||||
const (
|
||||
maxLevel = 16
|
||||
)
|
||||
|
||||
type Element struct {
|
||||
Member string
|
||||
Score float64
|
||||
}
|
||||
|
||||
// level aspect of a Node
|
||||
type Level struct {
|
||||
forward *Node // forward node has greater score
|
||||
span int64
|
||||
}
|
||||
|
||||
type Node struct {
|
||||
Element
|
||||
backward *Node
|
||||
level []*Level // level[0] is base level
|
||||
}
|
||||
|
||||
type skiplist struct {
|
||||
header *Node
|
||||
tail *Node
|
||||
length int64
|
||||
level int16
|
||||
}
|
||||
|
||||
func makeNode(level int16, score float64, member string) *Node {
|
||||
n := &Node{
|
||||
Element: Element{
|
||||
Score: score,
|
||||
Member: member,
|
||||
},
|
||||
level: make([]*Level, level),
|
||||
}
|
||||
for i := range n.level {
|
||||
n.level[i] = new(Level)
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func makeSkiplist() *skiplist {
|
||||
return &skiplist{
|
||||
level: 1,
|
||||
header: makeNode(maxLevel, 0, ""),
|
||||
}
|
||||
}
|
||||
|
||||
func randomLevel() int16 {
|
||||
level := int16(1)
|
||||
for float32(rand.Int31()&0xFFFF) < (0.25 * 0xFFFF) {
|
||||
level++
|
||||
}
|
||||
if level < maxLevel {
|
||||
return level
|
||||
}
|
||||
return maxLevel
|
||||
}
|
||||
|
||||
func (skiplist *skiplist) insert(member string, score float64) *Node {
|
||||
update := make([]*Node, maxLevel) // link new node with node in `update`
|
||||
rank := make([]int64, maxLevel)
|
||||
|
||||
// find position to insert
|
||||
node := skiplist.header
|
||||
for i := skiplist.level - 1; i >= 0; i-- {
|
||||
if i == skiplist.level-1 {
|
||||
rank[i] = 0
|
||||
} else {
|
||||
rank[i] = rank[i+1] // store rank that is crossed to reach the insert position
|
||||
}
|
||||
if node.level[i] != nil {
|
||||
// traverse the skip list
|
||||
for node.level[i].forward != nil &&
|
||||
(node.level[i].forward.Score < score ||
|
||||
(node.level[i].forward.Score == score && node.level[i].forward.Member < member)) { // same score, different key
|
||||
rank[i] += node.level[i].span
|
||||
node = node.level[i].forward
|
||||
}
|
||||
}
|
||||
update[i] = node
|
||||
}
|
||||
|
||||
level := randomLevel()
|
||||
// extend skiplist level
|
||||
if level > skiplist.level {
|
||||
for i := skiplist.level; i < level; i++ {
|
||||
rank[i] = 0
|
||||
update[i] = skiplist.header
|
||||
update[i].level[i].span = skiplist.length
|
||||
}
|
||||
skiplist.level = level
|
||||
}
|
||||
|
||||
// make node and link into skiplist
|
||||
node = makeNode(level, score, member)
|
||||
for i := int16(0); i < level; i++ {
|
||||
node.level[i].forward = update[i].level[i].forward
|
||||
update[i].level[i].forward = node
|
||||
|
||||
// update span covered by update[i] as node is inserted here
|
||||
node.level[i].span = update[i].level[i].span - (rank[0] - rank[i])
|
||||
update[i].level[i].span = (rank[0] - rank[i]) + 1
|
||||
}
|
||||
|
||||
// increment span for untouched levels
|
||||
for i := level; i < skiplist.level; i++ {
|
||||
update[i].level[i].span++
|
||||
}
|
||||
|
||||
// set backward node
|
||||
if update[0] == skiplist.header {
|
||||
node.backward = nil
|
||||
} else {
|
||||
node.backward = update[0]
|
||||
}
|
||||
if node.level[0].forward != nil {
|
||||
node.level[0].forward.backward = node
|
||||
} else {
|
||||
skiplist.tail = node
|
||||
}
|
||||
skiplist.length++
|
||||
return node
|
||||
}
|
||||
|
||||
/*
|
||||
* param node: node to delete
|
||||
* param update: backward node (of target)
|
||||
*/
|
||||
func (skiplist *skiplist) removeNode(node *Node, update []*Node) {
|
||||
for i := int16(0); i < skiplist.level; i++ {
|
||||
if update[i].level[i].forward == node {
|
||||
update[i].level[i].span += node.level[i].span - 1
|
||||
update[i].level[i].forward = node.level[i].forward
|
||||
} else {
|
||||
update[i].level[i].span--
|
||||
}
|
||||
}
|
||||
if node.level[0].forward != nil {
|
||||
node.level[0].forward.backward = node.backward
|
||||
} else {
|
||||
skiplist.tail = node.backward
|
||||
}
|
||||
for skiplist.level > 1 && skiplist.header.level[skiplist.level-1].forward == nil {
|
||||
skiplist.level--
|
||||
}
|
||||
skiplist.length--
|
||||
}
|
||||
|
||||
/*
|
||||
* return: has found and removed node
|
||||
*/
|
||||
func (skiplist *skiplist) remove(member string, score float64) bool {
|
||||
/*
|
||||
* find backward node (of target) or last node of each level
|
||||
* their forward need to be updated
|
||||
*/
|
||||
update := make([]*Node, maxLevel)
|
||||
node := skiplist.header
|
||||
for i := skiplist.level - 1; i >= 0; i-- {
|
||||
for node.level[i].forward != nil &&
|
||||
(node.level[i].forward.Score < score ||
|
||||
(node.level[i].forward.Score == score &&
|
||||
node.level[i].forward.Member < member)) {
|
||||
node = node.level[i].forward
|
||||
}
|
||||
update[i] = node
|
||||
}
|
||||
node = node.level[0].forward
|
||||
if node != nil && score == node.Score && node.Member == member {
|
||||
skiplist.removeNode(node, update)
|
||||
// free x
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
/*
|
||||
* return: 1 based rank, 0 means member not found
|
||||
*/
|
||||
func (skiplist *skiplist) getRank(member string, score float64) int64 {
|
||||
var rank int64 = 0
|
||||
x := skiplist.header
|
||||
for i := skiplist.level - 1; i >= 0; i-- {
|
||||
for x.level[i].forward != nil &&
|
||||
(x.level[i].forward.Score < score ||
|
||||
(x.level[i].forward.Score == score &&
|
||||
x.level[i].forward.Member <= member)) {
|
||||
rank += x.level[i].span
|
||||
x = x.level[i].forward
|
||||
}
|
||||
|
||||
/* x might be equal to zsl->header, so test if obj is non-NULL */
|
||||
if x.Member == member {
|
||||
return rank
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
/*
|
||||
* 1-based rank
|
||||
*/
|
||||
func (skiplist *skiplist) getByRank(rank int64) *Node {
|
||||
var i int64 = 0
|
||||
n := skiplist.header
|
||||
// scan from top level
|
||||
for level := skiplist.level - 1; level >= 0; level-- {
|
||||
for n.level[level].forward != nil && (i+n.level[level].span) <= rank {
|
||||
i += n.level[level].span
|
||||
n = n.level[level].forward
|
||||
}
|
||||
if i == rank {
|
||||
return n
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (skiplist *skiplist) hasInRange(min *ScoreBorder, max *ScoreBorder) bool {
|
||||
// min & max = empty
|
||||
if min.Value > max.Value || (min.Value == max.Value && (min.Exclude || max.Exclude)) {
|
||||
return false
|
||||
}
|
||||
// min > tail
|
||||
n := skiplist.tail
|
||||
if n == nil || !min.less(n.Score) {
|
||||
return false
|
||||
}
|
||||
// max < head
|
||||
n = skiplist.header.level[0].forward
|
||||
if n == nil || !max.greater(n.Score) {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func (skiplist *skiplist) getFirstInScoreRange(min *ScoreBorder, max *ScoreBorder) *Node {
|
||||
if !skiplist.hasInRange(min, max) {
|
||||
return nil
|
||||
}
|
||||
n := skiplist.header
|
||||
// scan from top level
|
||||
for level := skiplist.level - 1; level >= 0; level-- {
|
||||
// if forward is not in range than move forward
|
||||
for n.level[level].forward != nil && !min.less(n.level[level].forward.Score) {
|
||||
n = n.level[level].forward
|
||||
}
|
||||
}
|
||||
/* This is an inner range, so the next node cannot be NULL. */
|
||||
n = n.level[0].forward
|
||||
if !max.greater(n.Score) {
|
||||
return nil
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func (skiplist *skiplist) getLastInScoreRange(min *ScoreBorder, max *ScoreBorder) *Node {
|
||||
if !skiplist.hasInRange(min, max) {
|
||||
return nil
|
||||
}
|
||||
n := skiplist.header
|
||||
// scan from top level
|
||||
for level := skiplist.level - 1; level >= 0; level-- {
|
||||
for n.level[level].forward != nil && max.greater(n.level[level].forward.Score) {
|
||||
n = n.level[level].forward
|
||||
}
|
||||
}
|
||||
if !min.less(n.Score) {
|
||||
return nil
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
/*
|
||||
* return removed elements
|
||||
*/
|
||||
func (skiplist *skiplist) RemoveRangeByScore(min *ScoreBorder, max *ScoreBorder) (removed []*Element) {
|
||||
update := make([]*Node, maxLevel)
|
||||
removed = make([]*Element, 0)
|
||||
// find backward nodes (of target range) or last node of each level
|
||||
node := skiplist.header
|
||||
for i := skiplist.level - 1; i >= 0; i-- {
|
||||
for node.level[i].forward != nil {
|
||||
if min.less(node.level[i].forward.Score) { // already in range
|
||||
break
|
||||
}
|
||||
node = node.level[i].forward
|
||||
}
|
||||
update[i] = node
|
||||
}
|
||||
|
||||
// node is the first one within range
|
||||
node = node.level[0].forward
|
||||
|
||||
// remove nodes in range
|
||||
for node != nil {
|
||||
if !max.greater(node.Score) { // already out of range
|
||||
break
|
||||
}
|
||||
next := node.level[0].forward
|
||||
removedElement := node.Element
|
||||
removed = append(removed, &removedElement)
|
||||
skiplist.removeNode(node, update)
|
||||
node = next
|
||||
}
|
||||
return removed
|
||||
}
|
||||
|
||||
// 1-based rank, including start, exclude stop
|
||||
func (skiplist *skiplist) RemoveRangeByRank(start int64, stop int64) (removed []*Element) {
|
||||
var i int64 = 0 // rank of iterator
|
||||
update := make([]*Node, maxLevel)
|
||||
removed = make([]*Element, 0)
|
||||
|
||||
// scan from top level
|
||||
node := skiplist.header
|
||||
for level := skiplist.level - 1; level >= 0; level-- {
|
||||
for node.level[level].forward != nil && (i+node.level[level].span) < start {
|
||||
i += node.level[level].span
|
||||
node = node.level[level].forward
|
||||
}
|
||||
update[level] = node
|
||||
}
|
||||
|
||||
i++
|
||||
node = node.level[0].forward // first node in range
|
||||
|
||||
// remove nodes in range
|
||||
for node != nil && i < stop {
|
||||
next := node.level[0].forward
|
||||
removedElement := node.Element
|
||||
removed = append(removed, &removedElement)
|
||||
skiplist.removeNode(node, update)
|
||||
node = next
|
||||
i++
|
||||
}
|
||||
return removed
|
||||
}
|
||||
226
datastruct/sortedset/sortedset.go
Normal file
226
datastruct/sortedset/sortedset.go
Normal file
@@ -0,0 +1,226 @@
|
||||
package sortedset
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
)
|
||||
|
||||
type SortedSet struct {
|
||||
dict map[string]*Element
|
||||
skiplist *skiplist
|
||||
}
|
||||
|
||||
func Make() *SortedSet {
|
||||
return &SortedSet{
|
||||
dict: make(map[string]*Element),
|
||||
skiplist: makeSkiplist(),
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* return: has inserted new node
|
||||
*/
|
||||
func (sortedSet *SortedSet) Add(member string, score float64) bool {
|
||||
element, ok := sortedSet.dict[member]
|
||||
sortedSet.dict[member] = &Element{
|
||||
Member: member,
|
||||
Score: score,
|
||||
}
|
||||
if ok {
|
||||
if score != element.Score {
|
||||
sortedSet.skiplist.remove(member, score)
|
||||
sortedSet.skiplist.insert(member, score)
|
||||
}
|
||||
return false
|
||||
} else {
|
||||
sortedSet.skiplist.insert(member, score)
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
func (sortedSet *SortedSet) Len() int64 {
|
||||
return int64(len(sortedSet.dict))
|
||||
}
|
||||
|
||||
func (sortedSet *SortedSet) Get(member string) (element *Element, ok bool) {
|
||||
element, ok = sortedSet.dict[member]
|
||||
if !ok {
|
||||
return nil, false
|
||||
}
|
||||
return element, true
|
||||
}
|
||||
|
||||
func (sortedSet *SortedSet) Remove(member string) bool {
|
||||
v, ok := sortedSet.dict[member]
|
||||
if ok {
|
||||
sortedSet.skiplist.remove(member, v.Score)
|
||||
delete(sortedSet.dict, member)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
/**
|
||||
* get 0-based rank
|
||||
*/
|
||||
func (sortedSet *SortedSet) GetRank(member string, desc bool) (rank int64) {
|
||||
element, ok := sortedSet.dict[member]
|
||||
if !ok {
|
||||
return -1
|
||||
}
|
||||
r := sortedSet.skiplist.getRank(member, element.Score)
|
||||
if desc {
|
||||
r = sortedSet.skiplist.length - r
|
||||
} else {
|
||||
r--
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
/**
|
||||
* traverse [start, stop), 0-based rank
|
||||
*/
|
||||
func (sortedSet *SortedSet) ForEach(start int64, stop int64, desc bool, consumer func(element *Element) bool) {
|
||||
size := int64(sortedSet.Len())
|
||||
if start < 0 || start >= size {
|
||||
panic("illegal start " + strconv.FormatInt(start, 10))
|
||||
}
|
||||
if stop < start || stop > size {
|
||||
panic("illegal end " + strconv.FormatInt(stop, 10))
|
||||
}
|
||||
|
||||
// find start node
|
||||
var node *Node
|
||||
if desc {
|
||||
node = sortedSet.skiplist.tail
|
||||
if start > 0 {
|
||||
node = sortedSet.skiplist.getByRank(int64(size - start))
|
||||
}
|
||||
} else {
|
||||
node = sortedSet.skiplist.header.level[0].forward
|
||||
if start > 0 {
|
||||
node = sortedSet.skiplist.getByRank(int64(start + 1))
|
||||
}
|
||||
}
|
||||
|
||||
sliceSize := int(stop - start)
|
||||
for i := 0; i < sliceSize; i++ {
|
||||
if !consumer(&node.Element) {
|
||||
break
|
||||
}
|
||||
if desc {
|
||||
node = node.backward
|
||||
} else {
|
||||
node = node.level[0].forward
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* return [start, stop), 0-based rank
|
||||
* assert start in [0, size), stop in [start, size]
|
||||
*/
|
||||
func (sortedSet *SortedSet) Range(start int64, stop int64, desc bool) []*Element {
|
||||
sliceSize := int(stop - start)
|
||||
slice := make([]*Element, sliceSize)
|
||||
i := 0
|
||||
sortedSet.ForEach(start, stop, desc, func(element *Element) bool {
|
||||
slice[i] = element
|
||||
i++
|
||||
return true
|
||||
})
|
||||
return slice
|
||||
}
|
||||
|
||||
func (sortedSet *SortedSet) Count(min *ScoreBorder, max *ScoreBorder) int64 {
|
||||
var i int64 = 0
|
||||
// ascending order
|
||||
sortedSet.ForEach(0, sortedSet.Len(), false, func(element *Element) bool {
|
||||
gtMin := min.less(element.Score) // greater than min
|
||||
if !gtMin {
|
||||
// has not into range, continue foreach
|
||||
return true
|
||||
}
|
||||
ltMax := max.greater(element.Score) // less than max
|
||||
if !ltMax {
|
||||
// break through score border, break foreach
|
||||
return false
|
||||
}
|
||||
// gtMin && ltMax
|
||||
i++
|
||||
return true
|
||||
})
|
||||
return i
|
||||
}
|
||||
|
||||
func (sortedSet *SortedSet) ForEachByScore(min *ScoreBorder, max *ScoreBorder, offset int64, limit int64, desc bool, consumer func(element *Element) bool) {
|
||||
// find start node
|
||||
var node *Node
|
||||
if desc {
|
||||
node = sortedSet.skiplist.getLastInScoreRange(min, max)
|
||||
} else {
|
||||
node = sortedSet.skiplist.getFirstInScoreRange(min, max)
|
||||
}
|
||||
|
||||
for node != nil && offset > 0 {
|
||||
if desc {
|
||||
node = node.backward
|
||||
} else {
|
||||
node = node.level[0].forward
|
||||
}
|
||||
offset--
|
||||
}
|
||||
|
||||
// A negative limit returns all elements from the offset
|
||||
for i := 0; (i < int(limit) || limit < 0) && node != nil; i++ {
|
||||
if !consumer(&node.Element) {
|
||||
break
|
||||
}
|
||||
if desc {
|
||||
node = node.backward
|
||||
} else {
|
||||
node = node.level[0].forward
|
||||
}
|
||||
if node == nil {
|
||||
break
|
||||
}
|
||||
gtMin := min.less(node.Element.Score) // greater than min
|
||||
ltMax := max.greater(node.Element.Score)
|
||||
if !gtMin || !ltMax {
|
||||
break // break through score border
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* param limit: <0 means no limit
|
||||
*/
|
||||
func (sortedSet *SortedSet) RangeByScore(min *ScoreBorder, max *ScoreBorder, offset int64, limit int64, desc bool) []*Element {
|
||||
if limit == 0 || offset < 0 {
|
||||
return make([]*Element, 0)
|
||||
}
|
||||
slice := make([]*Element, 0)
|
||||
sortedSet.ForEachByScore(min, max, offset, limit, desc, func(element *Element) bool {
|
||||
slice = append(slice, element)
|
||||
return true
|
||||
})
|
||||
return slice
|
||||
}
|
||||
|
||||
func (sortedSet *SortedSet) RemoveByScore(min *ScoreBorder, max *ScoreBorder) int64 {
|
||||
removed := sortedSet.skiplist.RemoveRangeByScore(min, max)
|
||||
for _, element := range removed {
|
||||
delete(sortedSet.dict, element.Member)
|
||||
}
|
||||
return int64(len(removed))
|
||||
}
|
||||
|
||||
/*
|
||||
* 0-based rank, [start, stop)
|
||||
*/
|
||||
func (sortedSet *SortedSet) RemoveByRank(start int64, stop int64) int64 {
|
||||
removed := sortedSet.skiplist.RemoveRangeByRank(start+1, stop+1)
|
||||
for _, element := range removed {
|
||||
delete(sortedSet.dict, element.Member)
|
||||
}
|
||||
return int64(len(removed))
|
||||
}
|
||||
Reference in New Issue
Block a user