mirror/dolt
1
0
Fork 0
mirror of https://github.com/dolthub/dolt.git synced 2026-01-25 18:49:36 -06:00
Code Issues Packages Projects Releases 123 Wiki Activity

made message.ItemAccess fields pkg private

Browse Source
This commit is contained in:
Andy Arthur
2022-09-09 15:04:48 -07:00
parent 6cadd96237
commit c05032937c
10 changed files with 67 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
go/store/prolly/message/address_map.go
View File

@@ -81,25 +81,25 @@ func (s AddressMapSerializer) Serialize(keys, addrs [][]byte, subtrees []uint64,
return serial.FinishMessage(b, serial.AddressMapEnd(b), addressMapFileID)
}
func getAddressMapKeys(msg serial.Message) (keys ItemArray, err error) {
func getAddressMapKeys(msg serial.Message) (keys ItemAccess, err error) {
var am serial.AddressMap
err = serial.InitAddressMapRoot(&am, msg, serial.MessagePrefixSz)
if err != nil {
return keys, err
}
keys.Items = am.KeyItemsBytes()
keys.Offs = getAddressMapKeyOffsets(&am)
keys.items = am.KeyItemsBytes()
keys.offs = getAddressMapKeyOffsets(&am)
return
}
func getAddressMapValues(msg serial.Message) (values ItemArray, err error) {
func getAddressMapValues(msg serial.Message) (values ItemAccess, err error) {
var am serial.AddressMap
err = serial.InitAddressMapRoot(&am, msg, serial.MessagePrefixSz)
if err != nil {
return values, err
}
values.Items = am.AddressArrayBytes()
values.Offs = offsetsForAddressArray(values.Items)
values.items = am.AddressArrayBytes()
values.offs = offsetsForAddressArray(values.items)
return
}

2
go/store/prolly/message/addresses.go
View File

@@ -45,7 +45,7 @@ func init() {
// offsetsForAddressArray provides an uint16 offsets array |offs| for an array
// of addresses |arr|. Together, |arr| and |offs| can construct a val.SlicedBuffer.
// Offsets aren't necessary to slice into an array of fixed-width addresses, but
// we still wrap address arrays in ItemArray to provide a uniform API when
// we still wrap address arrays in ItemAccess to provide a uniform API when
// accessing keys and values of Messages.
func offsetsForAddressArray(arr []byte) (offs []byte) {
cnt := (len(arr) / addrSize) + 1

22
go/store/prolly/message/blob.go
View File

@@ -59,10 +59,10 @@ func (s BlobSerializer) Serialize(keys, values [][]byte, subtrees []uint64, leve
return serial.FinishMessage(b, serial.BlobEnd(b), blobFileID)
}
func getBlobKeys(msg serial.Message) (ItemArray, error) {
func getBlobKeys(msg serial.Message) (ItemAccess, error) {
cnt, err := getBlobCount(msg)
if err != nil {
return ItemArray{}, err
return ItemAccess{}, err
}
buf := make([]byte, cnt)
for i := range buf {
@@ -73,24 +73,24 @@ func getBlobKeys(msg serial.Message) (ItemArray, error) {
b := offs[i*2 : (i+1)*2]
binary.LittleEndian.PutUint16(b, uint16(i))
}
return ItemArray{
Items: buf,
Offs: offs,
return ItemAccess{
items: buf,
offs: offs,
}, nil
}
func getBlobValues(msg serial.Message) (ItemArray, error) {
func getBlobValues(msg serial.Message) (ItemAccess, error) {
var b serial.Blob
err := serial.InitBlobRoot(&b, msg, serial.MessagePrefixSz)
if err != nil {
return ItemArray{}, err
return ItemAccess{}, err
}
if b.TreeLevel() > 0 {
arr := b.AddressArrayBytes()
off := offsetsForAddressArray(arr)
return ItemArray{
Items: arr,
Offs: off,
return ItemAccess{
items: arr,
offs: off,
}, nil
}
@@ -98,7 +98,7 @@ func getBlobValues(msg serial.Message) (ItemArray, error) {
offs := make([]byte, 4)
binary.LittleEndian.PutUint16(offs[2:], uint16(len(buf)))
return ItemArray{Items: buf, Offs: offs}, nil
return ItemAccess{items: buf, offs: offs}, nil
}
func getBlobCount(msg serial.Message) (uint16, error) {

20
go/store/prolly/message/commit_closure.go
View File

@@ -50,36 +50,36 @@ func offsetsForCommitClosureKeys(buf []byte) []byte {
return commitClosureKeyOffsets[:cnt*uint16Size]
}
func getCommitClosureKeys(msg serial.Message) (ItemArray, error) {
var ret ItemArray
func getCommitClosureKeys(msg serial.Message) (ItemAccess, error) {
var ret ItemAccess
var m serial.CommitClosure
err := serial.InitCommitClosureRoot(&m, msg, serial.MessagePrefixSz)
if err != nil {
return ret, err
}
ret.Items = m.KeyItemsBytes()
ret.Offs = offsetsForCommitClosureKeys(ret.Items)
ret.items = m.KeyItemsBytes()
ret.offs = offsetsForCommitClosureKeys(ret.items)
return ret, nil
}
func getCommitClosureValues(msg serial.Message) (ItemArray, error) {
var ret ItemArray
func getCommitClosureValues(msg serial.Message) (ItemAccess, error) {
var ret ItemAccess
var m serial.CommitClosure
err := serial.InitCommitClosureRoot(&m, msg, serial.MessagePrefixSz)
if err != nil {
return ret, err
}
if m.AddressArrayLength() == 0 {
ret.Items = commitClosureEmptyValueBytes
ret.items = commitClosureEmptyValueBytes
cnt, err := getCommitClosureCount(msg)
if err != nil {
return ret, nil
}
ret.Offs = commitClosureValueOffsets[:cnt*uint16Size]
ret.offs = commitClosureValueOffsets[:cnt*uint16Size]
return ret, nil
}
ret.Items = m.AddressArrayBytes()
ret.Offs = offsetsForAddressArray(ret.Items)
ret.items = m.AddressArrayBytes()
ret.offs = offsetsForAddressArray(ret.items)
return ret, nil
}

22
go/store/prolly/message/item_array.go → go/store/prolly/message/item_access.go
View File

@@ -16,23 +16,23 @@ package message
import "github.com/dolthub/dolt/go/store/val"
// ItemArray is an array of Items
type ItemArray struct {
Items []byte
// Offs is an array of uint16 encoded offsets into |Items|.
// ItemAccess is an array of Items
type ItemAccess struct {
items []byte
// Offs is an array of uint16 encoded offsets into |items|.
// the first offset is 0, the last offset if len(Items).
Offs []byte
offs []byte
}
// GetItem returns the ith item in |arr|.
func (arr ItemArray) GetItem(i int) []byte {
func (arr ItemAccess) GetItem(i int) []byte {
pos := i * 2
start := val.ReadUint16(arr.Offs[pos : pos+2])
stop := val.ReadUint16(arr.Offs[pos+2 : pos+4])
return arr.Items[start:stop]
start := val.ReadUint16(arr.offs[pos : pos+2])
stop := val.ReadUint16(arr.offs[pos+2 : pos+4])
return arr.items[start:stop]
}
// Len returns the number of items in |arr|.
func (arr ItemArray) Len() int {
return len(arr.Offs)/2 - 1
func (arr ItemAccess) Len() int {
return len(arr.offs)/2 - 1
}

14
go/store/prolly/message/merge_artifacts.go
View File

@@ -102,24 +102,24 @@ func (s MergeArtifactSerializer) Serialize(keys, values [][]byte, subtrees []uin
return serial.FinishMessage(b, serial.MergeArtifactsEnd(b), mergeArtifactFileID)
}
func getArtifactMapKeysAndValues(msg serial.Message) (keys, values ItemArray, cnt uint16, err error) {
func getArtifactMapKeysAndValues(msg serial.Message) (keys, values ItemAccess, cnt uint16, err error) {
var am serial.MergeArtifacts
err = serial.InitMergeArtifactsRoot(&am, msg, serial.MessagePrefixSz)
if err != nil {
return
}
keys.Items = am.KeyItemsBytes()
keys.Offs = getMergeArtifactKeyOffsets(&am)
keys.items = am.KeyItemsBytes()
keys.offs = getMergeArtifactKeyOffsets(&am)
cnt = uint16(keys.Len())
vv := am.ValueItemsBytes()
if vv != nil {
values.Items = vv
values.Offs = getMergeArtifactValueOffsets(&am)
values.items = vv
values.offs = getMergeArtifactValueOffsets(&am)
} else {
values.Items = am.AddressArrayBytes()
values.Offs = offsetsForAddressArray(values.Items)
values.items = am.AddressArrayBytes()
values.offs = offsetsForAddressArray(values.items)
}
return

2
go/store/prolly/message/message.go
View File

@@ -26,7 +26,7 @@ type Serializer interface {
Serialize(keys, values [][]byte, subtrees []uint64, level int) serial.Message
}
func GetKeysAndValues(msg serial.Message) (keys, values ItemArray, cnt uint16, err error) {
func GetKeysAndValues(msg serial.Message) (keys, values ItemAccess, cnt uint16, err error) {
id := serial.GetFileID(msg)
if id == serial.ProllyTreeNodeFileID {

14
go/store/prolly/message/prolly_map.go
View File

@@ -101,24 +101,24 @@ func (s ProllyMapSerializer) Serialize(keys, values [][]byte, subtrees []uint64,
return serial.FinishMessage(b, serial.ProllyTreeNodeEnd(b), prollyMapFileID)
}
func getProllyMapKeysAndValues(msg serial.Message) (keys, values ItemArray, cnt uint16, err error) {
func getProllyMapKeysAndValues(msg serial.Message) (keys, values ItemAccess, cnt uint16, err error) {
var pm serial.ProllyTreeNode
err = serial.InitProllyTreeNodeRoot(&pm, msg, serial.MessagePrefixSz)
if err != nil {
return
}
keys.Items = pm.KeyItemsBytes()
keys.Offs = getProllyMapKeyOffsets(&pm)
keys.items = pm.KeyItemsBytes()
keys.offs = getProllyMapKeyOffsets(&pm)
cnt = uint16(keys.Len())
vv := pm.ValueItemsBytes()
if vv != nil {
values.Items = vv
values.Offs = getProllyMapValueOffsets(&pm)
values.items = vv
values.offs = getProllyMapValueOffsets(&pm)
} else {
values.Items = pm.AddressArrayBytes()
values.Offs = offsetsForAddressArray(values.Items)
values.items = pm.AddressArrayBytes()
values.offs = offsetsForAddressArray(values.items)
}
return

14
go/store/prolly/tree/immutable_tree_test.go
View File

@@ -19,6 +19,7 @@ import (
"context"
"errors"
"fmt"
"github.com/dolthub/dolt/go/gen/fb/serial"
"math"
"testing"
@@ -163,11 +164,11 @@ func TestWriteImmutableTree(t *testing.T) {
return err
}
if leaf {
byteCnt += len(n.values.Items)
byteCnt += len(getBlobValues(n.msg))
for _, i := range n.GetValue(0) {
sum += int(i)
}
keyCnt = len(n.values.Items)
keyCnt = len(getBlobValues(n.msg))
if keyCnt != tt.chunkSize {
unfilledCnt += 1
}
@@ -394,3 +395,12 @@ func mustNewBlob(ctx context.Context, ns NodeStore, len, chunkSize int) *Immutab
}
return root
}
func getBlobValues(msg serial.Message) []byte {
var b serial.Blob
err := serial.InitBlobRoot(&b, msg, serial.MessagePrefixSz)
if err != nil {
panic(err)
}
return b.PayloadBytes()
}

2
go/store/prolly/tree/node.go
View File

@@ -33,7 +33,7 @@ type subtreeCounts []uint64
type Node struct {
// keys and values contain sub-slices of |msg|,
// allowing faster lookups by avoiding the vtable
keys, values message.ItemArray
keys, values message.ItemAccess
subtrees subtreeCounts
count uint16
msg serial.Message