Add TXID type (#36)

Author: benbjohnson

cmd/ltx/checksum.go

@@ -45,7 +45,7 @@ Usage:
 	if err != nil {
 		return err
 	}
-	defer f.Close()
+	defer func() { _ = f.Close() }()
 
 	// Read database header to determine page size.
 	buf := make([]byte, 100)

cmd/ltx/dump.go

@@ -47,7 +47,7 @@ Arguments:
 	if err != nil {
 		return err
 	}
-	defer f.Close()
+	defer func() { _ = f.Close() }()
 
 	dec := ltx.NewDecoder(f)
 
@@ -59,8 +59,8 @@ Arguments:
 	fmt.Printf("Flags:     0x%08x\n", hdr.Flags)
 	fmt.Printf("Page size: %d\n", hdr.PageSize)
 	fmt.Printf("Commit:    %d\n", hdr.Commit)
-	fmt.Printf("Min TXID:  %s (%d)\n", ltx.FormatTXID(hdr.MinTXID), hdr.MinTXID)
-	fmt.Printf("Max TXID:  %s (%d)\n", ltx.FormatTXID(hdr.MaxTXID), hdr.MaxTXID)
+	fmt.Printf("Min TXID:  %s (%d)\n", hdr.MinTXID.String(), hdr.MinTXID)
+	fmt.Printf("Max TXID:  %s (%d)\n", hdr.MaxTXID.String(), hdr.MaxTXID)
 	fmt.Printf("Timestamp: %s (%d)\n", time.UnixMilli(int64(hdr.Timestamp)).UTC().Format(time.RFC3339Nano), hdr.Timestamp)
 	fmt.Printf("Pre-apply: %016x\n", hdr.PreApplyChecksum)
 	fmt.Printf("WAL offset: %d\n", hdr.WALOffset)

cmd/ltx/list.go

@@ -47,14 +47,14 @@ Arguments:
 	var w io.Writer = os.Stdout
 	if !*tsv {
 		tw := tabwriter.NewWriter(os.Stdout, 0, 8, 2, ' ', 0)
-		defer tw.Flush()
+		defer func() { _ = tw.Flush() }()
 		w = tw
 	}
 
-	fmt.Fprintln(w, "min_txid\tmax_txid\tcommit\tpages\tpreapply\tpostapply\ttimestamp\twal_offset\twal_size\twal_salt")
+	_, _ = fmt.Fprintln(w, "min_txid\tmax_txid\tcommit\tpages\tpreapply\tpostapply\ttimestamp\twal_offset\twal_size\twal_salt")
 	for _, arg := range fs.Args() {
 		if err := c.printFile(w, arg); err != nil {
-			fmt.Fprintf(os.Stderr, "%s: %s\n", arg, err)
+			_, _ = fmt.Fprintf(os.Stderr, "%s: %s\n", arg, err)
 		}
 	}
 
@@ -66,7 +66,7 @@ func (c *ListCommand) printFile(w io.Writer, filename string) error {
 	if err != nil {
 		return err
 	}
-	defer f.Close()
+	defer func() { _ = f.Close() }()
 
 	dec := ltx.NewDecoder(f)
 	if err := dec.Verify(); err != nil {
@@ -79,9 +79,9 @@ func (c *ListCommand) printFile(w io.Writer, filename string) error {
 		timestamp = ""
 	}
 
-	fmt.Fprintf(w, "%s\t%s\t%d\t%d\t%016x\t%016x\t%s\t%d\t%d\t%08x %08x\n",
-		ltx.FormatTXID(dec.Header().MinTXID),
-		ltx.FormatTXID(dec.Header().MaxTXID),
+	_, _ = fmt.Fprintf(w, "%s\t%s\t%d\t%d\t%016x\t%016x\t%s\t%d\t%d\t%08x %08x\n",
+		dec.Header().MinTXID.String(),
+		dec.Header().MaxTXID.String(),
 		dec.Header().Commit,
 		dec.PageN(),
 		dec.Header().PreApplyChecksum,

cmd/ltx/verify.go

@@ -61,7 +61,7 @@ func (c *VerifyCommand) verifyFile(ctx context.Context, filename string) error {
 	if err != nil {
 		return err
 	}
-	defer f.Close()
+	defer func() { _ = f.Close() }()
 
 	return ltx.NewDecoder(f).Verify()
 }

compactor.go

@@ -51,8 +51,8 @@ func (c *Compactor) Compact(ctx context.Context) (retErr error) {
 		}
 		if prevHdr.MaxTXID+1 != hdr.MinTXID {
 			return fmt.Errorf("non-contiguous transaction ids in input files: (%s,%s) -> (%s,%s)",
-				FormatTXID(prevHdr.MinTXID), FormatTXID(prevHdr.MaxTXID),
-				FormatTXID(hdr.MinTXID), FormatTXID(hdr.MaxTXID),
+				prevHdr.MinTXID.String(), prevHdr.MaxTXID.String(),
+				hdr.MinTXID.String(), hdr.MaxTXID.String(),
 			)
 		}
 	}

encoder.go

@@ -123,8 +123,12 @@ func (enc *Encoder) EncodeHeader(hdr Header) error {
 	// Use a compressed writer for the body if LZ4 is enabled.
 	if enc.header.Flags&HeaderFlagCompressLZ4 != 0 {
 		zw := lz4.NewWriter(enc.underlying)
-		zw.Apply(lz4.BlockSizeOption(lz4.Block64Kb)) // minimize memory allocation
-		zw.Apply(lz4.CompressionLevelOption(lz4.Fast))
+		if err := zw.Apply(lz4.BlockSizeOption(lz4.Block64Kb)); err != nil { // minimize memory allocation
+			return fmt.Errorf("cannot set lz4 block size: %w", err)
+		}
+		if err := zw.Apply(lz4.CompressionLevelOption(lz4.Fast)); err != nil {
+			return fmt.Errorf("cannot set lz4 compression level: %w", err)
+		}
 		enc.w = zw
 	}
 

ltx.go

@@ -58,7 +58,7 @@ const (
 
 // Pos represents the transactional position of a database.
 type Pos struct {
-	TXID              uint64
+	TXID              TXID
 	PostApplyChecksum uint64
 }
 
@@ -75,7 +75,7 @@ func (p Pos) IsZero() bool {
 // Marshal serializes the position into JSON.
 func (p Pos) MarshalJSON() ([]byte, error) {
 	var v posJSON
-	v.TXID = FormatTXID(p.TXID)
+	v.TXID = p.TXID.String()
 	v.PostApplyChecksum = fmt.Sprintf("%016x", p.PostApplyChecksum)
 	return json.Marshal(v)
 }
@@ -116,6 +116,51 @@ func (e *PosMismatchError) Error() string {
 	return fmt.Sprintf("ltx position mismatch (%s)", e.Pos)
 }
 
+// TXID represents a transaction ID.
+type TXID uint64
+
+// ParseTXID parses a 16-character hex string into a transaction ID.
+func ParseTXID(s string) (TXID, error) {
+	if len(s) != 16 {
+		return 0, fmt.Errorf("invalid formatted transaction id length: %q", s)
+	}
+	v, err := strconv.ParseUint(s, 16, 64)
+	if err != nil {
+		return 0, fmt.Errorf("invalid transaction id format: %q", s)
+	}
+	return TXID(v), nil
+}
+
+// String returns id formatted as a fixed-width hex number.
+func (t TXID) String() string {
+	return fmt.Sprintf("%016x", uint64(t))
+}
+
+func (t TXID) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + t.String() + `"`), nil
+}
+
+func (t *TXID) UnmarshalJSON(data []byte) (err error) {
+	var s *string
+	if err := json.Unmarshal(data, &s); err != nil {
+		return fmt.Errorf("cannot unmarshal TXID from JSON value")
+	}
+
+	// Set to zero if value is nil.
+	if s == nil {
+		*t = 0
+		return nil
+	}
+
+	txID, err := ParseTXID(*s)
+	if err != nil {
+		return fmt.Errorf("cannot parse TXID from JSON string: %q", *s)
+	}
+	*t = TXID(txID)
+
+	return nil
+}
+
 // Header flags.
 const (
 	HeaderFlagMask = uint32(0x00000001)
@@ -129,8 +174,8 @@ type Header struct {
 	Flags            uint32 // reserved flags
 	PageSize         uint32 // page size, in bytes
 	Commit           uint32 // db size after transaction, in pages
-	MinTXID          uint64 // minimum transaction ID
-	MaxTXID          uint64 // maximum transaction ID
+	MinTXID          TXID   // minimum transaction ID
+	MaxTXID          TXID   // maximum transaction ID
 	Timestamp        int64  // milliseconds since unix epoch
 	PreApplyChecksum uint64 // rolling checksum of database before applying this LTX file
 	WALOffset        int64  // file offset from original WAL; zero if journal
@@ -219,8 +264,8 @@ func (h *Header) MarshalBinary() ([]byte, error) {
 	binary.BigEndian.PutUint32(b[4:], h.Flags)
 	binary.BigEndian.PutUint32(b[8:], h.PageSize)
 	binary.BigEndian.PutUint32(b[12:], h.Commit)
-	binary.BigEndian.PutUint64(b[16:], h.MinTXID)
-	binary.BigEndian.PutUint64(b[24:], h.MaxTXID)
+	binary.BigEndian.PutUint64(b[16:], uint64(h.MinTXID))
+	binary.BigEndian.PutUint64(b[24:], uint64(h.MaxTXID))
 	binary.BigEndian.PutUint64(b[32:], uint64(h.Timestamp))
 	binary.BigEndian.PutUint64(b[40:], h.PreApplyChecksum)
 	binary.BigEndian.PutUint64(b[48:], uint64(h.WALOffset))
@@ -240,8 +285,8 @@ func (h *Header) UnmarshalBinary(b []byte) error {
 	h.Flags = binary.BigEndian.Uint32(b[4:])
 	h.PageSize = binary.BigEndian.Uint32(b[8:])
 	h.Commit = binary.BigEndian.Uint32(b[12:])
-	h.MinTXID = binary.BigEndian.Uint64(b[16:])
-	h.MaxTXID = binary.BigEndian.Uint64(b[24:])
+	h.MinTXID = TXID(binary.BigEndian.Uint64(b[16:]))
+	h.MaxTXID = TXID(binary.BigEndian.Uint64(b[24:]))
 	h.Timestamp = int64(binary.BigEndian.Uint64(b[32:]))
 	h.PreApplyChecksum = binary.BigEndian.Uint64(b[40:])
 	h.WALOffset = int64(binary.BigEndian.Uint64(b[48:]))
@@ -386,40 +431,23 @@ func ChecksumReader(r io.Reader, pageSize int) (uint64, error) {
 	return chksum, nil
 }
 
-// FormatTXID returns id formatted as a fixed-width hex number.
-func FormatTXID(id uint64) string {
-	return fmt.Sprintf("%016x", id)
-}
-
-// ParseTXID parses a 16-character hex string into a transaction ID.
-func ParseTXID(s string) (uint64, error) {
-	if len(s) != 16 {
-		return 0, fmt.Errorf("invalid formatted transaction id length: %q", s)
-	}
-	v, err := strconv.ParseUint(s, 16, 64)
-	if err != nil {
-		return 0, fmt.Errorf("invalid transaction id format: %q", s)
-	}
-	return uint64(v), nil
-}
-
 // ParseFilename parses a transaction range from an LTX file.
-func ParseFilename(name string) (minTXID, maxTXID uint64, err error) {
+func ParseFilename(name string) (minTXID, maxTXID TXID, err error) {
 	a := filenameRegex.FindStringSubmatch(name)
 	if a == nil {
 		return 0, 0, fmt.Errorf("invalid ltx filename: %s", name)
 	}
 
-	minTXID, _ = strconv.ParseUint(a[1], 16, 64)
-	maxTXID, _ = strconv.ParseUint(a[2], 16, 64)
-	return minTXID, maxTXID, nil
+	min, _ := strconv.ParseUint(a[1], 16, 64)
+	max, _ := strconv.ParseUint(a[2], 16, 64)
+	return TXID(min), TXID(max), nil
 }
 
 var filenameRegex = regexp.MustCompile(`^([0-9a-f]{16})-([0-9a-f]{16})\.ltx$`)
 
 // FormatFilename returns an LTX filename representing a range of transactions.
-func FormatFilename(minTXID, maxTXID uint64) string {
-	return fmt.Sprintf("%016x-%016x.ltx", minTXID, maxTXID)
+func FormatFilename(minTXID, maxTXID TXID) string {
+	return fmt.Sprintf("%s-%s.ltx", minTXID.String(), maxTXID.String())
 }
 
 const PENDING_BYTE = 0x40000000

ltx_test.go

@@ -3,6 +3,7 @@ package ltx_test
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 	"math"
@@ -245,9 +246,9 @@ func TestParseFilename(t *testing.T) {
 	t.Run("OK", func(t *testing.T) {
 		if min, max, err := ltx.ParseFilename("0000000000000001-00000000000003e8.ltx"); err != nil {
 			t.Fatal(err)
-		} else if got, want := min, uint64(1); got != want {
+		} else if got, want := min, ltx.TXID(1); got != want {
 			t.Fatalf("min=%d, want %d", got, want)
-		} else if got, want := max, uint64(1000); got != want {
+		} else if got, want := max, ltx.TXID(1000); got != want {
 			t.Fatalf("max=%d, want %d", got, want)
 		}
 	})
@@ -287,14 +288,72 @@ func TestChecksumReader(t *testing.T) {
 	})
 }
 
-func TestFormatTXID(t *testing.T) {
-	if got, want := ltx.FormatTXID(0), "0000000000000000"; got != want {
+func TestTXID_MarshalJSON(t *testing.T) {
+	t.Run("OK", func(t *testing.T) {
+		txID := ltx.TXID(1000)
+		if buf, err := json.Marshal(txID); err != nil {
+			t.Fatal(err)
+		} else if got, want := string(buf), `"00000000000003e8"`; got != want {
+			t.Fatalf("got=%q, want %q", got, want)
+		}
+	})
+	t.Run("Map", func(t *testing.T) {
+		m := map[string]ltx.TXID{"x": 1000, "y": 2000}
+		if buf, err := json.Marshal(m); err != nil {
+			t.Fatal(err)
+		} else if got, want := string(buf), `{"x":"00000000000003e8","y":"00000000000007d0"}`; got != want {
+			t.Fatalf("got=%q, want %q", got, want)
+		}
+	})
+}
+
+func TestTXID_UnmarshalJSON(t *testing.T) {
+	t.Run("OK", func(t *testing.T) {
+		var txID ltx.TXID
+		if err := json.Unmarshal([]byte(`"00000000000003e8"`), &txID); err != nil {
+			t.Fatal(err)
+		} else if got, want := txID, ltx.TXID(1000); got != want {
+			t.Fatalf("got=%q, want %q", got, want)
+		}
+	})
+	t.Run("Null", func(t *testing.T) {
+		var txID ltx.TXID
+		if err := json.Unmarshal([]byte(`null`), &txID); err != nil {
+			t.Fatal(err)
+		} else if got, want := txID, ltx.TXID(0); got != want {
+			t.Fatalf("got=%q, want %q", got, want)
+		}
+	})
+	t.Run("Map", func(t *testing.T) {
+		var m map[string]ltx.TXID
+		if err := json.Unmarshal([]byte(`{"x":"00000000000003e8","y":"00000000000007d0"}`), &m); err != nil {
+			t.Fatal(err)
+		} else if !reflect.DeepEqual(m, map[string]ltx.TXID{"x": 1000, "y": 2000}) {
+			t.Fatalf("unexpected map: %#v", m)
+		}
+	})
+	t.Run("ErrInvalidType", func(t *testing.T) {
+		var txID ltx.TXID
+		if err := json.Unmarshal([]byte(`123`), &txID); err == nil || err.Error() != `cannot unmarshal TXID from JSON value` {
+			t.Fatalf("unexpected error: %s", err)
+		}
+	})
+	t.Run("ErrStringFormat", func(t *testing.T) {
+		var txID ltx.TXID
+		if err := json.Unmarshal([]byte(`"xyz"`), &txID); err == nil || err.Error() != `cannot parse TXID from JSON string: "xyz"` {
+			t.Fatalf("unexpected error: %s", err)
+		}
+	})
+}
+
+func TestTXID_String(t *testing.T) {
+	if got, want := ltx.TXID(0).String(), "0000000000000000"; got != want {
 		t.Fatalf("got=%q, want %q", got, want)
 	}
-	if got, want := ltx.FormatTXID(1000), "00000000000003e8"; got != want {
+	if got, want := ltx.TXID(1000).String(), "00000000000003e8"; got != want {
 		t.Fatalf("got=%q, want %q", got, want)
 	}
-	if got, want := ltx.FormatTXID(math.MaxUint64), "ffffffffffffffff"; got != want {
+	if got, want := ltx.TXID(math.MaxUint64).String(), "ffffffffffffffff"; got != want {
 		t.Fatalf("got=%q, want %q", got, want)
 	}
 }
@@ -303,19 +362,19 @@ func TestParseTXID(t *testing.T) {
 	t.Run("OK", func(t *testing.T) {
 		if v, err := ltx.ParseTXID("0000000000000000"); err != nil {
 			t.Fatal(err)
-		} else if got, want := v, uint64(0); got != want {
+		} else if got, want := v, ltx.TXID(0); got != want {
 			t.Fatalf("got=%d, want %d", got, want)
 		}
 
 		if v, err := ltx.ParseTXID("00000000000003e8"); err != nil {
 			t.Fatal(err)
-		} else if got, want := v, uint64(1000); got != want {
+		} else if got, want := v, ltx.TXID(1000); got != want {
 			t.Fatalf("got=%d, want %d", got, want)
 		}
 
 		if v, err := ltx.ParseTXID("ffffffffffffffff"); err != nil {
 			t.Fatal(err)
-		} else if got, want := v, uint64(math.MaxUint64); got != want {
+		} else if got, want := v, ltx.TXID(math.MaxUint64); got != want {
 			t.Fatalf("got=%d, want %d", got, want)
 		}
 	})
@@ -406,18 +465,7 @@ func createFile(tb testing.TB, name string) *os.File {
 	if err != nil {
 		tb.Fatal(err)
 	}
-	tb.Cleanup(func() { f.Close() })
-	return f
-}
-
-// openFile opens a file and returns the file handle. Fail on error.
-func openFile(tb testing.TB, name string) *os.File {
-	tb.Helper()
-	f, err := os.Open(name)
-	if err != nil {
-		tb.Fatal(err)
-	}
-	tb.Cleanup(func() { f.Close() })
+	tb.Cleanup(func() { _ = f.Close() })
 	return f
 }