intern error strings

This changes the error message cache to intern the error
strings/messages. The reasoning for this change is that sqlite3 has a
finite number of constant error strings, but potential misuse of the
cache could lead to it growing unbounded with a large number of
essentially duplicate error messages.

Author: charlievieth

error.go

@@ -15,6 +15,7 @@ package sqlite3
 import "C"
 import (
 	"sync"
+	"sync/atomic"
 	"syscall"
 )
 
@@ -152,7 +153,11 @@ const (
 	ErrWarningAutoIndex       = ErrNoExtended(ErrWarning | 1<<8)
 )
 
-var errStrCache sync.Map // int => string
+var errStrCache struct {
+	sync.Map               // int => string
+	size     atomic.Uint64 // size of cache
+	intern   sync.Map      // interned error messages: string => string
+}
 
 // errorString returns the result of sqlite3_errstr for result code rv,
 // which may be cached.
@@ -161,11 +166,24 @@ func errorString(rv int) string {
 		return v.(string)
 	}
 	s := C.GoString(C.sqlite3_errstr(C.int(rv)))
-	// Prevent the cache from growing unbounded by ignoring invalid
-	// error codes.
-	if s != "unknown error" {
+	if s == "unknown error" {
+		// Prevent the cache from growing unbounded by ignoring invalid
+		// error codes.
+		return "unknown error"
+	}
+	if v, loaded := errStrCache.intern.LoadOrStore(s, s); loaded {
+		s = v.(string)
+	}
+	// NB: This is limit is not precise and we may exceed
+	// it if this function is called concurrently.
+	//
+	// TODO: make the limit less than a power of 2 to reduce
+	// the chance that we resize the map if it is exceeded.
+	if errStrCache.size.Load() < 1024 {
 		if v, loaded := errStrCache.LoadOrStore(rv, s); loaded {
 			s = v.(string)
+		} else {
+			errStrCache.size.Add(1)
 		}
 	}
 	return s

error_test.go

@@ -274,3 +274,27 @@ func TestError_SystemErrno(t *testing.T) {
 		t.Errorf("expected SystemErrno to be a not exists error, but got %v", serr.SystemErrno)
 	}
 }
+
+func TestErrorStringCacheSize(t *testing.T) {
+	for i := 0; i < 50_000; i++ {
+		_ = errorString(i)
+	}
+	n := 0
+	o := 0
+	errStrCache.Range(func(_, v any) bool {
+		n++
+		return true
+	})
+	errStrCache.intern.Range(func(_, v any) bool {
+		o++
+		return true
+	})
+	if n > 1024 {
+		t.Fatalf("len(errStrCache) should be capped at %d got: %d", 1024, n)
+	}
+	if o > 128 {
+		// If sqlite3 adds a lot of new error messages this value
+		// will need to be increased.
+		t.Errorf("expected errStrMsgCache to be below %d got: %d", 128, o)
+	}
+}