fixed compare behaviour

pkg/linedb/cache.go

@@ -1,6 +1,7 @@
 package linedb
 
 import (
+	"strings"
 	"sync"
 	"time"
 )
@@ -94,6 +95,37 @@ func (c *RecordCache) Clear() {
 	c.cache = make(map[string]*CacheEntry)
 }
 
+// ClearCollection удаляет записи кэша, относящиеся к коллекции collectionName:
+// ключи ReadByFilter ("collection:filter" и "collection_part:filter") и SetByRecord ("id:collection", "id:collection_part").
+func (c *RecordCache) ClearCollection(collectionName string) {
+	if collectionName == "" {
+		c.Clear()
+		return
+	}
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	for key := range c.cache {
+		if cacheKeyBelongsToCollection(key, collectionName) {
+			delete(c.cache, key)
+		}
+	}
+}
+
+func cacheKeyBelongsToCollection(key, collectionName string) bool {
+	if strings.HasPrefix(key, collectionName+":") {
+		return true
+	}
+	if strings.HasPrefix(key, collectionName+"_") {
+		return true
+	}
+	idx := strings.LastIndex(key, ":")
+	if idx < 0 {
+		return false
+	}
+	suf := key[idx+1:]
+	return suf == collectionName || strings.HasPrefix(suf, collectionName+"_")
+}
+
 // ClearEntriesContainingIDs удаляет из кэша только те записи, в данных которых
 // встречается хотя бы один из переданных id. Если ids пуст — ничего не делает.
 func (c *RecordCache) ClearEntriesContainingIDs(ids []any) {

pkg/linedb/jsonl_file.go

@@ -1103,14 +1103,18 @@ func (j *JSONLFile) valuesMatch(a, b any, strictCompare bool) bool {
 		return a == b
 	}
 
-	// Для строк - нечувствительное к регистру сравнение
+	if a == b {
+		return true
+	}
+
+	// Для строк - нечувствительное к регистру сравнение (равенство, не подстрока)
 	if aStr, ok := a.(string); ok {
 		if bStr, ok := b.(string); ok {
-			return strings.Contains(strings.ToLower(aStr), strings.ToLower(bStr))
+			return matchStringByPattern(aStr, bStr, strictCompare)
 		}
 	}
 
-	return a == b
+	return false
 }
 
 // rewriteFile перезаписывает файл новыми данными

pkg/linedb/line_db.go

@@ -88,6 +88,8 @@ func (db *LineDb) Init(force bool, initOptions *LineDbInitOptions) error {
 	if dbFolder == "" {
 		dbFolder = "linedb"
 	}
+	// Нормализуем и сохраняем фактический путь, чтобы партиции создавались в той же папке
+	db.initOptions.DBFolder = dbFolder
 
 	if err := os.MkdirAll(dbFolder, 0755); err != nil {
 		return fmt.Errorf("failed to create database folder: %w", err)
@@ -229,7 +231,13 @@ func (db *LineDb) seedLastIDPartitioned(dbFolder, baseName string) error {
 		if existing, ok := db.adapters[partName]; ok {
 			adapter = existing
 		} else {
-			adapter = NewJSONLFile(path, "", JSONLFileOptions{CollectionName: partName})
+			// Партиции должны наследовать опции базовой коллекции (allocSize/encode/crypto/marshal/etc.)
+			opts := JSONLFileOptions{CollectionName: partName}
+			if baseOpts := db.getCollectionOptions(baseName); baseOpts != nil {
+				opts = *baseOpts
+				opts.CollectionName = partName
+			}
+			adapter = NewJSONLFile(path, opts.EncryptKeyForLineDb, opts)
 			if err := adapter.Init(false, LineDbAdapterOptions{}); err != nil {
 				continue
 			}
@@ -392,12 +400,7 @@ func (db *LineDb) Insert(data any, collectionName string, options LineDbAdapterO
 		return fmt.Errorf("failed to write data: %w", err)
 	}
 
-	// Обновляем кэш
+	db.clearCacheForCollection(collectionName)
-	if db.cacheExternal != nil {
-		for _, item := range resultDataArray {
-			db.cacheExternal.UpdateCacheAfterInsert(item, collectionName)
-		}
-	}
 
 	return nil
 }
@@ -530,10 +533,7 @@ func (db *LineDb) Update(data any, collectionName string, filter any, options Li
 			return nil, err
 		}
 		if used {
-			if db.cacheExternal != nil {
+			db.clearCacheForCollection(collectionName)
-				ids := extractIDsFromRecords(result)
-				db.cacheExternal.ClearEntriesContainingIDs(ids)
-			}
 			return result, nil
 		}
 	}
@@ -552,10 +552,7 @@ func (db *LineDb) Update(data any, collectionName string, filter any, options Li
 			}
 		}
 	}
