21101309417

Committed 17 Jan 2026 09:42PM UTC coverage: 68.627% (-4.3%) from 72.975%

Build # 21101309417

Build Type

push

github

Committed by

freeeve

Commit Message

feat: add ORDER BY support and box-style table formatting

New features:
- ORDER BY support in SQL queries (ASC/DESC, multiple columns)
- Box-style table formatting with Unicode borders
- GitHub Actions CI for multi-platform releases (linux/darwin/windows × amd64/arm64)
- Build script with ldflags for version embedding

Improvements:
- Split shell.go into logical modules (shell_select.go, shell_write.go,
  shell_csv.go, shell_sql.go, shell_sort.go)
- Version string no longer shows redundant commit hash
- Reorganized tests into corresponding test files
- Added batch_parallel.go for parallel batch operations
- Test coverage improvements

Run Details

975 of 1677 new or added lines in 11 files covered. (58.14%)

8 existing lines in 3 files now uncovered.

5180 of 7548 relevant lines covered (68.63%)

430934.64 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.24

/batch_parallel.go

package tinykvs

import (
        "runtime"
        "sync"

        "github.com/vmihailenco/msgpack/v5"
)

// KeyStruct pairs a key with a struct value for bulk operations.
type KeyStruct struct {
        Key   []byte
        Value any
}

// putStructsParallel encodes and adds multiple structs in parallel.
// Uses all available CPU cores for encoding, then appends results atomically.
func (b *Batch) putStructsParallel(items []KeyStruct) error {
        return b.putStructsParallelN(items, runtime.NumCPU())
}

// putStructsParallelN encodes and adds multiple structs using n workers.
func (b *Batch) putStructsParallelN(items []KeyStruct, numWorkers int) error {
        if len(items) == 0 {
                return nil
        }

        if numWorkers <= 1 || len(items) < numWorkers {
                // Fall back to sequential for small batches
                for _, item := range items {
                        if err := b.PutStruct(item.Key, item.Value); err != nil {
                                return err
                        }
                }
                return nil
        }

        // Pre-allocate results slice
        results := make([]batchOp, len(items))
        var firstErr error
        var errOnce sync.Once

        // Create work chunks
        chunkSize := (len(items) + numWorkers - 1) / numWorkers
        var wg sync.WaitGroup

        for w := 0; w < numWorkers; w++ {
                start := w * chunkSize
                end := start + chunkSize
                if end > len(items) {
                        end = len(items)
                }
                if start >= end {
                        break
                }

                wg.Add(1)
                go func(start, end int) {
                        defer wg.Done()
                        for i := start; i < end; i++ {
                                item := items[i]
                                data, err := msgpack.Marshal(item.Value)
                                if err != nil {
                                        errOnce.Do(func() { firstErr = err })
                                        return
                                }
                                keyCopy := make([]byte, len(item.Key))
                                copy(keyCopy, item.Key)
                                results[i] = batchOp{key: keyCopy, value: MsgpackValue(data), delete: false}
                        }
                }(start, end)
        }

        wg.Wait()

        if firstErr != nil {
                return firstErr
        }

        // Append all results
        b.ops = append(b.ops, results...)
        return nil
}

// PutStructs writes multiple structs in parallel.
// This is the fastest way to ingest many structs - it parallelizes encoding
// across all CPU cores, then writes atomically.
func (s *Store) PutStructs(items []KeyStruct) error {
        if len(items) == 0 {
                return nil
        }

        // Parallel encode
        batch := NewBatch()
        if err := batch.putStructsParallel(items); err != nil {
                return err
        }

        // Write atomically
        return s.WriteBatch(batch)
}

1	package tinykvs
2
3	import (
4	"runtime"
5	"sync"
6
7	"github.com/vmihailenco/msgpack/v5"
8	)
9
10	// KeyStruct pairs a key with a struct value for bulk operations.
11	type KeyStruct struct {
12	Key []byte
13	Value any
14	}
15
16	// putStructsParallel encodes and adds multiple structs in parallel.
17	// Uses all available CPU cores for encoding, then appends results atomically.
18	func (b *Batch) putStructsParallel(items []KeyStruct) error {	1✔
19	return b.putStructsParallelN(items, runtime.NumCPU())	1✔
20	}	1✔
21
22	// putStructsParallelN encodes and adds multiple structs using n workers.
23	func (b *Batch) putStructsParallelN(items []KeyStruct, numWorkers int) error {	1✔
24	if len(items) == 0 {	1✔
NEW 25	return nil	×
NEW 26	}	×
27
28	if numWorkers <= 1 \|\| len(items) < numWorkers {	1✔
NEW 29	// Fall back to sequential for small batches	×
NEW 30	for _, item := range items {	×
NEW 31	if err := b.PutStruct(item.Key, item.Value); err != nil {	×
NEW 32	return err	×
NEW 33	}	×
34	}
NEW 35	return nil	×
36	}
37
38	// Pre-allocate results slice
39	results := make([]batchOp, len(items))	1✔
40	var firstErr error	1✔
41	var errOnce sync.Once	1✔
42		1✔
43	// Create work chunks	1✔
44	chunkSize := (len(items) + numWorkers - 1) / numWorkers	1✔
45	var wg sync.WaitGroup	1✔
46		1✔
47	for w := 0; w < numWorkers; w++ {	5✔
48	start := w * chunkSize	4✔
49	end := start + chunkSize	4✔
50	if end > len(items) {	4✔
NEW 51	end = len(items)	×
NEW 52	}	×
53	if start >= end {	4✔
NEW 54	break	×
55	}
56
57	wg.Add(1)	4✔
58	go func(start, end int) {	8✔
59	defer wg.Done()	4✔
60	for i := start; i < end; i++ {	1,004✔
61	item := items[i]	1,000✔
62	data, err := msgpack.Marshal(item.Value)	1,000✔
63	if err != nil {	1,000✔
NEW 64	errOnce.Do(func() { firstErr = err })	×
NEW 65	return	×
66	}
67	keyCopy := make([]byte, len(item.Key))	1,000✔
68	copy(keyCopy, item.Key)	1,000✔
69	results[i] = batchOp{key: keyCopy, value: MsgpackValue(data), delete: false}	1,000✔
70	}
71	}(start, end)
72	}
73
74	wg.Wait()	1✔
75		1✔
76	if firstErr != nil {	1✔
NEW 77	return firstErr	×
NEW 78	}	×
79
80	// Append all results
81	b.ops = append(b.ops, results...)	1✔
82	return nil	1✔
83	}
84
85	// PutStructs writes multiple structs in parallel.
86	// This is the fastest way to ingest many structs - it parallelizes encoding
87	// across all CPU cores, then writes atomically.
88	func (s *Store) PutStructs(items []KeyStruct) error {	1✔
89	if len(items) == 0 {	1✔
NEW 90	return nil	×
NEW 91	}	×
92
93	// Parallel encode
94	batch := NewBatch()	1✔
95	if err := batch.putStructsParallel(items); err != nil {	1✔
NEW 96	return err	×
NEW 97	}	×
98
99	// Write atomically
100	return s.WriteBatch(batch)	1✔
101	}

freeeve / tinykvs / 21101309417

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous