Table.Get SelectorRange implementation

filter_test.go

@@ -231,7 +231,7 @@ func TestFilter_Upsert(t *testing.T) {
 
 	mFilter.On("MayContain", mock.Anything, mock.Anything).Return(true).Once()
 
-	dbTr, err := tokenBalanceTable.Get(NewSelectorPoint(tokenBalanceAccountUpdated))
+	dbTr, err := tokenBalanceTable.Get(context.Background(), NewSelectorPoint(tokenBalanceAccountUpdated))
 	require.NoError(t, err)
 	assert.Equal(t, tokenBalanceAccountUpdated, dbTr[0])
 
@@ -270,7 +270,7 @@ func TestFilter_Get(t *testing.T) {
 
 	mFilter.On("MayContain", mock.Anything, mock.Anything).Return(false).Once()
 
-	_, err := tokenBalanceTable.Get(NewSelectorPoint(tokenBalanceAccount))
+	_, err := tokenBalanceTable.Get(context.Background(), NewSelectorPoint(tokenBalanceAccount))
 	require.Error(t, err)
 
 	mFilter.On("MayContain", mock.Anything, mock.Anything).Return(false).Once()
@@ -281,7 +281,7 @@ func TestFilter_Get(t *testing.T) {
 
 	mFilter.On("MayContain", mock.Anything, mock.Anything).Return(true).Once()
 
-	dbTr, err := tokenBalanceTable.Get(NewSelectorPoint(tokenBalanceAccount))
+	dbTr, err := tokenBalanceTable.Get(context.Background(), NewSelectorPoint(tokenBalanceAccount))
 	require.NoError(t, err)
 	assert.Equal(t, tokenBalanceAccount, dbTr[0])
 

index.go

@@ -200,6 +200,8 @@ func (idx *Index[T]) Iter(table Table[T], selector Selector[T], optBatch ...Batc
 		upperBound = encodeIndexKey(table, up, idx, keyBufferPool.Get()[:0])
 		if bytes.Equal(lowerBound, upperBound) {
 			upperBound = keySuccessor(lowerBound[0:_KeyPrefixSplitIndex(lowerBound)], upperBound[:0])
+		} else {
+			upperBound = keySuccessor(upperBound, upperBound[:0])
 		}
 	default:
 		panic("invalid selector type")

table.go

@@ -39,7 +39,7 @@ type TableInfo interface {
 }
 
 type TableGetter[T any] interface {
-	Get(sel Selector[T], optBatch ...Batch) ([]T, error)
+	Get(ctx context.Context, sel Selector[T], optBatch ...Batch) ([]T, error)
 }
 
 type TableExistChecker[T any] interface {
@@ -816,7 +816,7 @@ func (t *_table[T]) exist(key []byte, batch Batch, iter Iterator) bool {
 	return iter.SeekGE(key) && bytes.Equal(iter.Key(), key)
 }
 
-func (t *_table[T]) Get(sel Selector[T], optBatch ...Batch) ([]T, error) {
+func (t *_table[T]) Get(ctx context.Context, sel Selector[T], optBatch ...Batch) ([]T, error) {
 	var batch Batch
 	if len(optBatch) > 0 && optBatch[0] != nil {
 		batch = optBatch[0]
@@ -851,6 +851,15 @@ func (t *_table[T]) Get(sel Selector[T], optBatch ...Batch) ([]T, error) {
 		}
 
 		return []T{rtr}, nil
+	case SelectorTypeRange:
+		var trs []T
+
+		err := t.ScanIndex(ctx, t.primaryIndex, sel, &trs, optBatch...)
+		if err != nil {
+			return nil, err
+		}
+
+		return trs, nil
 	default:
 		return nil, fmt.Errorf("invalid selector type")
 	}

table_test.go

@@ -169,6 +169,100 @@ func TestBondTable_SerializerOption(t *testing.T) {
 	assert.NotNil(t, tokenBalanceTable.Serializer())
 }
 
+func TestBondTable_Get(t *testing.T) {
+	db := setupDatabase()
+	defer tearDownDatabase(db)
+
+	const (
+		TokenBalanceTableID TableID = 0xC0
+	)
+
+	tokenBalanceTable := NewTable[*TokenBalance](TableOptions[*TokenBalance]{
+		DB:        db,
+		TableID:   TokenBalanceTableID,
+		TableName: "token_balance",
+		TablePrimaryKeyFunc: func(builder KeyBuilder, tb *TokenBalance) []byte {
+			return builder.AddUint64Field(tb.ID).Bytes()
+		},
+		Serializer: &serializers.JsonSerializer{},
+	})
+	require.NotNil(t, tokenBalanceTable)
+
+	// token balances to insert
+	tokenBalanceAccount1 := &TokenBalance{
+		ID:              1,
+		AccountID:       1,
+		ContractAddress: "0xtestContract",
+		AccountAddress:  "0xtestAccount",
+		Balance:         5,
+	}
+
+	err := tokenBalanceTable.Insert(context.Background(), []*TokenBalance{tokenBalanceAccount1})
+	require.NoError(t, err)
+
+	// get token balance
+	tokenBalance, err := tokenBalanceTable.Get(context.Background(), NewSelectorPoint(&TokenBalance{ID: tokenBalanceAccount1.ID}))
+	require.NoError(t, err)
+	assert.Equal(t, tokenBalanceAccount1, tokenBalance[0])
+
+	// get token balance with non-existing id
+	tokenBalance, err = tokenBalanceTable.Get(context.Background(), NewSelectorPoint(&TokenBalance{ID: 2}))
+	require.Error(t, err)
+	assert.Nil(t, tokenBalance)
+}
+
+func TestBondTable_Get_Range(t *testing.T) {
+	db := setupDatabase()
+	defer tearDownDatabase(db)
+
+	const (
+		TokenBalanceTableID TableID = 0xC0
+	)
+
+	tokenBalanceTable := NewTable[*TokenBalance](TableOptions[*TokenBalance]{
+		DB:        db,
+		TableID:   TokenBalanceTableID,
+		TableName: "token_balance",
+		TablePrimaryKeyFunc: func(builder KeyBuilder, tb *TokenBalance) []byte {
+			return builder.AddUint64Field(tb.ID).Bytes()
+		},
+		Serializer: &serializers.JsonSerializer{},
+	})
+	require.NotNil(t, tokenBalanceTable)
+
+	// token balances to insert
+	expectedTokenBalances := []*TokenBalance{
+		{
+			ID:              1,
+			AccountID:       1,
+			ContractAddress: "0xtestContract",
+			AccountAddress:  "0xtestAccount",
+			Balance:         5,
+		},
+		{
+			ID:              2,
+			AccountID:       1,
+			ContractAddress: "0xtestContract",
+			AccountAddress:  "0xtestAccount",
+			Balance:         5,
+		},
+	}
+
+	err := tokenBalanceTable.Insert(context.Background(), expectedTokenBalances)
+	require.NoError(t, err)
+
+	// get token balances with range
+	tokenBalances, err := tokenBalanceTable.Get(context.Background(), NewSelectorRange(&TokenBalance{ID: 1}, &TokenBalance{ID: 2}))
+	require.NoError(t, err)
+	require.Equal(t, len(expectedTokenBalances), len(tokenBalances))
+	assert.Equal(t, expectedTokenBalances, tokenBalances)
+
+	// get token balance with non-existing id range
+	tokenBalances, err = tokenBalanceTable.Get(context.Background(), NewSelectorRange(&TokenBalance{ID: 3}, &TokenBalance{ID: 4}))
+	require.NoError(t, err)
+	assert.Equal(t, 0, len(tokenBalances))
+}
+
 func TestBondTable_Insert(t *testing.T) {
 	db := setupDatabase()
 	defer tearDownDatabase(db)
@@ -1162,7 +1256,7 @@ func TestBond_Batch(t *testing.T) {
 	exist := tokenBalanceTable.Exist(&TokenBalance{ID: 1}, batch)
 	require.True(t, exist)
 
-	tokenBalance, err := tokenBalanceTable.Get(NewSelectorPoint(&TokenBalance{ID: 1}), batch)
+	tokenBalance, err := tokenBalanceTable.Get(context.Background(), NewSelectorPoint(&TokenBalance{ID: 1}), batch)
 	require.NoError(t, err)
 	require.NotNil(t, tokenBalance)