github.com/runner-mei/ql@v1.1.0/mem.go (about) 1 // Copyright (c) 2014 ql Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 // Plain memory storage back end. 6 7 package ql 8 9 import ( 10 "bytes" 11 "fmt" 12 "io" 13 "math/big" 14 "time" 15 ) 16 17 var ( 18 _ btreeIndex = (*memIndex)(nil) 19 _ btreeIterator = (*memBTreeIterator)(nil) 20 _ indexIterator = (*xenumerator2)(nil) 21 _ storage = (*mem)(nil) 22 _ temp = (*memTemp)(nil) 23 ) 24 25 type memIndex struct { 26 m *mem 27 t *xtree 28 unique bool 29 } 30 31 func newMemIndex(m *mem, unique bool) *memIndex { 32 r := &memIndex{t: xtreeNew(), unique: unique, m: m} 33 //dbg("newMemIndex %p, %p", r, m) 34 return r 35 } 36 37 func (x *memIndex) Clear() error { 38 //dbg("memIndex(%p, %p).Clear", x, x.m) 39 x.m.newUndo(undoClearX, 0, []interface{}{x, x.t}) 40 x.t = xtreeNew() 41 return nil 42 } 43 44 func (x *memIndex) Create(indexedValues []interface{}, h int64) error { 45 //dbg("memIndex(%p, %p).Create %v, %v", x, x.m, indexedValues, h) 46 t := x.t 47 switch { 48 case !x.unique: 49 k := indexKey{indexedValues, h} 50 x.m.newUndo(undoCreateX, 0, []interface{}{x, k}) //TODO why is old value, if any, not saved? 51 t.Set(k, 0) 52 case isIndexNull(indexedValues): // unique, NULL 53 k := indexKey{nil, h} 54 x.m.newUndo(undoCreateX, 0, []interface{}{x, k}) //TODO why is old value, if any, not saved? 55 t.Set(k, 0) 56 default: // unique, non NULL 57 k := indexKey{indexedValues, 0} 58 if _, ok := t.Get(k); ok { //LATER need .Put 59 return fmt.Errorf("cannot insert into unique index: duplicate value(s): %v", indexedValues) 60 } 61 62 x.m.newUndo(undoCreateX, 0, []interface{}{x, k}) //TODO why is old value, if any, not saved? 63 t.Set(k, int(h)) 64 } 65 return nil 66 } 67 68 func (x *memIndex) Delete(indexedValues []interface{}, h int64) error { 69 //dbg("memIndex(%p, %p).Delete %v, %v", x, x.m, indexedValues, h) 70 t := x.t 71 var k indexKey 72 var v interface{} 73 var ok, okv bool 74 switch { 75 case !x.unique: 76 k = indexKey{indexedValues, h} 77 v, okv = t.Get(k) 78 ok = t.delete(k) 79 case isIndexNull(indexedValues): // unique, NULL 80 k = indexKey{nil, h} 81 v, okv = t.Get(k) 82 ok = t.delete(k) 83 default: // unique, non NULL 84 k = indexKey{indexedValues, 0} 85 v, okv = t.Get(k) 86 ok = t.delete(k) 87 } 88 if ok { 89 if okv { 90 x.m.newUndo(undoDeleteX, int64(v.(int)), []interface{}{x, k}) 91 } 92 return nil 93 } 94 95 return fmt.Errorf("internal error 047") 96 } 97 98 func (x *memIndex) Drop() error { 99 x.m.newUndo(undoDropX, 0, []interface{}{x, *x}) 100 *x = memIndex{} 101 return nil 102 } 103 104 func (x *memIndex) Seek(indexedValues []interface{}) (indexIterator, bool, error) { 105 it, hit := x.t.Seek(indexKey{indexedValues, 0}) 106 return &xenumerator2{*it, x.unique}, hit, nil 107 } 108 109 func (x *memIndex) SeekFirst() (iter indexIterator, err error) { 110 it, err := x.t.SeekFirst() 111 if err != nil { 112 return nil, err 113 } 114 115 return &xenumerator2{*it, x.unique}, nil 116 } 117 118 func (x *memIndex) SeekLast() (iter indexIterator, err error) { 119 it, err := x.t.SeekLast() 120 if err != nil { 121 return nil, err 122 } 123 124 return &xenumerator2{*it, x.unique}, nil 125 } 126 127 type xenumerator2 struct { 128 it xenumerator 129 unique bool 130 } 131 132 func (it *xenumerator2) Next() ([]interface{}, int64, error) { 133 k, h, err := it.it.Next() 134 if err != nil { 135 return nil, -1, err 136 } 137 138 switch it.unique { 139 case true: 140 if k.value == nil { 141 return nil, k.h, nil 142 } 143 144 return k.value, h, nil 145 default: 146 return k.value, k.h, nil 147 } 148 } 149 150 func (it *xenumerator2) Prev() ([]interface{}, int64, error) { 151 k, h, err := it.it.Prev() 152 if err != nil { 153 return nil, -1, err 154 } 155 156 switch it.unique { 157 case true: 158 if k.value == nil { 159 return nil, k.h, nil 160 } 161 162 return k.value, h, nil 163 default: 164 return k.value, k.h, nil 165 } 166 } 167 168 type memBTreeIterator enumerator 169 170 func (it *memBTreeIterator) Next() (k, v []interface{}, err error) { 171 return (*enumerator)(it).Next() 172 } 173 174 type memTemp struct { 175 tree *tree 176 store *mem 177 } 178 179 func (t *memTemp) BeginTransaction() (err error) { 180 return nil 181 } 182 183 func (t *memTemp) Get(k []interface{}) (v []interface{}, err error) { 184 v, _ = t.tree.Get(k) 185 return 186 } 187 188 func (t *memTemp) Create(data ...interface{}) (h int64, err error) { 189 s := t.store 190 switch n := len(s.recycler); { 191 case n != 0: 192 h = int64(s.recycler[n-1]) 193 s.recycler = s.recycler[:n-1] 194 s.data[h] = s.clone(data...) 195 default: 196 h = int64(len(s.data)) 197 s.data = append(s.data, s.clone(data...)) 198 } 199 return 200 } 201 202 func (t *memTemp) Read(dst []interface{}, h int64, cols ...*col) (data []interface{}, err error) { 203 return t.store.Read(dst, h, cols...) 204 } 205 206 func (*memTemp) Drop() (err error) { return } 207 208 func (t *memTemp) Set(k, v []interface{}) (err error) { 209 t.tree.Set(append([]interface{}(nil), k...), t.store.clone(v...)) 210 return 211 } 212 213 func (t *memTemp) SeekFirst() (e btreeIterator, err error) { 214 en, err := t.tree.SeekFirst() 215 if err != nil { 216 return 217 } 218 219 return (*memBTreeIterator)(en), nil 220 } 221 222 const ( 223 undoCreateNewHandle = iota 224 undoCreateRecycledHandle 225 undoUpdate 226 undoDelete 227 undoClearX // {0: *memIndex, 1: *xtree} 228 undoCreateX // {0: *memIndex, 1: indexKey} 229 undoDeleteX // {0: *memIndex, 1: indexKey} 230 undoDropX // {0: *memIndex, 1: memIndex} 231 ) 232 233 type undo struct { 234 tag int 235 h int64 236 data []interface{} 237 } 238 239 type undos struct { 240 list []undo 241 parent *undos 242 } 243 244 type mem struct { 245 data [][]interface{} 246 id int64 247 recycler []int 248 tnl int 249 rollback *undos 250 } 251 252 func newMemStorage() (s *mem, err error) { 253 s = &mem{data: [][]interface{}{nil}} 254 if err = s.BeginTransaction(); err != nil { 255 return nil, err 256 } 257 258 h, err := s.Create() 259 if h != 1 { 260 panic("internal error 048") 261 } 262 263 if err = s.Commit(); err != nil { 264 return nil, err 265 } 266 267 return 268 } 269 270 func (s *mem) OpenIndex(unique bool, handle int64) (btreeIndex, error) { // Never called on the memory backend. 271 panic("internal error 049") 272 } 273 274 func (s *mem) newUndo(tag int, h int64, data []interface{}) { 275 s.rollback.list = append(s.rollback.list, undo{tag, h, data}) 276 } 277 278 func (s *mem) Acid() bool { return false } 279 280 func (s *mem) Close() (err error) { 281 if s.tnl != 0 { 282 return fmt.Errorf("cannot close DB while open transaction exist") 283 } 284 *s = mem{} 285 return 286 } 287 288 func (s *mem) CreateIndex(unique bool) ( /* handle */ int64, btreeIndex, error) { 289 return -1, newMemIndex(s, unique), nil // handle of memIndex should never be used 290 } 291 292 func (s *mem) Name() string { return fmt.Sprintf("/proc/self/mem/%p", s) } // fake, non existing name 293 294 // OpenMem returns a new, empty DB backed by the process' memory. The back end 295 // has no limits on field/record/table/DB size other than memory available to 296 // the process. 297 func OpenMem() (db *DB, err error) { 298 s, err := newMemStorage() 299 if err != nil { 300 return 301 } 302 303 if db, err = newDB(s); err != nil { 304 return nil, err 305 } 306 307 db.isMem = true 308 return db, nil 309 } 310 311 func (s *mem) Verify() (allocs int64, err error) { 312 for _, v := range s.recycler { 313 if s.data[v] != nil { 314 return 0, fmt.Errorf("corrupted: non nil free handle %d", s.data[v]) 315 } 316 } 317 318 for _, v := range s.data { 319 if v != nil { 320 allocs++ 321 } 322 } 323 324 if allocs != int64(len(s.data))-1-int64(len(s.recycler)) { 325 return 0, fmt.Errorf("corrupted: len(data) %d, len(recycler) %d, allocs %d", len(s.data), len(s.recycler), allocs) 326 } 327 328 return 329 } 330 331 func (s *mem) String() string { 332 var b bytes.Buffer 333 for i, v := range s.data { 334 b.WriteString(fmt.Sprintf("s.data[%d] %#v\n", i, v)) 335 } 336 for i, v := range s.recycler { 337 b.WriteString(fmt.Sprintf("s.recycler[%d] %v\n", i, v)) 338 } 339 return b.String() 340 } 341 342 func (s *mem) CreateTemp(asc bool) (_ temp, err error) { 343 st, err := newMemStorage() 344 if err != nil { 345 return 346 } 347 348 return &memTemp{ 349 tree: treeNew(collators[asc]), 350 store: st, 351 }, nil 352 } 353 354 func (s *mem) ResetID() (err error) { 355 s.id = 0 356 return 357 } 358 359 func (s *mem) ID() (id int64, err error) { 360 s.id++ 361 return s.id, nil 362 } 363 364 func (s *mem) clone(data ...interface{}) []interface{} { 365 r := make([]interface{}, len(data)) 366 for i, v := range data { 367 switch x := v.(type) { 368 case nil: 369 // nop 370 case idealComplex: 371 r[i] = complex128(x) 372 case idealFloat: 373 r[i] = float64(x) 374 case idealInt: 375 r[i] = int64(x) 376 case idealRune: 377 r[i] = int32(x) 378 case idealUint: 379 r[i] = uint64(x) 380 case bool: 381 r[i] = x 382 case complex64: 383 r[i] = x 384 case complex128: 385 r[i] = x 386 case float32: 387 r[i] = x 388 case float64: 389 r[i] = x 390 case int: 391 r[i] = int64(x) 392 case int8: 393 r[i] = x 394 case int16: 395 r[i] = x 396 case int32: 397 r[i] = x 398 case int64: 399 r[i] = x 400 case string: 401 r[i] = x 402 case uint: 403 r[i] = uint64(x) 404 case uint8: 405 r[i] = x 406 case uint16: 407 r[i] = x 408 case uint32: 409 r[i] = x 410 case uint64: 411 r[i] = x 412 case []byte: 413 r[i] = append([]byte(nil), x...) 414 case *big.Int: 415 r[i] = big.NewInt(0).Set(x) 416 case *big.Rat: 417 r[i] = big.NewRat(1, 2).Set(x) 418 case time.Time: 419 t := x 420 r[i] = t 421 case time.Duration: 422 r[i] = x 423 case map[string]interface{}: // map of ids of a cross join 424 r[i] = x 425 default: 426 panic("internal error 050") 427 } 428 } 429 return r 430 } 431 432 func (s *mem) Create(data ...interface{}) (h int64, err error) { 433 switch n := len(s.recycler); { 434 case n != 0: 435 h = int64(s.recycler[n-1]) 436 s.recycler = s.recycler[:n-1] 437 s.data[h] = s.clone(data...) 438 r := s.rollback 439 r.list = append(r.list, undo{ 440 tag: undoCreateRecycledHandle, 441 h: h, 442 }) 443 default: 444 h = int64(len(s.data)) 445 s.data = append(s.data, s.clone(data...)) 446 r := s.rollback 447 r.list = append(r.list, undo{ 448 tag: undoCreateNewHandle, 449 h: h, 450 }) 451 } 452 return 453 } 454 455 func (s *mem) Read(dst []interface{}, h int64, cols ...*col) (data []interface{}, err error) { 456 if i := int(h); i != 0 && i < len(s.data) { 457 d := s.clone(s.data[h]...) 458 if cols == nil { 459 return d, nil 460 } 461 462 for n, dn := len(cols)+2, len(d); dn < n; dn++ { 463 d = append(d, nil) 464 } 465 return d, nil 466 } 467 468 return nil, errNoDataForHandle 469 } 470 471 func (s *mem) UpdateRow(h int64, _ []*col, data ...interface{}) (err error) { 472 return s.Update(h, data...) 473 } 474 475 func (s *mem) Update(h int64, data ...interface{}) (err error) { 476 r := s.rollback 477 r.list = append(r.list, undo{ 478 tag: undoUpdate, 479 h: h, 480 data: s.data[h], 481 }) 482 s.data[h] = s.clone(data...) 483 return 484 } 485 486 func (s *mem) Delete(h int64, _ ...*col) (err error) { 487 r := s.rollback 488 r.list = append(r.list, undo{ 489 tag: undoDelete, 490 h: h, 491 data: s.data[h], 492 }) 493 s.recycler = append(s.recycler, int(h)) 494 s.data[h] = nil 495 return 496 } 497 498 func (s *mem) BeginTransaction() (err error) { 499 s.rollback = &undos{parent: s.rollback} 500 s.tnl++ 501 return nil 502 } 503 504 func (s *mem) Rollback() (err error) { 505 if s.tnl == 0 { 506 return errRollbackNotInTransaction 507 } 508 509 list := s.rollback.list 510 for i := len(list) - 1; i >= 0; i-- { 511 undo := list[i] 512 switch h, data := int(undo.h), undo.data; undo.tag { 513 case undoCreateNewHandle: 514 d := s.data 515 s.data = d[:len(d)-1] 516 case undoCreateRecycledHandle: 517 s.data[h] = nil 518 r := s.recycler 519 s.recycler = append(r, h) 520 case undoUpdate: 521 s.data[h] = data 522 case undoDelete: 523 s.data[h] = data 524 s.recycler = s.recycler[:len(s.recycler)-1] 525 case undoClearX: 526 x, t := data[0].(*memIndex), data[1].(*xtree) 527 x.t = t 528 case undoCreateX: 529 x, k := data[0].(*memIndex), data[1].(indexKey) 530 x.t.delete(k) 531 case undoDeleteX: 532 x, k := data[0].(*memIndex), data[1].(indexKey) 533 x.t.Set(k, h) 534 case undoDropX: 535 x, v := data[0].(*memIndex), data[1].(memIndex) 536 *x = v 537 default: 538 panic("internal error 051") 539 } 540 } 541 542 s.tnl-- 543 s.rollback = s.rollback.parent 544 return nil 545 } 546 547 func (s *mem) Commit() (err error) { 548 if s.tnl == 0 { 549 return errCommitNotInTransaction 550 } 551 552 s.tnl-- 553 s.rollback = s.rollback.parent 554 return nil 555 } 556 557 // Transaction index B+Tree 558 //LATER make it just a wrapper of the implementation in btree.go. 559 560 type ( 561 xd struct { // data page 562 c int 563 xd [2*kd + 1]xde 564 n *xd 565 p *xd 566 } 567 568 xde struct { // xd element 569 k indexKey 570 v int 571 } 572 573 // xenumerator captures the state of enumerating a tree. It is returned 574 // from the Seek* methods. The enumerator is aware of any mutations 575 // made to the tree in the process of enumerating it and automatically 576 // resumes the enumeration at the proper key, if possible. 577 // 578 // However, once an xenumerator returns io.EOF to signal "no more 579 // items", it does no more attempt to "resync" on tree mutation(s). In 580 // other words, io.EOF from an Enumaretor is "sticky" (idempotent). 581 xenumerator struct { 582 err error 583 hit bool 584 i int 585 k indexKey 586 q *xd 587 t *xtree 588 ver int64 589 } 590 591 // xtree is a B+tree. 592 xtree struct { 593 c int 594 first *xd 595 last *xd 596 r interface{} 597 ver int64 598 } 599 600 xxe struct { // xx element 601 ch interface{} 602 sep *xd 603 } 604 605 xx struct { // index page 606 c int 607 xx [2*kx + 2]xxe 608 } 609 ) 610 611 func (a *indexKey) cmp(b *indexKey) int { 612 r := collate(a.value, b.value) 613 if r != 0 { 614 return r 615 } 616 617 return int(a.h) - int(b.h) 618 } 619 620 var ( // R/O zero values 621 zxd xd 622 zxde xde 623 zxx xx 624 zxxe xxe 625 ) 626 627 func xclr(q interface{}) { 628 switch xx := q.(type) { 629 case *xx: 630 for i := 0; i <= xx.c; i++ { // Ch0 Sep0 ... Chn-1 Sepn-1 Chn 631 xclr(xx.xx[i].ch) 632 } 633 *xx = zxx // GC 634 case *xd: 635 *xx = zxd // GC 636 } 637 } 638 639 // -------------------------------------------------------------------------- xx 640 641 func xnewX(ch0 interface{}) *xx { 642 r := &xx{} 643 r.xx[0].ch = ch0 644 return r 645 } 646 647 func (q *xx) extract(i int) { 648 q.c-- 649 if i < q.c { 650 copy(q.xx[i:], q.xx[i+1:q.c+1]) 651 q.xx[q.c].ch = q.xx[q.c+1].ch 652 q.xx[q.c].sep = nil // GC 653 q.xx[q.c+1] = zxxe // GC 654 } 655 } 656 657 func (q *xx) insert(i int, xd *xd, ch interface{}) *xx { 658 c := q.c 659 if i < c { 660 q.xx[c+1].ch = q.xx[c].ch 661 copy(q.xx[i+2:], q.xx[i+1:c]) 662 q.xx[i+1].sep = q.xx[i].sep 663 } 664 c++ 665 q.c = c 666 q.xx[i].sep = xd 667 q.xx[i+1].ch = ch 668 return q 669 } 670 671 func (q *xx) siblings(i int) (l, r *xd) { 672 if i >= 0 { 673 if i > 0 { 674 l = q.xx[i-1].ch.(*xd) 675 } 676 if i < q.c { 677 r = q.xx[i+1].ch.(*xd) 678 } 679 } 680 return 681 } 682 683 // -------------------------------------------------------------------------- xd 684 685 func (l *xd) mvL(r *xd, c int) { 686 copy(l.xd[l.c:], r.xd[:c]) 687 copy(r.xd[:], r.xd[c:r.c]) 688 l.c += c 689 r.c -= c 690 } 691 692 func (l *xd) mvR(r *xd, c int) { 693 copy(r.xd[c:], r.xd[:r.c]) 694 copy(r.xd[:c], l.xd[l.c-c:]) 695 r.c += c 696 l.c -= c 697 } 698 699 // ----------------------------------------------------------------------- xtree 700 701 // xtreeNew returns a newly created, empty xtree. The compare function is used 702 // for key collation. 703 func xtreeNew() *xtree { 704 return &xtree{} 705 } 706 707 // Clear removes all K/V pairs from the tree. 708 func (t *xtree) Clear() { 709 if t.r == nil { 710 return 711 } 712 713 xclr(t.r) 714 t.c, t.first, t.last, t.r = 0, nil, nil, nil 715 t.ver++ 716 } 717 718 func (t *xtree) cat(p *xx, q, r *xd, pi int) { 719 t.ver++ 720 q.mvL(r, r.c) 721 if r.n != nil { 722 r.n.p = q 723 } else { 724 t.last = q 725 } 726 q.n = r.n 727 if p.c > 1 { 728 p.extract(pi) 729 p.xx[pi].ch = q 730 } else { 731 t.r = q 732 } 733 } 734 735 func (t *xtree) catX(p, q, r *xx, pi int) { 736 t.ver++ 737 q.xx[q.c].sep = p.xx[pi].sep 738 copy(q.xx[q.c+1:], r.xx[:r.c]) 739 q.c += r.c + 1 740 q.xx[q.c].ch = r.xx[r.c].ch 741 if p.c > 1 { 742 p.c-- 743 pc := p.c 744 if pi < pc { 745 p.xx[pi].sep = p.xx[pi+1].sep 746 copy(p.xx[pi+1:], p.xx[pi+2:pc+1]) 747 p.xx[pc].ch = p.xx[pc+1].ch 748 p.xx[pc].sep = nil // GC 749 p.xx[pc+1].ch = nil // GC 750 } 751 return 752 } 753 754 t.r = q 755 } 756 757 //Delete removes the k's KV pair, if it exists, in which case Delete returns 758 //true. 759 func (t *xtree) delete(k indexKey) (ok bool) { 760 pi := -1 761 var p *xx 762 q := t.r 763 if q == nil { 764 return 765 } 766 767 for { 768 var i int 769 i, ok = t.find(q, k) 770 if ok { 771 switch xx := q.(type) { 772 case *xx: 773 dp := xx.xx[i].sep 774 switch { 775 case dp.c > kd: 776 t.extract(dp, 0) 777 default: 778 if xx.c < kx && q != t.r { 779 t.underflowX(p, &xx, pi, &i) 780 } 781 pi = i + 1 782 p = xx 783 q = xx.xx[pi].ch 784 ok = false 785 continue 786 } 787 case *xd: 788 t.extract(xx, i) 789 if xx.c >= kd { 790 return 791 } 792 793 if q != t.r { 794 t.underflow(p, xx, pi) 795 } else if t.c == 0 { 796 t.Clear() 797 } 798 } 799 return 800 } 801 802 switch xx := q.(type) { 803 case *xx: 804 if xx.c < kx && q != t.r { 805 t.underflowX(p, &xx, pi, &i) 806 } 807 pi = i 808 p = xx 809 q = xx.xx[i].ch 810 case *xd: 811 return 812 } 813 } 814 } 815 816 func (t *xtree) extract(q *xd, i int) { // (r int64) { 817 t.ver++ 818 //r = q.xd[i].v // prepared for Extract 819 q.c-- 820 if i < q.c { 821 copy(q.xd[i:], q.xd[i+1:q.c+1]) 822 } 823 q.xd[q.c] = zxde // GC 824 t.c-- 825 return 826 } 827 828 func (t *xtree) find(q interface{}, k indexKey) (i int, ok bool) { 829 var mk indexKey 830 l := 0 831 switch xx := q.(type) { 832 case *xx: 833 h := xx.c - 1 834 for l <= h { 835 m := (l + h) >> 1 836 mk = xx.xx[m].sep.xd[0].k 837 switch cmp := k.cmp(&mk); { 838 case cmp > 0: 839 l = m + 1 840 case cmp == 0: 841 return m, true 842 default: 843 h = m - 1 844 } 845 } 846 case *xd: 847 h := xx.c - 1 848 for l <= h { 849 m := (l + h) >> 1 850 mk = xx.xd[m].k 851 switch cmp := k.cmp(&mk); { 852 case cmp > 0: 853 l = m + 1 854 case cmp == 0: 855 return m, true 856 default: 857 h = m - 1 858 } 859 } 860 } 861 return l, false 862 } 863 864 // First returns the first item of the tree in the key collating order, or 865 // (nil, nil) if the tree is empty. 866 func (t *xtree) First() (k indexKey, v int) { 867 if q := t.first; q != nil { 868 q := &q.xd[0] 869 k, v = q.k, q.v 870 } 871 return 872 } 873 874 // Get returns the value associated with k and true if it exists. Otherwise Get 875 // returns (nil, false). 876 func (t *xtree) Get(k indexKey) (v int, ok bool) { 877 q := t.r 878 if q == nil { 879 return 880 } 881 882 for { 883 var i int 884 if i, ok = t.find(q, k); ok { 885 switch xx := q.(type) { 886 case *xx: 887 return xx.xx[i].sep.xd[0].v, true 888 case *xd: 889 return xx.xd[i].v, true 890 } 891 } 892 switch xx := q.(type) { 893 case *xx: 894 q = xx.xx[i].ch 895 default: 896 return 897 } 898 } 899 } 900 901 func (t *xtree) insert(q *xd, i int, k indexKey, v int) *xd { 902 t.ver++ 903 c := q.c 904 if i < c { 905 copy(q.xd[i+1:], q.xd[i:c]) 906 } 907 c++ 908 q.c = c 909 q.xd[i].k, q.xd[i].v = k, v 910 t.c++ 911 return q 912 } 913 914 // Last returns the last item of the tree in the key collating order, or (nil, 915 // nil) if the tree is empty. 916 func (t *xtree) Last() (k indexKey, v int) { 917 if q := t.last; q != nil { 918 q := &q.xd[q.c-1] 919 k, v = q.k, q.v 920 } 921 return 922 } 923 924 // Len returns the number of items in the tree. 925 func (t *xtree) Len() int { 926 return t.c 927 } 928 929 func (t *xtree) overflow(p *xx, q *xd, pi, i int, k indexKey, v int) { 930 t.ver++ 931 l, r := p.siblings(pi) 932 933 if l != nil && l.c < 2*kd { 934 l.mvL(q, 1) 935 t.insert(q, i-1, k, v) 936 return 937 } 938 939 if r != nil && r.c < 2*kd { 940 if i < 2*kd { 941 q.mvR(r, 1) 942 t.insert(q, i, k, v) 943 } else { 944 t.insert(r, 0, k, v) 945 } 946 return 947 } 948 949 t.split(p, q, pi, i, k, v) 950 } 951 952 // Seek returns an xenumerator positioned on a an item such that k >= item's 953 // key. ok reports if k == item.key The xenumerator's position is possibly 954 // after the last item in the tree. 955 func (t *xtree) Seek(k indexKey) (e *xenumerator, ok bool) { 956 q := t.r 957 if q == nil { 958 e = &xenumerator{nil, false, 0, k, nil, t, t.ver} 959 return 960 } 961 962 for { 963 var i int 964 if i, ok = t.find(q, k); ok { 965 switch xx := q.(type) { 966 case *xx: 967 e = &xenumerator{nil, ok, 0, k, xx.xx[i].sep, t, t.ver} 968 return 969 case *xd: 970 e = &xenumerator{nil, ok, i, k, xx, t, t.ver} 971 return 972 } 973 } 974 switch xx := q.(type) { 975 case *xx: 976 q = xx.xx[i].ch 977 case *xd: 978 e = &xenumerator{nil, ok, i, k, xx, t, t.ver} 979 return 980 } 981 } 982 } 983 984 // SeekFirst returns an enumerator positioned on the first KV pair in the tree, 985 // if any. For an empty tree, err == io.EOF is returned and e will be nil. 986 func (t *xtree) SeekFirst() (e *xenumerator, err error) { 987 q := t.first 988 if q == nil { 989 return nil, io.EOF 990 } 991 992 return &xenumerator{nil, true, 0, q.xd[0].k, q, t, t.ver}, nil 993 } 994 995 // SeekLast returns an enumerator positioned on the last KV pair in the tree, 996 // if any. For an empty tree, err == io.EOF is returned and e will be nil. 997 func (t *xtree) SeekLast() (e *xenumerator, err error) { 998 q := t.last 999 if q == nil { 1000 return nil, io.EOF 1001 } 1002 1003 return &xenumerator{nil, true, q.c - 1, q.xd[q.c-1].k, q, t, t.ver}, nil 1004 } 1005 1006 // Set sets the value associated with k. 1007 func (t *xtree) Set(k indexKey, v int) { 1008 pi := -1 1009 var p *xx 1010 q := t.r 1011 if q != nil { 1012 for { 1013 i, ok := t.find(q, k) 1014 if ok { 1015 switch xx := q.(type) { 1016 case *xx: 1017 xx.xx[i].sep.xd[0].v = v 1018 case *xd: 1019 xx.xd[i].v = v 1020 } 1021 return 1022 } 1023 1024 switch xx := q.(type) { 1025 case *xx: 1026 if xx.c > 2*kx { 1027 t.splitX(p, &xx, pi, &i) 1028 } 1029 pi = i 1030 p = xx 1031 q = xx.xx[i].ch 1032 case *xd: 1033 switch { 1034 case xx.c < 2*kd: 1035 t.insert(xx, i, k, v) 1036 default: 1037 t.overflow(p, xx, pi, i, k, v) 1038 } 1039 return 1040 } 1041 } 1042 } 1043 1044 z := t.insert(&xd{}, 0, k, v) 1045 t.r, t.first, t.last = z, z, z 1046 return 1047 } 1048 1049 func (t *xtree) split(p *xx, q *xd, pi, i int, k indexKey, v int) { 1050 t.ver++ 1051 r := &xd{} 1052 if q.n != nil { 1053 r.n = q.n 1054 r.n.p = r 1055 } else { 1056 t.last = r 1057 } 1058 q.n = r 1059 r.p = q 1060 1061 copy(r.xd[:], q.xd[kd:2*kd]) 1062 for i := range q.xd[kd:] { 1063 q.xd[kd+i] = zxde 1064 } 1065 q.c = kd 1066 r.c = kd 1067 if pi >= 0 { 1068 p.insert(pi, r, r) 1069 } else { 1070 t.r = xnewX(q).insert(0, r, r) 1071 } 1072 if i > kd { 1073 t.insert(r, i-kd, k, v) 1074 return 1075 } 1076 1077 t.insert(q, i, k, v) 1078 } 1079 1080 func (t *xtree) splitX(p *xx, pp **xx, pi int, i *int) { 1081 t.ver++ 1082 q := *pp 1083 r := &xx{} 1084 copy(r.xx[:], q.xx[kx+1:]) 1085 q.c = kx 1086 r.c = kx 1087 if pi >= 0 { 1088 p.insert(pi, q.xx[kx].sep, r) 1089 } else { 1090 t.r = xnewX(q).insert(0, q.xx[kx].sep, r) 1091 } 1092 q.xx[kx].sep = nil 1093 for i := range q.xx[kx+1:] { 1094 q.xx[kx+i+1] = zxxe 1095 } 1096 if *i > kx { 1097 *pp = r 1098 *i -= kx + 1 1099 } 1100 } 1101 1102 func (t *xtree) underflow(p *xx, q *xd, pi int) { 1103 t.ver++ 1104 l, r := p.siblings(pi) 1105 1106 if l != nil && l.c+q.c >= 2*kd { 1107 l.mvR(q, 1) 1108 } else if r != nil && q.c+r.c >= 2*kd { 1109 q.mvL(r, 1) 1110 r.xd[r.c] = zxde // GC 1111 } else if l != nil { 1112 t.cat(p, l, q, pi-1) 1113 } else { 1114 t.cat(p, q, r, pi) 1115 } 1116 } 1117 1118 func (t *xtree) underflowX(p *xx, pp **xx, pi int, i *int) { 1119 t.ver++ 1120 var l, r *xx 1121 q := *pp 1122 1123 if pi >= 0 { 1124 if pi > 0 { 1125 l = p.xx[pi-1].ch.(*xx) 1126 } 1127 if pi < p.c { 1128 r = p.xx[pi+1].ch.(*xx) 1129 } 1130 } 1131 1132 if l != nil && l.c > kx { 1133 q.xx[q.c+1].ch = q.xx[q.c].ch 1134 copy(q.xx[1:], q.xx[:q.c]) 1135 q.xx[0].ch = l.xx[l.c].ch 1136 q.xx[0].sep = p.xx[pi-1].sep 1137 q.c++ 1138 *i++ 1139 l.c-- 1140 p.xx[pi-1].sep = l.xx[l.c].sep 1141 return 1142 } 1143 1144 if r != nil && r.c > kx { 1145 q.xx[q.c].sep = p.xx[pi].sep 1146 q.c++ 1147 q.xx[q.c].ch = r.xx[0].ch 1148 p.xx[pi].sep = r.xx[0].sep 1149 copy(r.xx[:], r.xx[1:r.c]) 1150 r.c-- 1151 rc := r.c 1152 r.xx[rc].ch = r.xx[rc+1].ch 1153 r.xx[rc].sep = nil 1154 r.xx[rc+1].ch = nil 1155 return 1156 } 1157 1158 if l != nil { 1159 *i += l.c + 1 1160 t.catX(p, l, q, pi-1) 1161 *pp = l 1162 return 1163 } 1164 1165 t.catX(p, q, r, pi) 1166 } 1167 1168 // ----------------------------------------------------------------- xenumerator 1169 1170 // Next returns the currently enumerated item, if it exists and moves to the 1171 // next item in the key collation order. If there is no item to return, err == 1172 // io.EOF is returned. 1173 func (e *xenumerator) Next() (k indexKey, v int64, err error) { 1174 if err = e.err; err != nil { 1175 return 1176 } 1177 1178 if e.ver != e.t.ver { 1179 f, hit := e.t.Seek(e.k) 1180 if !e.hit && hit { 1181 if err = f.next(); err != nil { 1182 return 1183 } 1184 } 1185 1186 *e = *f 1187 } 1188 if e.q == nil { 1189 e.err, err = io.EOF, io.EOF 1190 return 1191 } 1192 1193 if e.i >= e.q.c { 1194 if err = e.next(); err != nil { 1195 return 1196 } 1197 } 1198 1199 i := e.q.xd[e.i] 1200 k, v = i.k, int64(i.v) 1201 e.k, e.hit = k, false 1202 e.next() 1203 return 1204 } 1205 1206 func (e *xenumerator) next() error { 1207 if e.q == nil { 1208 e.err = io.EOF 1209 return io.EOF 1210 } 1211 1212 switch { 1213 case e.i < e.q.c-1: 1214 e.i++ 1215 default: 1216 if e.q, e.i = e.q.n, 0; e.q == nil { 1217 e.err = io.EOF 1218 } 1219 } 1220 return e.err 1221 } 1222 1223 // Prev returns the currently enumerated item, if it exists and moves to the 1224 // previous item in the key collation order. If there is no item to return, err 1225 // == io.EOF is returned. 1226 func (e *xenumerator) Prev() (k indexKey, v int64, err error) { 1227 if err = e.err; err != nil { 1228 return 1229 } 1230 1231 if e.ver != e.t.ver { 1232 f, hit := e.t.Seek(e.k) 1233 if !e.hit && hit { 1234 if err = f.prev(); err != nil { 1235 return 1236 } 1237 } 1238 1239 *e = *f 1240 } 1241 if e.q == nil { 1242 e.err, err = io.EOF, io.EOF 1243 return 1244 } 1245 1246 if e.i >= e.q.c { 1247 if err = e.next(); err != nil { 1248 return 1249 } 1250 } 1251 1252 i := e.q.xd[e.i] 1253 k, v = i.k, int64(i.v) 1254 e.k, e.hit = k, false 1255 e.prev() 1256 return 1257 } 1258 1259 func (e *xenumerator) prev() error { 1260 if e.q == nil { 1261 e.err = io.EOF 1262 return io.EOF 1263 } 1264 1265 switch { 1266 case e.i > 0: 1267 e.i-- 1268 default: 1269 if e.q = e.q.p; e.q == nil { 1270 e.err = io.EOF 1271 break 1272 } 1273 1274 e.i = e.q.c - 1 1275 } 1276 return e.err 1277 }