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

92.66

/cmd/tinykvs/shell_write.go

package main

import (
        "encoding/json"
        "fmt"
        "strings"

        "github.com/blastrain/vitess-sqlparser/sqlparser"
        "github.com/freeeve/tinykvs"
)

func (s *Shell) handleInsert(stmt *sqlparser.Insert) {
        // Extract values from INSERT
        rows, ok := stmt.Rows.(sqlparser.Values)
        if !ok || len(rows) == 0 {
                fmt.Println("Error: Invalid INSERT syntax")
                return
        }

        inserted := 0
        for _, row := range rows {
                if len(row) < 2 {
                        fmt.Println("Error: INSERT requires (key, value)")
                        continue
                }

                key := extractValue(row[0])
                value, hexBytes, isHex := extractValueAndType(row[1])

                if key == "" {
                        fmt.Println("Error: key cannot be empty")
                        continue
                }

                // Try msgpack first if it's hex data that looks like a msgpack map
                if isHex && isMsgpackMap(hexBytes) {
                        if record, err := tinykvs.DecodeMsgpack(hexBytes); err == nil {
                                if err := s.store.PutMap([]byte(key), record); err != nil {
                                        fmt.Printf("Error: %v\n", err)
                                        continue
                                }
                                inserted++
                                continue
                        }
                        // Fall through to store as bytes if msgpack decode fails
                }

                // Detect JSON and store as record
                if strings.HasPrefix(value, "{") && strings.HasSuffix(value, "}") {
                        var record map[string]any
                        if err := json.Unmarshal([]byte(value), &record); err == nil {
                                if err := s.store.PutMap([]byte(key), record); err != nil {
                                        fmt.Printf("Error: %v\n", err)
                                        continue
                                }
                                inserted++
                                continue
                        }
                }

                // Store hex data as bytes, strings as strings
                if isHex {
                        if err := s.store.PutBytes([]byte(key), hexBytes); err != nil {
                                fmt.Printf("Error: %v\n", err)
                                continue
                        }
                } else {
                        if err := s.store.PutString([]byte(key), value); err != nil {
                                fmt.Printf("Error: %v\n", err)
                                continue
                        }
                }
                inserted++
        }

        fmt.Printf("INSERT %d\n", inserted)
}

func (s *Shell) handleUpdate(stmt *sqlparser.Update) {
        // Extract key from WHERE
        var keyEquals string
        if stmt.Where != nil {
                var dummy1, dummy2, dummy3 string
                var dummyFilters []*valueFilter
                s.parseWhere(stmt.Where.Expr, &keyEquals, &dummy1, &dummy2, &dummy3, &dummyFilters)
        }

        if keyEquals == "" {
                fmt.Println("Error: UPDATE requires WHERE k = 'value'")
                return
        }

        // Extract new value from SET
        var newValue string
        for _, expr := range stmt.Exprs {
                if strings.ToLower(expr.Name.Name.String()) == "v" {
                        newValue = extractValue(expr.Expr)
                        break
                }
        }

        // Detect JSON and store as record (same logic as INSERT)
        if strings.HasPrefix(newValue, "{") && strings.HasSuffix(newValue, "}") {
                var record map[string]any
                if err := json.Unmarshal([]byte(newValue), &record); err == nil {
                        if err := s.store.PutMap([]byte(keyEquals), record); err != nil {
                                fmt.Printf("Error: %v\n", err)
                                return
                        }
                        fmt.Println("UPDATE 1")
                        return
                }
        }

        if err := s.store.PutString([]byte(keyEquals), newValue); err != nil {
                fmt.Printf("Error: %v\n", err)
                return
        }

        fmt.Println("UPDATE 1")
}

func (s *Shell) handleDelete(stmt *sqlparser.Delete) {
        var keyEquals string
        var keyPrefix string
        var keyStart, keyEnd string
        var dummyFilters []*valueFilter

        if stmt.Where != nil {
                s.parseWhere(stmt.Where.Expr, &keyEquals, &keyPrefix, &keyStart, &keyEnd, &dummyFilters)
        }

        if keyEquals != "" {
                // Delete single key
                if err := s.store.Delete([]byte(keyEquals)); err != nil {
                        fmt.Printf("Error: %v\n", err)
                        return
                }
                fmt.Println("DELETE 1")
        } else if keyPrefix != "" {
                // Delete by prefix
                deleted, err := s.store.DeletePrefix([]byte(keyPrefix))
                if err != nil {
                        fmt.Printf("Error: %v\n", err)
                        return
                }
                fmt.Printf("DELETE %d\n", deleted)
        } else if keyStart != "" && keyEnd != "" {
                // Delete range
                deleted, err := s.store.DeleteRange([]byte(keyStart), []byte(keyEnd))
                if err != nil {
                        fmt.Printf("Error: %v\n", err)
                        return
                }
                fmt.Printf("DELETE %d\n", deleted)
        } else {
                fmt.Println("Error: DELETE requires WHERE clause")
        }
}

