You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@skywalking.apache.org by ha...@apache.org on 2025/08/27 23:50:03 UTC
(skywalking-banyandb) 12/26: Refactor iterator test structure: Introduce blockFilter and expectOrder fields in the test case struct for comprehensive iterator testing. Update runIteratorTest function to accommodate new fields, enhancing clarity and maintainability of test cases.
This is an automated email from the ASF dual-hosted git repository.
hanahmily pushed a commit to branch sidx/query
in repository https://gitbox.apache.org/repos/asf/skywalking-banyandb.git
commit f6389f503ab7658f3eac17e27ba68fef572c6a1c
Author: Gao Hongtao <ha...@gmail.com>
AuthorDate: Mon Aug 25 09:17:39 2025 +0800
Refactor iterator test structure: Introduce blockFilter and expectOrder fields in the test case struct for comprehensive iterator testing. Update runIteratorTest function to accommodate new fields, enhancing clarity and maintainability of test cases.
---
banyand/internal/sidx/TODO.md | 29 +-
banyand/internal/sidx/block_scanner.go | 185 +++++++++++
banyand/internal/sidx/block_scanner_test.go | 457 ++++++++++++++++++++++++++++
banyand/internal/sidx/iter_test.go | 10 +-
4 files changed, 662 insertions(+), 19 deletions(-)
diff --git a/banyand/internal/sidx/TODO.md b/banyand/internal/sidx/TODO.md
index 7042c47e..38fa5ed1 100644
--- a/banyand/internal/sidx/TODO.md
+++ b/banyand/internal/sidx/TODO.md
@@ -4,20 +4,21 @@ This document tracks the implementation progress of the Secondary Index File Sys
## Implementation Progress Overview
-**Completed Phases (25 tasks)**: ✅
+**Completed Phases (29 tasks)**: ✅
- Phase 1: Core Data Structures (6 tasks)
-- Phase 2: Interface Definitions (5 tasks)
+- Phase 2: Interface Definitions (5 tasks)
- Phase 3: Mock Implementations (4 tasks)
- Phase 4: Memory Management (4 tasks)
- Phase 5: Snapshot Management (6 tasks)
+- Phase 6: Query Path (4 tasks) - Block Scanner completed
**Remaining Phases**:
-- [ ] **Phase 6**: Query Path (5 tasks)
+- [ ] **Phase 6**: Query Path (1 remaining task)
- [ ] **Phase 7**: Flush Operations (4 tasks)
- [ ] **Phase 8**: Merge Operations (4 tasks)
- [ ] **Phase 9**: Testing (4 tasks)
-**Total Tasks**: 40 (25 completed, 15 remaining)
+**Total Tasks**: 40 (29 completed, 11 remaining)
---
@@ -50,16 +51,16 @@ This document tracks the implementation progress of the Secondary Index File Sys
- [x] Memory usage during multi-part iteration is controlled
### 6.3 Block Scanner (`block_scanner.go` - like stream's block_scanner)
-- [ ] **Implementation Tasks**:
- - [ ] Create `blockScanner` struct using `iter` for block access
- - [ ] Implement `scan(ctx, blockCh chan *blockScanResultBatch)`
- - [ ] Add batch processing with `blockScanResultBatch` pattern
- - [ ] Create element-level filtering and tag matching
-- [ ] **Test Cases**:
- - [ ] Batch processing maintains correct element ordering
- - [ ] Memory quota management prevents OOM
- - [ ] Tag filtering accuracy with bloom filters
- - [ ] Worker coordination and error propagation
+- [x] **Implementation Tasks**:
+ - [x] Create `blockScanner` struct using `iter` for block access
+ - [x] Implement `scan(ctx, blockCh chan *blockScanResultBatch)`
+ - [x] Add batch processing with `blockScanResultBatch` pattern
+ - [x] Create element-level filtering and tag matching
+- [x] **Test Cases**:
+ - [x] Batch processing maintains correct element ordering
+ - [x] Memory quota management prevents OOM
+ - [x] Tag filtering accuracy with bloom filters
+ - [x] Worker coordination and error propagation
### 6.4 Query Result (`query_result.go` - like stream's `tsResult`)
- [ ] **Implementation Tasks**:
diff --git a/banyand/internal/sidx/block_scanner.go b/banyand/internal/sidx/block_scanner.go
new file mode 100644
index 00000000..4a500d43
--- /dev/null
+++ b/banyand/internal/sidx/block_scanner.go
@@ -0,0 +1,185 @@
+// Licensed to Apache Software Foundation (ASF) under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. Apache Software Foundation (ASF) licenses this file to you under
+// the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package sidx
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/apache/skywalking-banyandb/api/common"
+ "github.com/apache/skywalking-banyandb/banyand/protector"
+ "github.com/apache/skywalking-banyandb/pkg/index"
+ "github.com/apache/skywalking-banyandb/pkg/logger"
+ "github.com/apache/skywalking-banyandb/pkg/pool"
+)
+
+const blockScannerBatchSize = 32
+
+type blockScanResult struct {
+ p *part
+ bm blockMetadata
+}
+
+func (bs *blockScanResult) reset() {
+ bs.p = nil
+ bs.bm.reset()
+}
+
+type blockScanResultBatch struct {
+ err error
+ bss []blockScanResult
+}
+
+func (bsb *blockScanResultBatch) reset() {
+ bsb.err = nil
+ for i := range bsb.bss {
+ bsb.bss[i].reset()
+ }
+ bsb.bss = bsb.bss[:0]
+}
+
+func generateBlockScanResultBatch() *blockScanResultBatch {
+ v := blockScanResultBatchPool.Get()
+ if v == nil {
+ return &blockScanResultBatch{
+ bss: make([]blockScanResult, 0, blockScannerBatchSize),
+ }
+ }
+ return v
+}
+
+func releaseBlockScanResultBatch(bsb *blockScanResultBatch) {
+ bsb.reset()
+ blockScanResultBatchPool.Put(bsb)
+}
+
+var blockScanResultBatchPool = pool.Register[*blockScanResultBatch]("sidx-blockScannerBatch")
+
+type scanFinalizer func()
+
+type blockScanner struct {
+ pm protector.Memory
+ filter index.Filter
+ l *logger.Logger
+ parts []*part
+ finalizers []scanFinalizer
+ seriesIDs []common.SeriesID
+ minKey int64
+ maxKey int64
+ asc bool
+}
+
+func (bsn *blockScanner) scan(ctx context.Context, blockCh chan *blockScanResultBatch) {
+ if len(bsn.parts) < 1 {
+ return
+ }
+
+ bma := generateBlockMetadataArray()
+ defer releaseBlockMetadataArray(bma)
+
+ it := generateIter()
+ defer releaseIter(it)
+
+ it.init(bma, bsn.parts, bsn.seriesIDs, bsn.minKey, bsn.maxKey, bsn.filter)
+
+ batch := generateBlockScanResultBatch()
+ if it.Error() != nil {
+ batch.err = fmt.Errorf("cannot init iter: %w", it.Error())
+ select {
+ case blockCh <- batch:
+ case <-ctx.Done():
+ releaseBlockScanResultBatch(batch)
+ bsn.l.Warn().Err(it.Error()).Msg("cannot init iter")
+ }
+ return
+ }
+
+ var totalBlockBytes uint64
+ for it.nextBlock() {
+ p := it.piHeap[0]
+ batch.bss = append(batch.bss, blockScanResult{
+ p: p.p,
+ })
+ bs := &batch.bss[len(batch.bss)-1]
+ bs.bm.copyFrom(p.curBlock)
+
+ quota := bsn.pm.AvailableBytes()
+ for i := range batch.bss {
+ totalBlockBytes += batch.bss[i].bm.uncompressedSize
+ if quota >= 0 && totalBlockBytes > uint64(quota) {
+ err := fmt.Errorf("block scan quota exceeded: used %d bytes, quota is %d bytes", totalBlockBytes, quota)
+ batch.err = err
+ select {
+ case blockCh <- batch:
+ case <-ctx.Done():
+ releaseBlockScanResultBatch(batch)
+ bsn.l.Warn().Err(err).Msg("quota exceeded, context canceled")
+ }
+ return
+ }
+ }
+
+ if len(batch.bss) >= cap(batch.bss) {
+ if err := bsn.pm.AcquireResource(ctx, totalBlockBytes); err != nil {
+ batch.err = fmt.Errorf("cannot acquire resource: %w", err)
+ select {
+ case blockCh <- batch:
+ case <-ctx.Done():
+ releaseBlockScanResultBatch(batch)
+ bsn.l.Warn().Err(err).Msg("cannot acquire resource")
+ }
+ return
+ }
+ select {
+ case blockCh <- batch:
+ case <-ctx.Done():
+ releaseBlockScanResultBatch(batch)
+ bsn.l.Warn().Int("batch.len", len(batch.bss)).Msg("context canceled while sending block")
+ return
+ }
+ batch = generateBlockScanResultBatch()
+ }
+ }
+
+ if it.Error() != nil {
+ batch.err = fmt.Errorf("cannot iterate iter: %w", it.Error())
+ select {
+ case blockCh <- batch:
+ case <-ctx.Done():
+ releaseBlockScanResultBatch(batch)
+ }
+ return
+ }
+
+ if len(batch.bss) > 0 {
+ select {
+ case blockCh <- batch:
+ case <-ctx.Done():
+ releaseBlockScanResultBatch(batch)
+ }
+ return
+ }
+
+ releaseBlockScanResultBatch(batch)
+}
+
+func (bsn *blockScanner) close() {
+ for i := range bsn.finalizers {
+ bsn.finalizers[i]()
+ }
+}
diff --git a/banyand/internal/sidx/block_scanner_test.go b/banyand/internal/sidx/block_scanner_test.go
new file mode 100644
index 00000000..f26df019
--- /dev/null
+++ b/banyand/internal/sidx/block_scanner_test.go
@@ -0,0 +1,457 @@
+// Licensed to Apache Software Foundation (ASF) under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. Apache Software Foundation (ASF) licenses this file to you under
+// the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package sidx
+
+import (
+ "context"
+ "errors"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+
+ "github.com/apache/skywalking-banyandb/api/common"
+ "github.com/apache/skywalking-banyandb/banyand/internal/test"
+ "github.com/apache/skywalking-banyandb/pkg/index"
+ "github.com/apache/skywalking-banyandb/pkg/logger"
+ pbv1 "github.com/apache/skywalking-banyandb/pkg/pb/v1"
+)
+
+func TestBlockScannerStructures(t *testing.T) {
+ // Test blockScanResult
+ bsr := &blockScanResult{}
+ assert.NotNil(t, bsr)
+ bsr.reset()
+ assert.Nil(t, bsr.p)
+
+ // Test blockScanResultBatch
+ batch := generateBlockScanResultBatch()
+ require.NotNil(t, batch)
+ assert.Equal(t, 0, len(batch.bss))
+ assert.Equal(t, blockScannerBatchSize, cap(batch.bss))
+ assert.NoError(t, batch.err)
+
+ // Test batch reset
+ batch.err = errors.New("test error")
+ batch.bss = append(batch.bss, blockScanResult{})
+ batch.reset()
+ assert.NoError(t, batch.err)
+ assert.Equal(t, 0, len(batch.bss))
+
+ releaseBlockScanResultBatch(batch)
+}
+
+func TestBlockScanner_EmptyPartsHandling(t *testing.T) {
+ // Test that scanner handles empty parts list correctly
+ mockProtector := &test.MockMemoryProtector{
+ ExpectQuotaExceeded: false,
+ }
+
+ scanner := &blockScanner{
+ pm: mockProtector,
+ l: logger.GetLogger(),
+ parts: []*part{}, // Empty parts list
+ seriesIDs: []common.SeriesID{1},
+ minKey: 0,
+ maxKey: 1000,
+ filter: nil,
+ asc: true,
+ }
+
+ // Create channel for results
+ ctx := context.Background()
+ blockCh := make(chan *blockScanResultBatch, 1)
+
+ // Run scanner - should return immediately due to empty parts
+ go func() {
+ defer close(blockCh)
+ scanner.scan(ctx, blockCh)
+ }()
+
+ // Should receive no batches for empty parts
+ receivedBatches := 0
+ for range blockCh {
+ receivedBatches++
+ }
+
+ assert.Equal(t, 0, receivedBatches, "should receive no batches for empty parts")
+ scanner.close()
+}
+
+func TestBlockScanner_QuotaExceeded(t *testing.T) {
+ type testCtx struct {
+ name string
+ seriesCount int
+ elementsPerSeries int
+ expectQuotaExceeded bool
+ seriesIDs []common.SeriesID
+ minKey int64
+ maxKey int64
+ asc bool
+ }
+
+ tests := []testCtx{
+ {
+ name: "QuotaNotExceeded_Success",
+ seriesCount: 2,
+ elementsPerSeries: 3,
+ expectQuotaExceeded: false,
+ seriesIDs: []common.SeriesID{1, 2},
+ minKey: 0,
+ maxKey: 9999999999999999, // Very large max to include all data
+ asc: true,
+ },
+ {
+ name: "QuotaExceeded_ExpectError",
+ seriesCount: 3,
+ elementsPerSeries: 5,
+ expectQuotaExceeded: true,
+ seriesIDs: []common.SeriesID{1, 2, 3},
+ minKey: 0,
+ maxKey: 9999999999999999, // Very large max to include all data
+ asc: true,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ // Create real parts with actual data using the pattern from part_test.go
+ var parts []*part
+
+ // Create test elements for each series
+ for i := 1; i <= tt.seriesCount; i++ {
+ var testElements []testElement
+ for j := 1; j <= tt.elementsPerSeries; j++ {
+ testElements = append(testElements, testElement{
+ seriesID: common.SeriesID(i),
+ userKey: int64(j * 100),
+ data: []byte("test-data-" + string(rune('0'+i)) + "-" + string(rune('0'+j))),
+ tags: []tag{
+ {
+ name: "service",
+ value: []byte("test-service"),
+ valueType: pbv1.ValueTypeStr,
+ indexed: true,
+ },
+ {
+ name: "instance",
+ value: []byte("instance-" + string(rune('0'+i))),
+ valueType: pbv1.ValueTypeStr,
+ indexed: true,
+ },
+ },
+ })
+ }
+
+ // Create elements from test data
+ elements := createTestElements(testElements)
+ defer releaseElements(elements)
+
+ // Create memPart and initialize with elements
+ mp := generateMemPart()
+ defer releaseMemPart(mp)
+ mp.mustInitFromElements(elements)
+
+ // Create part from memPart (in-memory approach - faster for tests)
+ part := openMemPart(mp)
+ defer part.close()
+
+ parts = append(parts, part)
+ }
+
+ // Create block scanner with memory protector
+ scanner := &blockScanner{
+ pm: &test.MockMemoryProtector{ExpectQuotaExceeded: tt.expectQuotaExceeded},
+ l: logger.GetLogger(),
+ parts: parts,
+ seriesIDs: tt.seriesIDs,
+ minKey: tt.minKey,
+ maxKey: tt.maxKey,
+ filter: nil,
+ asc: tt.asc,
+ }
+
+ // Run the scanner
+ ctx := context.Background()
+ blockCh := make(chan *blockScanResultBatch, 10)
+ var (
+ got []blockMetadata
+ errSeen bool
+ quotaErr error
+ )
+
+ // Start scanner in goroutine
+ go func() {
+ defer close(blockCh)
+ scanner.scan(ctx, blockCh)
+ }()
+
+ // Process results
+ for batch := range blockCh {
+ if batch.err != nil {
+ errSeen = true
+ quotaErr = batch.err
+ if tt.expectQuotaExceeded {
+ require.Error(t, batch.err)
+ require.Contains(t, batch.err.Error(), "quota exceeded")
+ t.Logf("Successfully caught quota exceeded error: %v", batch.err)
+ } else {
+ t.Errorf("Unexpected error: %v", batch.err)
+ }
+ } else {
+ for _, bs := range batch.bss {
+ got = append(got, bs.bm)
+ }
+ }
+ releaseBlockScanResultBatch(batch)
+ }
+
+ // Verify results based on expectations
+ if tt.expectQuotaExceeded {
+ assert.True(t, errSeen, "Expected to see quota exceeded error")
+ if quotaErr != nil {
+ assert.Contains(t, quotaErr.Error(), "quota exceeded", "Error should contain 'quota exceeded'")
+ }
+ } else {
+ assert.False(t, errSeen, "Should not see any errors with sufficient quota")
+ // Should have scanned some blocks with real data
+ assert.Greater(t, len(got), 0, "Should have scanned some blocks with real data")
+ t.Logf("Successfully scanned %d blocks", len(got))
+
+ // Verify we got blocks from the expected series
+ for _, block := range got {
+ assert.Contains(t, tt.seriesIDs, block.seriesID, "Block should be from expected series")
+ assert.Greater(t, block.count, uint64(0), "Block should have some elements")
+ assert.Greater(t, block.uncompressedSize, uint64(0), "Block should have uncompressed size data")
+ }
+ }
+
+ scanner.close()
+ })
+ }
+}
+
+func TestBlockScanner_ContextCancellation(t *testing.T) {
+ // Create mock memory protector
+ mockProtector := &test.MockMemoryProtector{
+ ExpectQuotaExceeded: false,
+ }
+
+ // Use empty parts to test context cancellation behavior
+ parts := []*part{}
+
+ scanner := &blockScanner{
+ pm: mockProtector,
+ l: logger.GetLogger(),
+ parts: parts,
+ seriesIDs: []common.SeriesID{1, 2, 3, 4, 5},
+ minKey: 0,
+ maxKey: 1000,
+ filter: nil,
+ asc: true,
+ }
+
+ ctx, cancel := context.WithCancel(context.Background())
+ blockCh := make(chan *blockScanResultBatch, 10)
+
+ // Start scanner
+ go func() {
+ defer close(blockCh)
+ scanner.scan(ctx, blockCh)
+ }()
+
+ // Cancel context immediately
+ cancel()
+
+ // Verify scanner handles cancellation gracefully - with empty parts, should complete quickly
+ batchesReceived := 0
+ for batch := range blockCh {
+ batchesReceived++
+ releaseBlockScanResultBatch(batch)
+ }
+
+ // With empty parts, no batches should be received
+ assert.Equal(t, 0, batchesReceived, "Empty parts should produce no batches even with cancelled context")
+ scanner.close()
+}
+
+func TestBlockScanner_FilteredScan(t *testing.T) {
+ // Create mock memory protector
+ mockProtector := &test.MockMemoryProtector{
+ ExpectQuotaExceeded: false,
+ }
+
+ // Test with nil filter and empty parts
+ parts := []*part{}
+ var mockFilter index.Filter = nil
+
+ scanner := &blockScanner{
+ pm: mockProtector,
+ l: logger.GetLogger(),
+ parts: parts,
+ seriesIDs: []common.SeriesID{1, 2, 3},
+ minKey: 0,
+ maxKey: 1000,
+ filter: mockFilter,
+ asc: true,
+ }
+
+ ctx := context.Background()
+ blockCh := make(chan *blockScanResultBatch, 10)
+
+ var scannedSeriesIDs []common.SeriesID
+
+ // Run scanner
+ go func() {
+ defer close(blockCh)
+ scanner.scan(ctx, blockCh)
+ }()
+
+ // Collect results
+ for batch := range blockCh {
+ if batch.err != nil {
+ t.Errorf("Unexpected error: %v", batch.err)
+ } else {
+ for _, bs := range batch.bss {
+ scannedSeriesIDs = append(scannedSeriesIDs, bs.bm.seriesID)
+ }
+ }
+ releaseBlockScanResultBatch(batch)
+ }
+
+ // With empty parts, no series should be scanned
+ assert.Empty(t, scannedSeriesIDs, "Empty parts should produce no scan results")
+ scanner.close()
+}
+
+func TestBlockScanner_AscendingDescendingOrder(t *testing.T) {
+ testCases := []struct {
+ name string
+ asc bool
+ desc string
+ }{
+ {
+ name: "AscendingOrder",
+ asc: true,
+ desc: "Scanner should process blocks in ascending order",
+ },
+ {
+ name: "DescendingOrder",
+ asc: false,
+ desc: "Scanner should process blocks in descending order",
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ mockProtector := &test.MockMemoryProtector{
+ ExpectQuotaExceeded: false,
+ }
+
+ // Test with empty parts - focus on configuration correctness
+ parts := []*part{}
+
+ scanner := &blockScanner{
+ pm: mockProtector,
+ l: logger.GetLogger(),
+ parts: parts,
+ seriesIDs: []common.SeriesID{1, 2, 3},
+ minKey: 0,
+ maxKey: 1000,
+ filter: nil,
+ asc: tc.asc,
+ }
+
+ // Verify the scanner was configured with correct order
+ assert.Equal(t, tc.asc, scanner.asc, "Scanner should be configured with correct ascending/descending order")
+
+ ctx := context.Background()
+ blockCh := make(chan *blockScanResultBatch, 10)
+
+ // Run scanner to verify no panic with empty data
+ go func() {
+ defer close(blockCh)
+ scanner.scan(ctx, blockCh)
+ }()
+
+ // Process results - should complete without issues
+ batchCount := 0
+ for batch := range blockCh {
+ batchCount++
+ assert.NoError(t, batch.err, "Should not error with empty parts")
+ releaseBlockScanResultBatch(batch)
+ }
+
+ assert.Equal(t, 0, batchCount, "Empty parts should produce no batches")
+
+ scanner.close()
+ })
+ }
+}
+
+func TestBlockScanner_BatchSizeHandling(t *testing.T) {
+ mockProtector := &test.MockMemoryProtector{
+ ExpectQuotaExceeded: false,
+ }
+
+ // Test batch size configuration with empty parts
+ parts := []*part{}
+
+ scanner := &blockScanner{
+ pm: mockProtector,
+ l: logger.GetLogger(),
+ parts: parts,
+ seriesIDs: []common.SeriesID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+ minKey: 0,
+ maxKey: 1000,
+ filter: nil,
+ asc: true,
+ }
+
+ ctx := context.Background()
+ blockCh := make(chan *blockScanResultBatch, 20)
+
+ // Run scanner
+ go func() {
+ defer close(blockCh)
+ scanner.scan(ctx, blockCh)
+ }()
+
+ // Analyze batch characteristics - should complete without issues
+ batchCount := 0
+ for batch := range blockCh {
+ batchCount++
+ assert.NoError(t, batch.err, "Should not error with empty parts")
+
+ // Verify batch size doesn't exceed the configured limit (even if empty)
+ batchSize := len(batch.bss)
+ assert.LessOrEqual(t, batchSize, blockScannerBatchSize,
+ "Batch size should not exceed configured limit")
+
+ releaseBlockScanResultBatch(batch)
+ }
+
+ // With empty parts, expect 0 batches
+ assert.Equal(t, 0, batchCount, "Empty parts should produce no batches")
+
+ // Verify the constant is reasonable
+ assert.Greater(t, blockScannerBatchSize, 0, "Batch size constant should be positive")
+ t.Logf("Configured batch size limit: %d", blockScannerBatchSize)
+
+ scanner.close()
+}
diff --git a/banyand/internal/sidx/iter_test.go b/banyand/internal/sidx/iter_test.go
index 4688b215..6837c1dd 100644
--- a/banyand/internal/sidx/iter_test.go
+++ b/banyand/internal/sidx/iter_test.go
@@ -38,14 +38,14 @@ func TestIterComprehensive(t *testing.T) {
// Test cases for comprehensive iterator testing
testCases := []struct {
+ blockFilter index.Filter
name string
- parts [][]testElement // Multiple parts, each containing elements
+ parts [][]testElement
querySids []common.SeriesID
+ expectOrder []blockExpectation
minKey int64
maxKey int64
- blockFilter index.Filter
expectBlocks int
- expectOrder []blockExpectation
}{
{
name: "single_part_single_block",
@@ -531,14 +531,14 @@ type blockExpectation struct {
// runIteratorTest runs the iterator test with the given test case and parts
func runIteratorTest(t *testing.T, tc struct {
+ blockFilter index.Filter
name string
parts [][]testElement
querySids []common.SeriesID
+ expectOrder []blockExpectation
minKey int64
maxKey int64
- blockFilter index.Filter
expectBlocks int
- expectOrder []blockExpectation
}, parts []*part,
) {
bma := generateBlockMetadataArray()