MIT6.5830 Lab1-GoDB实验记录（四）

MIT6.5830 Lab1-GoDB实验记录（四） – WhiteNight's Site

标签：Golang

读写缓冲区我是一点思路都没有，所以得单独开篇文章记录。

实验补充

了解buffer、序列化与反序列化

这里的序列化，简单来说类似于把一个很长的字符串拆成一个个字符；反序列化就是把这一个个字符拼回成完整的字符串。此处我们需要根据所给的Tuple，转换为二进制后再写入buffer中。

而buffer–缓冲区相信大家都不陌生了。我们来个go中的例子。先来个把结构转换为二进制后写入buffer的例子。

再来看个从buffer中读取byte[]，再将其转换为字符串的例子

实验BUG

修正tuple.equal函数

如果你是按着我的代码敲的，在tuple.equal中有个bug，会导致你即使没动过writeTo和read函数，run test TestTupleSerialization也能通过。

主要是因为没比较两个元组的长度，只比较了Desc的长度。所以如果两个元组字段相同但记录不一样，会导致最后equal仍然return true。

修改一下equal即可。

func (t1 *Tuple) equals(t2 *Tuple) bool {
	// TODO: some code goes here
	if t1.Desc.equals(&t2.Desc) == false {
		return false
	}
	if len(t1.Fields) != len(t2.Fields) {
		return false
	}
	for i := range t1.Fields {
		if t1.Fields[i] != t2.Fields[i] {
			return false
		}
	}
	return true
}

实验步骤

补全writeTo函数

先来看看writeTo，把一个元组的字段写入缓冲区。Desc倒是不用写入，这点可以从read函数中反推出来。

还好GoDB只支持两种数据类型：int和string。所以只需要判断字段是int还是string。int比较好处理，没做要求所以我们直接写入即可。

func (t *Tuple) writeTo(b *bytes.Buffer) error {
	// TODO: some code goes here
	for _,field :=range t.Fields{
		switch f:=field.(type){
		case IntField:
			err:=binary.Write(b,binary.LittleEndian,f.Value)
			if err!=nil{
				return err
			}
		case StringField:
			
		}
	}
	return 

在注释中，还提到了缓冲区大小不够，无法写入元组的情况，这种情况需要返回一个err，所以我们还需要判断缓冲区和元组的大小，并new一个error。

但是这又有个问题：缓冲区大小是受你电脑或者操作系统分配的。buffer会根据你要传递的数据自动增长。用人话讲：缓冲区的大小会自动改变，那我们该怎么判断它大小不够无法再写入数据了呢？

说实话，没戏。获取自己电脑的系统内存？没戏，起码对于入门的Goer没戏；更何况真达到这个上限的时候内存早爆了。

所以我选择自定义一个2G的缓冲区大小，超出2G就报错。按一个字符串32字节来算，那也能存67108864个字符串，足够了。

func (t *Tuple) writeTo(b *bytes.Buffer) error {
	// TODO: some code goes here
	maxSize := 0
	for _, field := range t.Fields {
		switch f := field.(type) {
		case IntField:
			maxSize += int(unsafe.Sizeof(f.Value))
		case StringField:
			maxSize += 32
		}
	}
	if maxSize >= 2147483648 { //2 G=2,147,483,648 Bytes
		err := errors.New("Buffer has insufficient capacity!")
		return err
	} else {
		for _, field := range t.Fields {
			switch f := field.(type) {
			case IntField:
				err := binary.Write(b, binary.LittleEndian, f.Value)
				if err != nil {
					return err
				}
			case StringField:
				
			}
		}
		return nil
	}
}

接下来就是重头戏了：怎么处理string类型的字符串。

// Strings can be converted to byte arrays by casting to []byte. Note that all
// strings need to be padded to StringLength bytes (set in types.go). For
// example if StringLength is set to 5, the string 'mit' should be written as
// 'm', 'i', 't', 0, 0

可以看出，字符串先要转为字节数组，然后小于32字节的字符串要补0，一直补到32字节为止。那很简单，make一个len-x的切片，然后添加到字节数组后面即可。

func (t *Tuple) writeTo(b *bytes.Buffer) error {
	// TODO: some code goes here
	maxSize := 0
	for _, field := range t.Fields {
		switch f := field.(type) {
		case IntField:
			maxSize += int(unsafe.Sizeof(f.Value))
		case StringField:
			maxSize += 32
		}
	}
	if maxSize >= 2147483648 { //2 G=2,147,483,648 Bytes
		err := errors.New("Buffer has insufficient capacity!")
		return err
	} else {
		for _, field := range t.Fields {
			switch f := field.(type) {
			case IntField:
				err := binary.Write(b, binary.LittleEndian, f.Value)
				if err != nil {
					return err
				}
			case StringField:
				str := []byte(f.Value)
				if len(str) < StringLength {
					padding := make([]byte, StringLength-len(str))
					str = append(str, padding...)
				}
				err := binary.Write(b, binary.LittleEndian, str)
				if err != nil {
					return err
				}
			}
		}
		return nil //replace me
	}
}

run file test，全过，prefect。