1	package main
2
3	import (
4	"encoding/json"
5	"fmt"
6	"strings"
7
8	"github.com/blastrain/vitess-sqlparser/sqlparser"
9	"github.com/freeeve/tinykvs"
10	)
11
12	func (s Shell) handleInsert(stmt sqlparser.Insert) {	178✔
13	// Extract values from INSERT	178✔
14	rows, ok := stmt.Rows.(sqlparser.Values)	178✔
15	if !ok \|\| len(rows) == 0 {	178✔
NEW 16	fmt.Println("Error: Invalid INSERT syntax")	×
NEW 17	return	×
NEW 18	}	×
19
20	inserted := 0	178✔
21	for _, row := range rows {	358✔
22	if len(row) < 2 {	181✔
23	fmt.Println("Error: INSERT requires (key, value)")	1✔
24	continue	1✔
25	}
26
27	key := extractValue(row[0])	179✔
28	value, hexBytes, isHex := extractValueAndType(row[1])	179✔
29		179✔
30	if key == "" {	180✔
31	fmt.Println("Error: key cannot be empty")	1✔
32	continue	1✔
33	}
34
35	// Try msgpack first if it's hex data that looks like a msgpack map
36	if isHex && isMsgpackMap(hexBytes) {	182✔
37	if record, err := tinykvs.DecodeMsgpack(hexBytes); err == nil {	5✔
38	if err := s.store.PutMap([]byte(key), record); err != nil {	1✔
NEW 39	fmt.Printf("Error: %v\n", err)	×
NEW 40	continue	×
41	}
42	inserted++	1✔
43	continue	1✔
44	}
45	// Fall through to store as bytes if msgpack decode fails
46	}
47
48	// Detect JSON and store as record
49	if strings.HasPrefix(value, "{") && strings.HasSuffix(value, "}") {	219✔
50	var record map[string]any	42✔
51	if err := json.Unmarshal([]byte(value), &record); err == nil {	83✔
52	if err := s.store.PutMap([]byte(key), record); err != nil {	42✔
53	fmt.Printf("Error: %v\n", err)	1✔
54	continue	1✔
55	}
56	inserted++	40✔
57	continue	40✔
58	}
59	}
60
61	// Store hex data as bytes, strings as strings
62	if isHex {	141✔
63	if err := s.store.PutBytes([]byte(key), hexBytes); err != nil {	7✔
64	fmt.Printf("Error: %v\n", err)	2✔
65	continue	2✔
66	}
67	} else {	131✔
68	if err := s.store.PutString([]byte(key), value); err != nil {	132✔
69	fmt.Printf("Error: %v\n", err)	1✔
70	continue	1✔
71	}
72	}
73	inserted++	133✔
74	}
75
76	fmt.Printf("INSERT %d\n", inserted)	178✔
77	}
78
79	func (s Shell) handleUpdate(stmt sqlparser.Update) {	6✔
80	// Extract key from WHERE	6✔
81	var keyEquals string	6✔
82	if stmt.Where != nil {	11✔
83	var dummy1, dummy2, dummy3 string	5✔
84	var dummyFilters []*valueFilter	5✔
85	s.parseWhere(stmt.Where.Expr, &keyEquals, &dummy1, &dummy2, &dummy3, &dummyFilters)	5✔
86	}	5✔
87
88	if keyEquals == "" {	7✔
89	fmt.Println("Error: UPDATE requires WHERE k = 'value'")	1✔
90	return	1✔
91	}	1✔
92
93	// Extract new value from SET
94	var newValue string	5✔
95	for _, expr := range stmt.Exprs {	10✔
96	if strings.ToLower(expr.Name.Name.String()) == "v" {	9✔
97	newValue = extractValue(expr.Expr)	4✔
98	break	4✔
99	}
100	}
101
102	// Detect JSON and store as record (same logic as INSERT)
103	if strings.HasPrefix(newValue, "{") && strings.HasSuffix(newValue, "}") {	6✔
104	var record map[string]any	1✔
105	if err := json.Unmarshal([]byte(newValue), &record); err == nil {	2✔
106	if err := s.store.PutMap([]byte(keyEquals), record); err != nil {	1✔
NEW 107	fmt.Printf("Error: %v\n", err)	×
NEW 108	return	×
NEW 109	}	×
110	fmt.Println("UPDATE 1")	1✔
111	return	1✔
112	}
113	}
114
115	if err := s.store.PutString([]byte(keyEquals), newValue); err != nil {	5✔
116	fmt.Printf("Error: %v\n", err)	1✔
117	return	1✔
118	}	1✔
119
120	fmt.Println("UPDATE 1")	3✔
121	}
122
123	func (s Shell) handleDelete(stmt sqlparser.Delete) {	13✔
124	var keyEquals string	13✔
125	var keyPrefix string	13✔
126	var keyStart, keyEnd string	13✔
127	var dummyFilters []*valueFilter	13✔
128		13✔
129	if stmt.Where != nil {	25✔
130	s.parseWhere(stmt.Where.Expr, &keyEquals, &keyPrefix, &keyStart, &keyEnd, &dummyFilters)	12✔
131	}	12✔
132
133	if keyEquals != "" {	17✔
134	// Delete single key	4✔
135	if err := s.store.Delete([]byte(keyEquals)); err != nil {	5✔
136	fmt.Printf("Error: %v\n", err)	1✔
137	return	1✔
138	}	1✔
139	fmt.Println("DELETE 1")	3✔
140	} else if keyPrefix != "" {	13✔
141	// Delete by prefix	4✔
142	deleted, err := s.store.DeletePrefix([]byte(keyPrefix))	4✔
143	if err != nil {	5✔
144	fmt.Printf("Error: %v\n", err)	1✔
145	return	1✔
146	}	1✔
147	fmt.Printf("DELETE %d\n", deleted)	3✔
148	} else if keyStart != "" && keyEnd != "" {	9✔
149	// Delete range	4✔
150	deleted, err := s.store.DeleteRange([]byte(keyStart), []byte(keyEnd))	4✔
151	if err != nil {	5✔
152	fmt.Printf("Error: %v\n", err)	1✔
153	return	1✔
154	}	1✔
155	fmt.Printf("DELETE %d\n", deleted)	3✔
156	} else {	1✔
157	fmt.Println("Error: DELETE requires WHERE clause")	1✔
158	}	1✔
159	}

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