add a filter query cache 512mb that stores already decoded recent query results

this should improve performance noticeably for typical kind 1 client queries

pkg/database/save-event.go

@@ -5,6 +5,8 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"os"
+	"strconv"
 	"strings"
 
 	"github.com/dgraph-io/badger/v4"
@@ -34,7 +36,9 @@ func (d *D) GetSerialsFromFilter(f *filter.F) (
 		return
 	}
 	// Pre-allocate slice with estimated capacity to reduce reallocations
-	sers = make(types.Uint40s, 0, len(idxs)*100) // Estimate 100 serials per index
+	sers = make(
+		types.Uint40s, 0, len(idxs)*100,
+	) // Estimate 100 serials per index
 	for _, idx := range idxs {
 		var s types.Uint40s
 		if s, err = d.GetSerialsByRange(idx); chk.E(err) {
@@ -111,13 +115,13 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 		err = errors.New("nil event")
 		return
 	}
-	
+
 	// Reject ephemeral events (kinds 20000-29999) - they should never be stored
 	if ev.Kind >= 20000 && ev.Kind <= 29999 {
 		err = errors.New("blocked: ephemeral events should not be stored")
 		return
 	}
-	
+
 	// check if the event already exists
 	var ser *types.Uint40
 	if ser, err = d.GetSerialById(ev.ID); err == nil && ser != nil {
@@ -176,7 +180,10 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 	if idxs, err = GetIndexesForEvent(ev, serial); chk.E(err) {
 		return
 	}
-	log.T.F("SaveEvent: generated %d indexes for event %x (kind %d)", len(idxs), ev.ID, ev.Kind)
+	log.T.F(
+		"SaveEvent: generated %d indexes for event %x (kind %d)", len(idxs),
+		ev.ID, ev.Kind,
+	)
 
 	// Serialize event once to check size
 	eventDataBuf := new(bytes.Buffer)
@@ -184,9 +191,15 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 	eventData := eventDataBuf.Bytes()
 
 	// Determine storage strategy (Reiser4 optimizations)
-	// 384 bytes covers: ID(32) + Pubkey(32) + Sig(64) + basic fields + small content
-	const smallEventThreshold = 384
-	isSmallEvent := len(eventData) <= smallEventThreshold
+	// Get threshold from environment, default to 0 (disabled)
+	// When enabled, typical values: 384 (conservative), 512 (recommended), 1024 (aggressive)
+	smallEventThreshold := 1024
+	if v := os.Getenv("ORLY_INLINE_EVENT_THRESHOLD"); v != "" {
+		if n, perr := strconv.Atoi(v); perr == nil && n >= 0 {
+			smallEventThreshold = n
+		}
+	}
+	isSmallEvent := smallEventThreshold > 0 && len(eventData) <= smallEventThreshold
 	isReplaceableEvent := kind.IsReplaceable(ev.Kind)
 	isAddressableEvent := kind.IsParameterizedReplaceable(ev.Kind)
 
@@ -224,7 +237,9 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 					return
 				}
 				// Append size as uint16 big-endian (2 bytes for size up to 65535)
-				sizeBytes := []byte{byte(len(eventData) >> 8), byte(len(eventData))}
+				sizeBytes := []byte{
+					byte(len(eventData) >> 8), byte(len(eventData)),
+				}
 				keyBuf.Write(sizeBytes)
 				// Append event data
 				keyBuf.Write(eventData)
@@ -232,7 +247,10 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 				if err = txn.Set(keyBuf.Bytes(), nil); chk.E(err) {
 					return
 				}
-				log.T.F("SaveEvent: stored small event inline (%d bytes)", len(eventData))
+				log.T.F(
+					"SaveEvent: stored small event inline (%d bytes)",
+					len(eventData),
+				)
 			} else {
 				// Large event: store separately with evt prefix
 				keyBuf := new(bytes.Buffer)
@@ -242,7 +260,10 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 				if err = txn.Set(keyBuf.Bytes(), eventData); chk.E(err) {
 					return
 				}
-				log.T.F("SaveEvent: stored large event separately (%d bytes)", len(eventData))
+				log.T.F(
+					"SaveEvent: stored large event separately (%d bytes)",
+					len(eventData),
+				)
 			}
 
 			// Additionally, store replaceable/addressable events with specialized keys for direct access
@@ -256,11 +277,15 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 				dTagHash.FromIdent(dTag.Value())
 
 				keyBuf := new(bytes.Buffer)
-				if err = indexes.AddressableEventEnc(pubHash, kindVal, dTagHash).MarshalWrite(keyBuf); chk.E(err) {
+				if err = indexes.AddressableEventEnc(
+					pubHash, kindVal, dTagHash,
+				).MarshalWrite(keyBuf); chk.E(err) {
 					return
 				}
 				// Append size as uint16 big-endian
-				sizeBytes := []byte{byte(len(eventData) >> 8), byte(len(eventData))}
+				sizeBytes := []byte{
+					byte(len(eventData) >> 8), byte(len(eventData)),
+				}
 				keyBuf.Write(sizeBytes)
 				// Append event data
 				keyBuf.Write(eventData)
@@ -277,11 +302,15 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 				kindVal.Set(ev.Kind)
 
 				keyBuf := new(bytes.Buffer)
-				if err = indexes.ReplaceableEventEnc(pubHash, kindVal).MarshalWrite(keyBuf); chk.E(err) {
+				if err = indexes.ReplaceableEventEnc(
+					pubHash, kindVal,
+				).MarshalWrite(keyBuf); chk.E(err) {
 					return
 				}
 				// Append size as uint16 big-endian
-				sizeBytes := []byte{byte(len(eventData) >> 8), byte(len(eventData))}
+				sizeBytes := []byte{
+					byte(len(eventData) >> 8), byte(len(eventData)),
+				}
 				keyBuf.Write(sizeBytes)
 				// Append event data
 				keyBuf.Write(eventData)
@@ -297,7 +326,7 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 	if err != nil {
 		return
 	}
-	
+
 	// Process deletion events to actually delete the referenced events
 	if ev.Kind == kind.Deletion.K {
 		if err = d.ProcessDelete(ev, nil); chk.E(err) {
@@ -306,5 +335,13 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 			err = nil
 		}
 	}
+
+	// Invalidate query cache since a new event was stored
+	// This ensures subsequent queries will see the new event
+	if d.queryCache != nil {
+		d.queryCache.Invalidate()
+		log.T.F("SaveEvent: invalidated query cache")
+	}
+
 	return
 }