-	if db.cacheExternal != nil {
+	db.clearCacheForCollection(collectionName)
-		ids := extractIDsFromRecords(result)
-		db.cacheExternal.ClearEntriesContainingIDs(ids)
-	}
 	return result, nil
 }
 
@@ -596,10 +593,7 @@ func (db *LineDb) Delete(data any, collectionName string, options LineDbAdapterO
 			return nil, err
 		}
 		if used {
-			if db.cacheExternal != nil {
+			db.clearCacheForCollection(collectionName)
-				ids := extractIDsFromRecords(result)
-				db.cacheExternal.ClearEntriesContainingIDs(ids)
-			}
 			return result, nil
 		}
 	}
@@ -618,10 +612,7 @@ func (db *LineDb) Delete(data any, collectionName string, options LineDbAdapterO
 			}
 		}
 	}
-	if db.cacheExternal != nil {
+	db.clearCacheForCollection(collectionName)
-		ids := extractIDsFromRecords(result)
-		db.cacheExternal.ClearEntriesContainingIDs(ids)
-	}
 	return result, nil
 }
 
@@ -672,7 +663,7 @@ func (db *LineDb) ReadByFilter(filter any, collectionName string, options LineDb
 			if err != nil || (options.FailOnFailureIndexRead && !hit) {
 				return nil, fmt.Errorf("index read failed: %w", err)
 			}
-			if hit && err == nil {
+			if hit {
 				if db.cacheExternal != nil && !options.InTransaction {
 					db.cacheExternal.Set(db.generateCacheKey(filter, collectionName), result)
 				}
@@ -703,7 +694,7 @@ func (db *LineDb) ReadByFilter(filter any, collectionName string, options LineDb
 		if err != nil || (options.FailOnFailureIndexRead && !hit) {
 			return nil, fmt.Errorf("index read failed: %w", err)
 		}
-		if hit && err == nil {
+		if hit {
 			if db.cacheExternal != nil && !options.InTransaction {
 				db.cacheExternal.Set(db.generateCacheKey(filter, collectionName), result)
 			}
@@ -758,15 +749,21 @@ func (db *LineDb) ClearCache(collectionName string, options LineDbAdapterOptions
 		if collectionName == "" {
 			db.cacheExternal.Clear()
 		} else {
-			// Очищаем только записи для конкретной коллекции
+			db.cacheExternal.ClearCollection(collectionName)
-			// Это упрощенная реализация
-			db.cacheExternal.Clear()
 		}
 	}
 
 	return nil
 }
 
+// clearCacheForCollection сбрасывает кэш запросов по логической коллекции (включая ключи партиций base_*).
+func (db *LineDb) clearCacheForCollection(collectionName string) {
+	if db.cacheExternal == nil || collectionName == "" {
+		return
+	}
+	db.cacheExternal.ClearCollection(collectionName)
+}
+
 // Close закрывает базу данных
 func (db *LineDb) Close() {
 	db.mutex.Lock()
@@ -1159,7 +1156,7 @@ func (db *LineDb) getCollectionOptions(collectionName string) *JSONLFileOptions
 }
 
 // isValueEmpty проверяет, считается ли значение "пустым" (nil или "" для string) — для обратной совместимости
-func (db *LineDb) isValueEmpty(v any) bool {
+func (db *LineDb) IsValueEmpty(v any) bool {
 	if v == nil {
 		return true
 	}
@@ -1397,7 +1394,13 @@ func (db *LineDb) getPartitionAdapter(data any, collectionName string) (*JSONLFi
 	if !exists {
 		// Создаем новый адаптер для партиции
 		filename := filepath.Join(db.initOptions.DBFolder, partitionName+".jsonl")
-		adapter = NewJSONLFile(filename, "", JSONLFileOptions{CollectionName: partitionName})
+		// Партиции должны наследовать опции базовой коллекции (allocSize/encode/crypto/marshal/etc.)
+		opts := JSONLFileOptions{CollectionName: partitionName}
+		if baseOpts := db.getCollectionOptions(collectionName); baseOpts != nil {
+			opts = *baseOpts
+			opts.CollectionName = partitionName
+		}
+		adapter = NewJSONLFile(filename, opts.EncryptKeyForLineDb, opts)
 
 		if err := adapter.Init(false, LineDbAdapterOptions{}); err != nil {
 			return nil, fmt.Errorf("failed to init partition adapter: %w", err)
@@ -1471,7 +1474,7 @@ func (db *LineDb) valuesMatch(a, b any, strictCompare bool) bool {
 	// Сравнение строк
 	if aStr, ok := a.(string); ok {
 		if bStr, ok := b.(string); ok {
-			return strings.EqualFold(aStr, bStr)
+			return matchStringByPattern(aStr, bStr, strictCompare)
 		}
 	}
 
@@ -1561,24 +1564,6 @@ func (db *LineDb) compareIDs(a, b any) bool {
 	return a == b
 }
 
-// extractIDsFromRecords извлекает id из списка записей (map[string]any).
-func extractIDsFromRecords(records []any) []any {
-	if len(records) == 0 {
-		return nil
-	}
-	ids := make([]any, 0, len(records))
-	for _, rec := range records {
-		m, ok := rec.(map[string]any)
-		if !ok {
-			continue
-		}
-		if id, exists := m["id"]; exists && id != nil {
-			ids = append(ids, id)
-		}
-	}
-	return ids
-}
-
 func (db *LineDb) generateCacheKey(filter any, collectionName string) string {
 	// Упрощенная реализация генерации ключа кэша
 	return fmt.Sprintf("%s:%v", collectionName, filter)
@@ -1677,6 +1662,7 @@ func (db *LineDb) updatePartitioned(data any, collectionName string, filter any,
 		}
 	}
 
+	db.clearCacheForCollection(collectionName)
 	return allResults, nil
 }
 
@@ -1710,6 +1696,7 @@ func (db *LineDb) deletePartitioned(data any, collectionName string, options Lin
 		}
 	}
 
+	db.clearCacheForCollection(collectionName)
 	return allResults, nil
 }
 

pkg/linedb/string_match.go

@@ -0,0 +1,118 @@
+package linedb
+
+import "strings"
+
+type stringMatchMode int
+
+const (
+	stringMatchEqual stringMatchMode = iota
+	stringMatchContains
+	stringMatchHasPrefix
+	stringMatchHasSuffix
+)
+
+func matchStringByPattern(value string, pattern string, strictCompare bool) bool {
+	mode, lit := parsePercentPattern(pattern)
+
+	if !strictCompare {
+		// For substring checks we use ToLower (close enough to EqualFold intent).
+		value = strings.ToLower(value)
+		lit = strings.ToLower(lit)
+	}
+
+	switch mode {
+	case stringMatchContains:
+		return strings.Contains(value, lit)
+	case stringMatchHasPrefix:
+		return strings.HasPrefix(value, lit)
+	case stringMatchHasSuffix:
+		return strings.HasSuffix(value, lit)
+	default:
+		if strictCompare {
+			return value == lit
+		}
+		return strings.EqualFold(value, lit)
+	}
+}
+
+// parsePercentPattern interprets unescaped % at the start/end of pattern:
+// - %foo% => contains "foo"
+// - foo%  => hasPrefix "foo"
+// - %foo  => hasSuffix "foo"
+// - foo   => equal "foo"
+// Escaping: \% means literal %, \\ means literal \ (only affects escape processing).
+func parsePercentPattern(pattern string) (stringMatchMode, string) {
+	if pattern == "" {
+		return stringMatchEqual, ""
+	}
+
+	leading := pattern[0] == '%'
+	trailing := len(pattern) > 0 && pattern[len(pattern)-1] == '%' && !isEscapedAt(pattern, len(pattern)-1)
+
+	start := 0
+	end := len(pattern)
+	if leading {
+		start = 1
+	}
+	if trailing && end > start {
+		end--
+	}
+	lit := unescapePercents(pattern[start:end])
+
+	switch {
+	case leading && trailing:
+		return stringMatchContains, lit
+	case trailing:
+		return stringMatchHasPrefix, lit
+	case leading:
+		return stringMatchHasSuffix, lit
+	default:
+		return stringMatchEqual, unescapePercents(pattern)
+	}
+}
+
+func isEscapedAt(s string, idx int) bool {
+	// idx is escaped if preceded by an odd number of backslashes.
+	if idx <= 0 || idx >= len(s) {
+		return false
+	}
+	n := 0
+	for i := idx - 1; i >= 0 && s[i] == '\\'; i-- {
+		n++
+	}
+	return n%2 == 1
+}
+
+func unescapePercents(s string) string {
+	if s == "" {
+		return ""
+	}
+	var b strings.Builder
+	b.Grow(len(s))
+	esc := false
+	for i := 0; i < len(s); i++ {
+		ch := s[i]
+		if esc {
+			// Only unescape % and \; keep backslash for other chars.
+			if ch == '%' || ch == '\\' {
+				b.WriteByte(ch)
+			} else {
+				b.WriteByte('\\')
+				b.WriteByte(ch)
+			}
+			esc = false
+			continue
+		}
+		if ch == '\\' {
+			esc = true
+			continue
+		}
+		b.WriteByte(ch)
+	}
+	if esc {
+		// dangling backslash
+		b.WriteByte('\\')
+	}
+	return b.String()
+}
+