Enregistrement d'expérience MIT6.5830 Lab1-GoDB (6) – Site de WhiteNight
tag :Golang
Cyber Prison Journey Chapitre 1 Section 6 : Dans la continuité de la section précédente, complétez les fonctions restantes de heap_page.
Commencez à aller en prison
Supprimer le tuple
Cela ne semble pas si difficile, essayons de l'écrire. Parcourez ensuite le tuple et trouvez le débarras.
func (h *heapPage) deleteTuple(rid recordID) error {
// TODO: some code goes here
for i, tuple := range h.Tuple {
if tuple.Rid == rid {
h.Tuple[i] = nil
h.Hdr.UsedSlots -= 1
return nil
}
}
return errors.New("the slot is invalid") //replace me
}Exécutez TestDeleteHeapPage et réussissez.
Une fois que vous avez vraiment une idée, vous pouvez l’écrire facilement, puis continuer à lire.
N'oubliez pas qu'il existe également un TestHeapPageDeleteTuple, exécutez-le. Euh ? En fait, il a signalé une erreur. Une autre visite qui a dépassé les limites.
Voyez où l'erreur est signalée. Si vous regardez bien, le tuple n'est pas vide………………Si le tuple est égal à zéro, si vous ne parvenez pas à vous débarrasser, l'accès sera hors limites……………….merci de le compléter
func (h *heapPage) deleteTuple(rid recordID) error {
// TODO: some code goes here
for i, tuple := range h.Tuple {
if tuple != nil && tuple.Rid == rid {
h.Tuple[i] = nil
h.Hdr.UsedSlots -= 1
return nil
}
}
return errors.New("the slot is invalid") //replace me
}Testez-le à nouveau et réussissez.
Étapes expérimentales
sale
Pour déterminer si une page est une « page sale » et pour définir la page comme une « page sale », vous devez ajouter dirty à la structure de la page.
type heapPage struct {
// TODO: some code goes here
Hdr Header
Tuple []*Tuple
Desc *TupleDesc
File *HeapFile
PageNo int
Dirty bool
}Il n’y a pas grand chose à dire sur ces deux fonctions, elles sont assez simples.
// Page method - return whether or not the page is dirty
func (h *heapPage) isDirty() bool {
// TODO: some code goes here
return h.Dirty //replace me
}
// Page method - mark the page as dirty
func (h *heapPage) setDirty(dirty bool) {
// TODO: some code goes here
h.Dirty = dirty
}Il existe en fait un test pour cela, alors exécutons-le et réussissons-le.
J'ai jeté un coup d'œil au test suivant, haha, c'est encore la sérialisation, il semble que le voyage de la cyber-prison doit continuer.
Étapes expérimentales
Retour à la page correspondante
Est-ce vraiment difficile ? Comme c'est difficile.
Eh bien, c'est vraiment difficile à regarder attentivement. Parce que le commentaire n'est qu'une phrase : renvoie le heapFile où se trouve la page du tas actuelle.
// Page method - return the corresponding HeapFile
// for this page.
func (p *heapPage) getFile() *DBFile {
// TODO: some code goes here
return nil //replace me
}Il n’y a pas d’autres astuces, nous ne pouvons donc que commencer par examiner la définition de DBFile.
Hmm... étant donné une interface, alors DBFile devrait contenir un fichier tas. Il suffit ensuite de renvoyer le fichier de la page tas directement dans l'interface...
func (p *heapPage) getFile() *DBFile {
// TODO: some code goes here
var dbFile DBFile = p.File
return &dbFile //replace me
}Il n'y a aucun moyen de le tester car GetPage n'est pas encore terminé, alors commençons par le parcourir !
Étapes expérimentales
Encore une sérialisation
Je ne connais vraiment pas la sérialisation. Je ne peux que mordre la balle et écrire. Voyons d’abord quoi faire.
// Allocate a new bytes.Buffer and write the heap page to it. Returns an error
// if the write to the the buffer fails. You will likely want to call this from
// your [HeapFile.flushPage] method. You should write the page header, using
// the binary.Write method in LittleEndian order, followed by the tuples of the
// page, written using the Tuple.writeTo method.
func (h *heapPage) toBuffer() (*bytes.Buffer, error) {
// TODO: some code goes here
return nil, nil //replace me
}
// Read the contents of the HeapPage from the supplied buffer.
func (h *heapPage) initFromBuffer(buf *bytes.Buffer) error {
// TODO: some code goes here
return nil //replace me
}Nous avons déjà abordé la sérialisation et la désérialisation dans le tuple précédent, nous allons donc commencer à l'écrire directement ici.
Comme d'habitude, écrivez d'abord dans le tampon. Cela semble plus simple qu'un tuple, après tout, il n'est pas nécessaire de considérer différents types de champs.
func (h *heapPage) toBuffer() (*bytes.Buffer, error) {
// TODO: some code goes here
bytesBuffer := new(bytes.Buffer)
err := binary.Write(bytesBuffer, binary.LittleEndian, h.Hdr)
if err != nil {
return nil, err
}
for _, tuple := range h.Tuple {
if tuple != nil {
err := tuple.writeTo(bytesBuffer)
if err != nil {
return nil, err
}
}
}
return bytesBuffer, nil //replace me
}Vient ensuite le tampon de lecture. Faites attention à la plage lors de la lecture. Par exemple, la page a 102 emplacements disponibles, ce qui signifie que les emplacements indexés de 0 à 101 sont disponibles, donc TotalSlots doit être réduit de un.
func (h *heapPage) initFromBuffer(buf *bytes.Buffer) error {
// TODO: some code goes here
err := binary.Read(buf, binary.LittleEndian, &h.Hdr)
if err != nil {
return err
}
for i := 0; i < int(h.Hdr.TotalSlots)-1; i++ {
tuple, err := readTupleFrom(buf, h.Desc)
if err != nil {
return err
}
h.Tuple[i] = tuple
}
return nil //replace me
}Exécutez le test et il réussit. À ce stade, nous avons terminé tout le contenu de l’exercice 3 et l’étape suivante consiste à terminer l’exercice 4.
