Skip to content

Commit 69ed18b

Browse files
miaozwmiaozw
committed
1 parent 2cba4f1 commit 69ed18b

File tree

1 file changed

+64
-60
lines changed

1 file changed

+64
-60
lines changed

‎db.go‎

Lines changed: 64 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -446,68 +446,70 @@ func (db *DB) AscendGreaterOrEqual(key []byte, handleFn func(k []byte, v []byte)
446446
// Since our expiry time is stored in the value, if you want to filter expired keys,
447447
// you need to set parameter filterExpired to true. But the performance will be affected.
448448
// Because we need to read the value of each key to determine if it is expired.
449-
func (db *DB) AscendKeys(pattern []byte, filterExpired bool, handleFn func(k []byte) (bool, error)) {
449+
func (db *DB) AscendKeys(pattern []byte, filterExpired bool, handleFn func(k []byte) (bool, error)) error {
450450
db.mu.RLock()
451451
defer db.mu.RUnlock()
452452

453453
var reg *regexp.Regexp
454454
if len(pattern) > 0 {
455-
reg = regexp.MustCompile(string(pattern))
455+
var err error
456+
reg, err = regexp.Compile(string(pattern))
457+
if err != nil {
458+
return err
459+
}
456460
}
457461

458462
db.index.Ascend(func(key []byte, pos *wal.ChunkPosition) (bool, error) {
459-
if reg == nil || reg.Match(key) {
460-
var invalid bool
461-
if filterExpired {
462-
chunk, err := db.dataFiles.Read(pos)
463-
if err != nil {
464-
return false, err
465-
}
466-
if value := db.checkValue(chunk); value == nil {
467-
invalid = true
468-
}
463+
if reg != nil && !reg.Match(key) {
464+
return true, nil
465+
}
466+
if filterExpired {
467+
chunk, err := db.dataFiles.Read(pos)
468+
if err != nil {
469+
return false, err
469470
}
470-
if invalid {
471+
if value := db.checkValue(chunk); value == nil {
471472
return true, nil
472473
}
473-
return handleFn(key)
474474
}
475-
return true, nil
475+
return handleFn(key)
476476
})
477+
return nil
477478
}
478479

479480
// AscendKeysRange calls handleFn for keys within a range in the db in ascending order.
480481
// Since our expiry time is stored in the value, if you want to filter expired keys,
481482
// you need to set parameter filterExpired to true. But the performance will be affected.
482483
// Because we need to read the value of each key to determine if it is expired.
483-
func (db *DB) AscendKeysRange(startKey, endKey, pattern []byte, filterExpired bool, handleFn func(k []byte) (bool, error)) {
484+
func (db *DB) AscendKeysRange(startKey, endKey, pattern []byte, filterExpired bool, handleFn func(k []byte) (bool, error)) error {
484485
db.mu.RLock()
485486
defer db.mu.RUnlock()
486487

487488
var reg *regexp.Regexp
488489
if len(pattern) > 0 {
489-
reg = regexp.MustCompile(string(pattern))
490+
var err error
491+
reg, err = regexp.Compile(string(pattern))
492+
if err != nil {
493+
return err
494+
}
490495
}
491496

492497
db.index.AscendRange(startKey, endKey, func(key []byte, pos *wal.ChunkPosition) (bool, error) {
493-
if reg == nil || reg.Match(key) {
494-
var invalid bool
495-
if filterExpired {
496-
chunk, err := db.dataFiles.Read(pos)
497-
if err != nil {
498-
return false, err
499-
}
500-
if value := db.checkValue(chunk); value == nil {
501-
invalid = true
502-
}
498+
if reg != nil && !reg.Match(key) {
499+
return true, nil
500+
}
501+
if filterExpired {
502+
chunk, err := db.dataFiles.Read(pos)
503+
if err != nil {
504+
return false, err
503505
}
504-
if invalid {
506+
if value := db.checkValue(chunk); value == nil {
505507
return true, nil
506508
}
507-
return handleFn(key)
508509
}
509-
return true, nil
510+
return handleFn(key)
510511
})
512+
return nil
511513
}
512514

513515
// Descend calls handleFn for each key/value pair in the db in descending order.
@@ -565,68 +567,70 @@ func (db *DB) DescendLessOrEqual(key []byte, handleFn func(k []byte, v []byte) (
565567
// Since our expiry time is stored in the value, if you want to filter expired keys,
566568
// you need to set parameter filterExpired to true. But the performance will be affected.
567569
// Because we need to read the value of each key to determine if it is expired.
568-
func (db *DB) DescendKeys(pattern []byte, filterExpired bool, handleFn func(k []byte) (bool, error)) {
570+
func (db *DB) DescendKeys(pattern []byte, filterExpired bool, handleFn func(k []byte) (bool, error)) error {
569571
db.mu.RLock()
570572
defer db.mu.RUnlock()
571573

572574
var reg *regexp.Regexp
573575
if len(pattern) > 0 {
574-
reg = regexp.MustCompile(string(pattern))
576+
var err error
577+
reg, err = regexp.Compile(string(pattern))
578+
if err != nil {
579+
return err
580+
}
575581
}
576582

577583
db.index.Descend(func(key []byte, pos *wal.ChunkPosition) (bool, error) {
578-
if reg == nil || reg.Match(key) {
579-
var invalid bool
580-
if filterExpired {
581-
chunk, err := db.dataFiles.Read(pos)
582-
if err != nil {
583-
return false, err
584-
}
585-
if value := db.checkValue(chunk); value == nil {
586-
invalid = true
587-
}
584+
if reg != nil && !reg.Match(key) {
585+
return true, nil
586+
}
587+
if filterExpired {
588+
chunk, err := db.dataFiles.Read(pos)
589+
if err != nil {
590+
return false, err
588591
}
589-
if invalid {
592+
if value := db.checkValue(chunk); value == nil {
590593
return true, nil
591594
}
592-
return handleFn(key)
593595
}
594-
return true, nil
596+
return handleFn(key)
595597
})
598+
return nil
596599
}
597600

598601
// DescendKeysRange calls handleFn for keys within a range in the db in descending order.
599602
// Since our expiry time is stored in the value, if you want to filter expired keys,
600603
// you need to set parameter filterExpired to true. But the performance will be affected.
601604
// Because we need to read the value of each key to determine if it is expired.
602-
func (db *DB) DescendKeysRange(startKey, endKey, pattern []byte, filterExpired bool, handleFn func(k []byte) (bool, error)) {
605+
func (db *DB) DescendKeysRange(startKey, endKey, pattern []byte, filterExpired bool, handleFn func(k []byte) (bool, error)) error {
603606
db.mu.RLock()
604607
defer db.mu.RUnlock()
605608

606609
var reg *regexp.Regexp
607610
if len(pattern) > 0 {
608-
reg = regexp.MustCompile(string(pattern))
611+
var err error
612+
reg, err = regexp.Compile(string(pattern))
613+
if err != nil {
614+
return err
615+
}
609616
}
610617

611618
db.index.DescendRange(startKey, endKey, func(key []byte, pos *wal.ChunkPosition) (bool, error) {
612-
if reg == nil || reg.Match(key) {
613-
var invalid bool
614-
if filterExpired {
615-
chunk, err := db.dataFiles.Read(pos)
616-
if err != nil {
617-
return false, err
618-
}
619-
if value := db.checkValue(chunk); value == nil {
620-
invalid = true
621-
}
619+
if reg != nil && !reg.Match(key) {
620+
return true, nil
621+
}
622+
if filterExpired {
623+
chunk, err := db.dataFiles.Read(pos)
624+
if err != nil {
625+
return false, err
622626
}
623-
if invalid {
627+
if value := db.checkValue(chunk); value == nil {
624628
return true, nil
625629
}
626-
return handleFn(key)
627630
}
628-
return true, nil
631+
return handleFn(key)
629632
})
633+
return nil
630634
}
631635

632636
func (db *DB) checkValue(chunk []byte) []byte {

0 commit comments

Comments
 (0)