github.com/weaviate/weaviate@v1.24.6/adapters/repos/db/lsmkv/binary_search_tree_map_test.go (about)

     1  //                           _       _
     2  // __      _____  __ ___   ___  __ _| |_ ___
     3  // \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
     4  //  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
     5  //   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
     6  //
     7  //  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
     8  //
     9  //  CONTACT: hello@weaviate.io
    10  //
    11  
    12  package lsmkv
    13  
    14  import (
    15  	"testing"
    16  
    17  	"github.com/stretchr/testify/assert"
    18  	"github.com/stretchr/testify/require"
    19  )
    20  
    21  func Test_BinarySearchTreeMap(t *testing.T) {
    22  	t.Run("single row key, single map key", func(t *testing.T) {
    23  		tree := &binarySearchTreeMap{}
    24  		rowKey := []byte("rowkey")
    25  
    26  		pair1 := MapPair{
    27  			Key:   []byte("map-key-1"),
    28  			Value: []byte("map-value-1"),
    29  		}
    30  
    31  		tree.insert(rowKey, pair1)
    32  
    33  		res, err := tree.get(rowKey)
    34  		require.Nil(t, err)
    35  		assert.Equal(t, []MapPair{
    36  			{
    37  				Key:   []byte("map-key-1"),
    38  				Value: []byte("map-value-1"),
    39  			},
    40  		}, res)
    41  	})
    42  
    43  	t.Run("single row key, updated map value", func(t *testing.T) {
    44  		tree := &binarySearchTreeMap{}
    45  		rowKey := []byte("rowkey")
    46  
    47  		tree.insert(rowKey, MapPair{
    48  			Key:   []byte("c"),
    49  			Value: []byte("c1"),
    50  		})
    51  
    52  		tree.insert(rowKey, MapPair{
    53  			Key:   []byte("a"),
    54  			Value: []byte("a1"),
    55  		})
    56  
    57  		tree.insert(rowKey, MapPair{
    58  			Key:   []byte("b"),
    59  			Value: []byte("b1"),
    60  		})
    61  
    62  		tree.insert(rowKey, MapPair{
    63  			Key:   []byte("b"),
    64  			Value: []byte("b2"),
    65  		})
    66  
    67  		tree.insert(rowKey, MapPair{
    68  			Key:   []byte("a"),
    69  			Value: []byte("a2"),
    70  		})
    71  
    72  		res, err := tree.get(rowKey)
    73  		require.Nil(t, err)
    74  		assert.Equal(t, []MapPair{
    75  			{
    76  				Key:   []byte("a"),
    77  				Value: []byte("a2"),
    78  			},
    79  			{
    80  				Key:   []byte("b"),
    81  				Value: []byte("b2"),
    82  			},
    83  			{
    84  				Key:   []byte("c"),
    85  				Value: []byte("c1"),
    86  			},
    87  		}, res)
    88  	})
    89  
    90  	t.Run("two row keys, updated map value", func(t *testing.T) {
    91  		tree := &binarySearchTreeMap{}
    92  		rowKey1 := []byte("rowkey")
    93  		rowKey2 := []byte("other-rowkey")
    94  
    95  		tree.insert(rowKey1, MapPair{
    96  			Key:   []byte("c"),
    97  			Value: []byte("c1"),
    98  		})
    99  
   100  		tree.insert(rowKey1, MapPair{
   101  			Key:   []byte("a"),
   102  			Value: []byte("a1"),
   103  		})
   104  
   105  		tree.insert(rowKey2, MapPair{
   106  			Key:   []byte("z"),
   107  			Value: []byte("z1"),
   108  		})
   109  
   110  		tree.insert(rowKey1, MapPair{
   111  			Key:   []byte("b"),
   112  			Value: []byte("b1"),
   113  		})
   114  
   115  		tree.insert(rowKey2, MapPair{
   116  			Key:   []byte("x"),
   117  			Value: []byte("x1"),
   118  		})
   119  
   120  		tree.insert(rowKey1, MapPair{
   121  			Key:   []byte("b"),
   122  			Value: []byte("b2"),
   123  		})
   124  
   125  		tree.insert(rowKey1, MapPair{
   126  			Key:   []byte("a"),
   127  			Value: []byte("a2"),
   128  		})
   129  
   130  		tree.insert(rowKey2, MapPair{
   131  			Key:   []byte("x"),
   132  			Value: []byte("x2"),
   133  		})
   134  
   135  		res, err := tree.get(rowKey1)
   136  		require.Nil(t, err)
   137  		assert.Equal(t, []MapPair{
   138  			{
   139  				Key:   []byte("a"),
   140  				Value: []byte("a2"),
   141  			},
   142  			{
   143  				Key:   []byte("b"),
   144  				Value: []byte("b2"),
   145  			},
   146  			{
   147  				Key:   []byte("c"),
   148  				Value: []byte("c1"),
   149  			},
   150  		}, res)
   151  
   152  		res, err = tree.get(rowKey2)
   153  		require.Nil(t, err)
   154  		assert.Equal(t, []MapPair{
   155  			{
   156  				Key:   []byte("x"),
   157  				Value: []byte("x2"),
   158  			},
   159  			{
   160  				Key:   []byte("z"),
   161  				Value: []byte("z1"),
   162  			},
   163  		}, res)
   164  	})
   165  
   166  	t.Run("single row key, deleted map values", func(t *testing.T) {
   167  		tree := &binarySearchTreeMap{}
   168  		rowKey := []byte("rowkey")
   169  
   170  		tree.insert(rowKey, MapPair{
   171  			Key:   []byte("c"),
   172  			Value: []byte("c1"),
   173  		})
   174  
   175  		tree.insert(rowKey, MapPair{
   176  			Key:   []byte("a"),
   177  			Value: []byte("a1"),
   178  		})
   179  
   180  		tree.insert(rowKey, MapPair{
   181  			Key:   []byte("b"),
   182  			Value: []byte("b1"),
   183  		})
   184  
   185  		tree.insert(rowKey, MapPair{
   186  			Key:       []byte("b"),
   187  			Tombstone: true,
   188  		})
   189  
   190  		tree.insert(rowKey, MapPair{
   191  			Key:       []byte("a"),
   192  			Tombstone: true,
   193  		})
   194  
   195  		res, err := tree.get(rowKey)
   196  		require.Nil(t, err)
   197  		assert.Equal(t, []MapPair{
   198  			{
   199  				Key:       []byte("a"),
   200  				Tombstone: true,
   201  			},
   202  			{
   203  				Key:       []byte("b"),
   204  				Tombstone: true,
   205  			},
   206  			{
   207  				Key:   []byte("c"),
   208  				Value: []byte("c1"),
   209  			},
   210  		}, res)
   211  	})
   212  }