Passing project4a

Author: Junlong Gao

README.md

@@ -7,8 +7,9 @@
 | Project 2c| Done |
 | Project 3a| Done |
 | Project 3b| Done |
-| Project 3c| De-scoped, using official placement driver v3.0.13 |
-| Project 4a| In progress |
+| Project 3c| De-scoped, using official placement driver v3.0.13 : )|
+| Project 4a| Done |
+| Project 4b| In progress |
 
 # The TinyKV Course
 
@@ -100,10 +101,4 @@ After the placement driver does the magic, hack the client dir:
 ```
 $ make client
 $ ./bin/tinykv-client
-```
-
-### Play
-
-```
-mysql -u root -h 127.0.0.1 -P 4000
-```
+```

kv/transaction/mvcc/transaction.go

@@ -2,6 +2,8 @@ package mvcc
 
 import (
 	"encoding/binary"
+	"github.com/pingcap-incubator/tinykv/kv/util/engine_util"
+	"math"
 
 	"github.com/pingcap-incubator/tinykv/kv/storage"
 	"github.com/pingcap-incubator/tinykv/kv/util/codec"
@@ -41,53 +43,148 @@ func (txn *MvccTxn) Writes() []storage.Modify {
 // PutWrite records a write at key and ts.
 func (txn *MvccTxn) PutWrite(key []byte, ts uint64, write *Write) {
 	// Your Code Here (4A).
+	txn.writes = append(txn.writes, storage.Modify{Data: storage.Put{
+		Key:   EncodeKey(key, ts),
+		Value: write.ToBytes(),
+		Cf:    engine_util.CfWrite,
+	}})
 }
 
 // GetLock returns a lock if key is locked. It will return (nil, nil) if there is no lock on key, and (nil, err)
 // if an error occurs during lookup.
 func (txn *MvccTxn) GetLock(key []byte) (*Lock, error) {
 	// Your Code Here (4A).
-	return nil, nil
+	val, err := txn.Reader.GetCF(engine_util.CfLock, key)
+
+	if err != nil {
+		return nil, err
+	}
+
+	l, err := ParseLock(val)
+	if err != nil {
+		panic(err)
+	}
+	return l, nil
 }
 
 // PutLock adds a key/lock to this transaction.
 func (txn *MvccTxn) PutLock(key []byte, lock *Lock) {
 	// Your Code Here (4A).
+	txn.writes = append(txn.writes, storage.Modify{
+		Data: storage.Put{
+			Key:   key,
+			Cf:    engine_util.CfLock,
+			Value: lock.ToBytes(),
+		},
+	})
 }
 
 // DeleteLock adds a delete lock to this transaction.
 func (txn *MvccTxn) DeleteLock(key []byte) {
 	// Your Code Here (4A).
+	txn.writes = append(txn.writes, storage.Modify{
+		Data: storage.Delete{
+			Key: key,
+			Cf:  engine_util.CfLock,
+		},
+	})
 }
 
 // GetValue finds the value for key, valid at the start timestamp of this transaction.
 // I.e., the most recent value committed before the start of this transaction.
 func (txn *MvccTxn) GetValue(key []byte) ([]byte, error) {
 	// Your Code Here (4A).
+	iter := txn.Reader.IterCF(engine_util.CfWrite)
+
+	startKey := EncodeKey(key, txn.StartTS)
+	endKey := EncodeKey(key, 0)
+	for iter.Seek(startKey); iter.Valid() && !engine_util.ExceedEndKey(iter.Item().Key(), endKey); iter.Next() {
+		v, err := iter.Item().Value()
+		if err != nil {
+			return nil, err
+		}
+		w, err := ParseWrite(v)
+		if err != nil {
+			panic(err)
+		}
+
+		return txn.Reader.GetCF(engine_util.CfDefault, EncodeKey(key, w.StartTS))
+	}
+
 	return nil, nil
 }
 
 // PutValue adds a key/value write to this transaction.
 func (txn *MvccTxn) PutValue(key []byte, value []byte) {
 	// Your Code Here (4A).
+	txn.writes = append(txn.writes, storage.Modify{
+		Data: storage.Put{
+			Key:   EncodeKey(key, txn.StartTS),
+			Value: value,
+			Cf:    engine_util.CfDefault,
+		},
+	})
 }
 
 // DeleteValue removes a key/value pair in this transaction.
 func (txn *MvccTxn) DeleteValue(key []byte) {
 	// Your Code Here (4A).
+	txn.writes = append(txn.writes, storage.Modify{
+		Data: storage.Delete{
+			Key: EncodeKey(key, txn.StartTS),
+			Cf:  engine_util.CfDefault,
+		},
+	})
 }
 
 // CurrentWrite searches for a write with this transaction's start timestamp. It returns a Write from the DB and that
 // write's commit timestamp, or an error.
 func (txn *MvccTxn) CurrentWrite(key []byte) (*Write, uint64, error) {
 	// Your Code Here (4A).
+	iter := txn.Reader.IterCF(engine_util.CfWrite)
+	// the committed write must have timestamp no eariler than txn.StartTS
+	startKey := EncodeKey(key, math.MaxInt64)
+	endKey := EncodeKey(key, txn.StartTS)
+	for iter.Seek(startKey); iter.Valid() && !engine_util.ExceedEndKey(iter.Item().Key(), endKey); iter.Next() {
+		v, err := iter.Item().Value()
+		if err != nil {
+			return nil, 0, err
+		}
+		w, err := ParseWrite(v)
+		if err != nil {
+			panic(err)
+		}
+
+		if w.StartTS != txn.StartTS {
+			continue
+		}
+
+		return w, decodeTimestamp(iter.Item().Key()), nil
+	}
+
 	return nil, 0, nil
 }
 
 // MostRecentWrite finds the most recent write with the given key. It returns a Write from the DB and that
 // write's commit timestamp, or an error.
 func (txn *MvccTxn) MostRecentWrite(key []byte) (*Write, uint64, error) {
 	// Your Code Here (4A).
+	iter := txn.Reader.IterCF(engine_util.CfWrite)
+
+	startKey := EncodeKey(key, math.MaxInt64)
+	endKey := EncodeKey(key, 0)
+	for iter.Seek(startKey); iter.Valid() && !engine_util.ExceedEndKey(iter.Item().Key(), endKey); iter.Next() {
+		v, err := iter.Item().Value()
+		if err != nil {
+			return nil, 0, err
+		}
+		w, err := ParseWrite(v)
+		if err != nil {
+			panic(err)
+		}
+
+		return w, decodeTimestamp(iter.Item().Key()), nil
+	}
 	return nil, 0, nil
 }