1785 lines
60 KiB
Go
1785 lines
60 KiB
Go
/*
|
||
* Copyright 2026 Safronov Grigorii
|
||
*
|
||
* Licensed under the CDDL, Version 1.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
*
|
||
* You may obtain a copy of the License at
|
||
* https://opensource.org/licenses/CDDL-1.0
|
||
*/
|
||
|
||
// Файл: internal/storage/collection.go
|
||
// Назначение: Реализация коллекции с индексами (первичными и вторичными).
|
||
// Индексы хранятся отдельно от документов, обеспечивают wait-free доступ.
|
||
//
|
||
// ИСПРАВЛЕНО: корректная работа уникальных индексов, удаление из индексов
|
||
// при обновлении.
|
||
// Lock-free: ACL и Constraints переведены на атомарные операции.
|
||
// MVCC: удалён (2026) — заменён на WAL-based time-travel.
|
||
//
|
||
// ИЗМЕНЕНО (2026): Инвертированный индекс Index.data переведён с sync.Map
|
||
// на lock-free skip list (см. internal/storage/skiplist.go).
|
||
//
|
||
// ИСПРАВЛЕНО (2026): Устранены race condition в CollectionACL и Constraints.
|
||
// Добавлены sync.RWMutex для защиты операций чтения/записи map.
|
||
// Все методы load*/store* теперь используют блокировку.
|
||
//
|
||
// ИЗМЕНЕНО (2026): Удалены все вызовы MVCCManager.
|
||
// Time-travel реализован через WAL (см. transactions.go).
|
||
//
|
||
// ИЗМЕНЕНО (2026-10): Удалены вызовы LogAOFInsert/Update/Delete/Restore.
|
||
// AOF удалён, единственный источник истины — WAL.
|
||
//
|
||
// ИСПРАВЛЕНО (2026-10):
|
||
// 1. CountAll/CountDeleted/count-семантика приведены в порядок.
|
||
// В режиме SoftDelete c.docCount больше не уменьшается на soft-delete
|
||
// (иначе CountAll занижался). c.docCount теперь = общее число
|
||
// документов в c.docs (включая soft-deleted). Для активных — Count().
|
||
// 2. Insert теперь атомарен относительно уникальных индексов: проверка
|
||
// checkUniqueConstraints и LoadOrStore выполняются под c.indexMu.
|
||
// Раньше два параллельных Insert могли вставить дубликат по
|
||
// уникальному полю.
|
||
// 3. Drop больше не пересоздаёт sync.Map — вместо этого очищает
|
||
// содержимое через Range + Delete. Замена sync.Map — это запись
|
||
// указателя, а читатели (Find/Insert) обращаются к нему без
|
||
// блокировки, что давало data race.
|
||
// 4. AddRegexConstraint теперь действительно использует regexp.MatchString,
|
||
// а не strings.Contains (раньше имя не соответствовало поведению).
|
||
// 5. AddRegexConstraint и AddEnumConstraint документируют, что regex
|
||
// компилируется при каждом ValidateDocument — кэш не ведётся,
|
||
// потому что constraints меняются редко.
|
||
|
||
package storage
|
||
|
||
import (
|
||
"fmt"
|
||
"regexp"
|
||
"strings"
|
||
"sync"
|
||
"sync/atomic"
|
||
"time"
|
||
|
||
"futriis/internal/serializer"
|
||
)
|
||
|
||
// =============================================================================
|
||
// КОНСТАНТЫ (определены в trigger.go)
|
||
// =============================================================================
|
||
|
||
// MaxVersionsPerDoc, VersionRetentionDays, VisibilityMapSize
|
||
// определены в trigger.go.
|
||
|
||
// =============================================================================
|
||
// Collection — ОСНОВНАЯ СТРУКТУРА
|
||
// =============================================================================
|
||
|
||
// Collection представляет коллекцию документов (аналог таблицы).
|
||
type Collection struct {
|
||
dbName string // имя базы данных
|
||
name string // имя коллекции
|
||
docs sync.Map // map[string]*Document — wait-free хранилище
|
||
indexes sync.Map // map[string]*Index — индексы (lock-free)
|
||
metadata *CollectionMetadata // метаданные коллекции
|
||
docCount atomic.Int64 // общее число документов в c.docs (вкл. soft-deleted)
|
||
sizeBytes atomic.Int64 // размер коллекции в байтах
|
||
mu sync.RWMutex // для операций, изменяющих структуру
|
||
constraints *Constraints // ограничения коллекции (lock-free)
|
||
acl *CollectionACL // ACL для коллекции (lock-free)
|
||
triggers sync.Map // map[string]*Trigger — триггеры
|
||
|
||
// indexMu защищает согласованность индексов при Insert/Update/Delete.
|
||
// Используется для атомарной проверки уникальных ограничений и
|
||
// последующей вставки в c.docs.
|
||
indexMu sync.Mutex
|
||
}
|
||
|
||
// CollectionMetadata содержит метаданные коллекции.
|
||
type CollectionMetadata struct {
|
||
Name string `msgpack:"name"`
|
||
CreatedAt int64 `msgpack:"created_at"`
|
||
UpdatedAt int64 `msgpack:"updated_at"`
|
||
DeletedAt int64 `msgpack:"deleted_at"`
|
||
DocumentCount int64 `msgpack:"document_count"`
|
||
SizeBytes int64 `msgpack:"size_bytes"`
|
||
IndexCount int `msgpack:"index_count"`
|
||
Settings *CollectionSettings `msgpack:"settings"`
|
||
}
|
||
|
||
// CollectionSettings содержит настройки коллекции.
|
||
type CollectionSettings struct {
|
||
MaxDocuments int `msgpack:"max_documents"`
|
||
ValidateSchema bool `msgpack:"validate_schema"`
|
||
AutoIndexID bool `msgpack:"auto_index_id"`
|
||
TTLSeconds int `msgpack:"ttl_seconds"`
|
||
SoftDelete bool `msgpack:"soft_delete"`
|
||
}
|
||
|
||
// Index представляет индекс для ускорения поиска.
|
||
type Index struct {
|
||
Name string `msgpack:"name"`
|
||
Fields []string `msgpack:"fields"`
|
||
Unique bool `msgpack:"unique"`
|
||
CreatedAt int64 `msgpack:"created_at"`
|
||
UpdatedAt int64 `msgpack:"updated_at"`
|
||
data *SkipList // значение индекса -> ID документа
|
||
}
|
||
|
||
// Constraints представляет ограничения на коллекцию (lock-free версия).
|
||
type Constraints struct {
|
||
mu sync.RWMutex
|
||
|
||
requiredFieldsPtr atomic.Value // map[string]bool
|
||
uniqueFieldsPtr atomic.Value // map[string]bool
|
||
minValuesPtr atomic.Value // map[string]float64
|
||
maxValuesPtr atomic.Value // map[string]float64
|
||
patternFieldsPtr atomic.Value // map[string]string
|
||
enumFieldsPtr atomic.Value // map[string][]interface{}
|
||
|
||
createdAt int64
|
||
updatedAt atomic.Int64
|
||
constraintHistory atomic.Value // []ConstraintChange
|
||
}
|
||
|
||
// ConstraintChange представляет изменение ограничения.
|
||
type ConstraintChange struct {
|
||
Timestamp int64 `msgpack:"timestamp"`
|
||
TimestampStr string `msgpack:"timestamp_str"`
|
||
Action string `msgpack:"action"`
|
||
ConstraintType string `msgpack:"constraint_type"`
|
||
Field string `msgpack:"field"`
|
||
OldValue interface{} `msgpack:"old_value,omitempty"`
|
||
NewValue interface{} `msgpack:"new_value,omitempty"`
|
||
}
|
||
|
||
// CollectionACL представляет список контроля доступа для коллекции (lock-free).
|
||
type CollectionACL struct {
|
||
mu sync.RWMutex
|
||
|
||
readRolesPtr atomic.Value // map[string]bool
|
||
writeRolesPtr atomic.Value // map[string]bool
|
||
deleteRolesPtr atomic.Value // map[string]bool
|
||
adminRolesPtr atomic.Value // map[string]bool
|
||
|
||
createdAt int64
|
||
updatedAt atomic.Int64
|
||
aclHistory atomic.Value // []ACLChange
|
||
}
|
||
|
||
// ACLChange представляет изменение ACL.
|
||
type ACLChange struct {
|
||
Timestamp int64 `msgpack:"timestamp"`
|
||
TimestampStr string `msgpack:"timestamp_str"`
|
||
Action string `msgpack:"action"`
|
||
Role string `msgpack:"role"`
|
||
Permission string `msgpack:"permission"`
|
||
Granted bool `msgpack:"granted"`
|
||
}
|
||
|
||
// =============================================================================
|
||
// КОНСТРУКТОРЫ
|
||
// =============================================================================
|
||
|
||
// NewConstraints создаёт новый экземпляр Constraints с lock-free реализацией.
|
||
func NewConstraints() *Constraints {
|
||
c := &Constraints{
|
||
createdAt: time.Now().UnixMilli(),
|
||
}
|
||
c.requiredFieldsPtr.Store(make(map[string]bool))
|
||
c.uniqueFieldsPtr.Store(make(map[string]bool))
|
||
c.minValuesPtr.Store(make(map[string]float64))
|
||
c.maxValuesPtr.Store(make(map[string]float64))
|
||
c.patternFieldsPtr.Store(make(map[string]string))
|
||
c.enumFieldsPtr.Store(make(map[string][]interface{}))
|
||
c.constraintHistory.Store(make([]ConstraintChange, 0))
|
||
c.updatedAt.Store(c.createdAt)
|
||
return c
|
||
}
|
||
|
||
// NewCollectionACL создаёт новый экземпляр CollectionACL.
|
||
func NewCollectionACL() *CollectionACL {
|
||
acl := &CollectionACL{
|
||
createdAt: time.Now().UnixMilli(),
|
||
}
|
||
acl.readRolesPtr.Store(make(map[string]bool))
|
||
acl.writeRolesPtr.Store(make(map[string]bool))
|
||
acl.deleteRolesPtr.Store(make(map[string]bool))
|
||
acl.adminRolesPtr.Store(make(map[string]bool))
|
||
acl.aclHistory.Store(make([]ACLChange, 0))
|
||
acl.updatedAt.Store(acl.createdAt)
|
||
return acl
|
||
}
|
||
|
||
// NewCollection создаёт новую коллекцию.
|
||
func NewCollection(dbName, name string, settings *CollectionSettings) *Collection {
|
||
if settings == nil {
|
||
settings = &CollectionSettings{
|
||
MaxDocuments: 0,
|
||
ValidateSchema: false,
|
||
AutoIndexID: true,
|
||
TTLSeconds: 0,
|
||
SoftDelete: false,
|
||
}
|
||
}
|
||
|
||
now := time.Now().UnixMilli()
|
||
coll := &Collection{
|
||
dbName: dbName,
|
||
name: name,
|
||
metadata: &CollectionMetadata{
|
||
Name: name,
|
||
CreatedAt: now,
|
||
UpdatedAt: now,
|
||
DeletedAt: 0,
|
||
DocumentCount: 0,
|
||
SizeBytes: 0,
|
||
IndexCount: 0,
|
||
Settings: settings,
|
||
},
|
||
constraints: NewConstraints(),
|
||
acl: NewCollectionACL(),
|
||
}
|
||
|
||
if settings.AutoIndexID {
|
||
coll.CreateIndex("_id_", []string{"_id"}, true)
|
||
}
|
||
|
||
if settings.TTLSeconds > 0 {
|
||
go coll.ttlCleanupLoop()
|
||
}
|
||
|
||
AuditCollectionOperation("CREATE", dbName, name, settings)
|
||
|
||
return coll
|
||
}
|
||
|
||
// =============================================================================
|
||
// МЕТОДЫ ДЛЯ РАБОТЫ С ТРИГГЕРАМИ
|
||
// =============================================================================
|
||
|
||
// AddTrigger добавляет триггер в коллекцию.
|
||
func (c *Collection) AddTrigger(trigger *Trigger) error {
|
||
if trigger.Name == "" {
|
||
return fmt.Errorf("trigger name cannot be empty")
|
||
}
|
||
if _, exists := c.triggers.Load(trigger.Name); exists {
|
||
return fmt.Errorf("trigger '%s' already exists", trigger.Name)
|
||
}
|
||
trigger.CreatedAt = time.Now().UnixMilli()
|
||
trigger.UpdatedAt = trigger.CreatedAt
|
||
c.triggers.Store(trigger.Name, trigger)
|
||
|
||
c.mu.Lock()
|
||
c.metadata.UpdatedAt = time.Now().UnixMilli()
|
||
c.mu.Unlock()
|
||
|
||
AuditDocumentOperation("CREATE_TRIGGER", c.dbName, c.name, trigger.Name, map[string]interface{}{
|
||
"event": trigger.Event,
|
||
"action": trigger.Action,
|
||
})
|
||
return nil
|
||
}
|
||
|
||
// DropTrigger удаляет триггер из коллекции.
|
||
func (c *Collection) DropTrigger(name string) error {
|
||
if _, exists := c.triggers.LoadAndDelete(name); !exists {
|
||
return fmt.Errorf("trigger '%s' not found", name)
|
||
}
|
||
c.mu.Lock()
|
||
c.metadata.UpdatedAt = time.Now().UnixMilli()
|
||
c.mu.Unlock()
|
||
AuditDocumentOperation("DROP_TRIGGER", c.dbName, c.name, name, nil)
|
||
return nil
|
||
}
|
||
|
||
// ListTriggers возвращает список всех триггеров в коллекции.
|
||
func (c *Collection) ListTriggers() []*Trigger {
|
||
triggers := make([]*Trigger, 0)
|
||
c.triggers.Range(func(key, value interface{}) bool {
|
||
triggers = append(triggers, value.(*Trigger))
|
||
return true
|
||
})
|
||
return triggers
|
||
}
|
||
|
||
// GetTrigger возвращает триггер по имени.
|
||
func (c *Collection) GetTrigger(name string) (*Trigger, bool) {
|
||
if val, ok := c.triggers.Load(name); ok {
|
||
return val.(*Trigger), true
|
||
}
|
||
return nil, false
|
||
}
|
||
|
||
// EnableTrigger включает триггер.
|
||
func (c *Collection) EnableTrigger(name string) error {
|
||
val, ok := c.triggers.Load(name)
|
||
if !ok {
|
||
return fmt.Errorf("trigger '%s' not found", name)
|
||
}
|
||
trigger := val.(*Trigger)
|
||
trigger.mu.Lock()
|
||
trigger.Enabled = true
|
||
trigger.UpdatedAt = time.Now().UnixMilli()
|
||
trigger.mu.Unlock()
|
||
c.triggers.Store(name, trigger)
|
||
|
||
c.mu.Lock()
|
||
c.metadata.UpdatedAt = time.Now().UnixMilli()
|
||
c.mu.Unlock()
|
||
|
||
AuditDocumentOperation("ENABLE_TRIGGER", c.dbName, c.name, name, nil)
|
||
return nil
|
||
}
|
||
|
||
// DisableTrigger отключает триггер.
|
||
func (c *Collection) DisableTrigger(name string) error {
|
||
val, ok := c.triggers.Load(name)
|
||
if !ok {
|
||
return fmt.Errorf("trigger '%s' not found", name)
|
||
}
|
||
trigger := val.(*Trigger)
|
||
trigger.mu.Lock()
|
||
trigger.Enabled = false
|
||
trigger.UpdatedAt = time.Now().UnixMilli()
|
||
trigger.mu.Unlock()
|
||
c.triggers.Store(name, trigger)
|
||
|
||
c.mu.Lock()
|
||
c.metadata.UpdatedAt = time.Now().UnixMilli()
|
||
c.mu.Unlock()
|
||
|
||
AuditDocumentOperation("DISABLE_TRIGGER", c.dbName, c.name, name, nil)
|
||
return nil
|
||
}
|
||
|
||
// executeTriggers выполняет триггеры для заданного события.
|
||
func (c *Collection) executeTriggers(event string, docID string, data map[string]interface{}) error {
|
||
triggers := c.ListTriggers()
|
||
for _, trigger := range triggers {
|
||
if !trigger.Enabled || trigger.Event != event {
|
||
continue
|
||
}
|
||
LogTriggerExecution(trigger.Name, event, c.name, docID, trigger.Action, true, nil)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// =============================================================================
|
||
// БАЗОВЫЕ МЕТОДЫ КОЛЛЕКЦИИ
|
||
// =============================================================================
|
||
|
||
// Name возвращает имя коллекции.
|
||
func (c *Collection) Name() string { return c.name }
|
||
|
||
// DBName возвращает имя базы данных.
|
||
func (c *Collection) DBName() string { return c.dbName }
|
||
|
||
// Insert вставляет документ в коллекцию.
|
||
//
|
||
// ИСПРАВЛЕНО: проверка уникальных индексов и LoadOrStore выполняются
|
||
// под c.indexMu — так два параллельных Insert не смогут вставить
|
||
// дубликат по уникальному полю.
|
||
func (c *Collection) Insert(doc *Document) error {
|
||
if err := c.constraints.ValidateDocument(doc); err != nil {
|
||
return fmt.Errorf("constraint violation: %v", err)
|
||
}
|
||
|
||
if c.metadata.Settings.MaxDocuments > 0 {
|
||
if c.CountAll() >= int64(c.metadata.Settings.MaxDocuments) {
|
||
return fmt.Errorf("collection is full: max documents %d reached",
|
||
c.metadata.Settings.MaxDocuments)
|
||
}
|
||
}
|
||
|
||
if c.metadata.Settings.ValidateSchema {
|
||
if err := c.validateDocument(doc); err != nil {
|
||
return fmt.Errorf("document validation failed: %v", err)
|
||
}
|
||
}
|
||
|
||
c.indexMu.Lock()
|
||
defer c.indexMu.Unlock()
|
||
|
||
if err := c.checkUniqueConstraints(doc); err != nil {
|
||
return err
|
||
}
|
||
|
||
doc.CreatedAt = time.Now().UnixMilli()
|
||
doc.UpdatedAt = doc.CreatedAt
|
||
doc.DeletedAt = 0
|
||
|
||
data, err := serializer.Marshal(doc)
|
||
if err != nil {
|
||
return fmt.Errorf("failed to serialize document: %v", err)
|
||
}
|
||
|
||
if _, loaded := c.docs.LoadOrStore(doc.ID, doc); loaded {
|
||
return fmt.Errorf("document with id %s already exists", doc.ID)
|
||
}
|
||
|
||
c.addToIndexes(doc)
|
||
|
||
c.docCount.Add(1)
|
||
c.sizeBytes.Add(int64(len(data)))
|
||
|
||
c.mu.Lock()
|
||
c.metadata.DocumentCount = c.docCount.Load()
|
||
c.metadata.SizeBytes = c.sizeBytes.Load()
|
||
c.metadata.UpdatedAt = time.Now().UnixMilli()
|
||
c.mu.Unlock()
|
||
|
||
AuditDocumentOperation("INSERT", c.dbName, c.name, doc.ID, doc.GetFields())
|
||
c.executeTriggers("AFTER_INSERT", doc.ID, doc.GetFields())
|
||
|
||
return nil
|
||
}
|
||
|
||
// InsertFromMap создаёт и вставляет документ из map.
|
||
func (c *Collection) InsertFromMap(fields map[string]interface{}) error {
|
||
doc := NewDocument()
|
||
for k, v := range fields {
|
||
doc.SetField(k, v)
|
||
}
|
||
return c.Insert(doc)
|
||
}
|
||
|
||
// Find находит документ по ID.
|
||
func (c *Collection) Find(id string) (*Document, error) {
|
||
if val, ok := c.docs.Load(id); ok {
|
||
doc := val.(*Document)
|
||
if doc.IsDeleted() && c.metadata.Settings.SoftDelete {
|
||
return nil, fmt.Errorf("document deleted at %s", doc.GetDeletedAtStr())
|
||
}
|
||
if c.metadata.Settings.TTLSeconds > 0 {
|
||
if time.Now().UnixMilli()-doc.CreatedAt > int64(c.metadata.Settings.TTLSeconds*1000) {
|
||
if c.metadata.Settings.SoftDelete {
|
||
doc.SoftDelete()
|
||
c.docs.Store(id, doc)
|
||
} else {
|
||
c.Delete(id)
|
||
}
|
||
return nil, fmt.Errorf("key not found")
|
||
}
|
||
}
|
||
return doc, nil
|
||
}
|
||
return nil, fmt.Errorf("key not found")
|
||
}
|
||
|
||
// FindIncludingDeleted находит документ даже если он мягко удалён.
|
||
func (c *Collection) FindIncludingDeleted(id string) (*Document, error) {
|
||
if val, ok := c.docs.Load(id); ok {
|
||
return val.(*Document), nil
|
||
}
|
||
return nil, fmt.Errorf("key not found")
|
||
}
|
||
|
||
// compareValues сравнивает два значения с учётом типа.
|
||
func compareValues(a, b interface{}) bool {
|
||
if a == nil && b == nil {
|
||
return true
|
||
}
|
||
if a == nil || b == nil {
|
||
return false
|
||
}
|
||
if a == b {
|
||
return true
|
||
}
|
||
return fmt.Sprintf("%v", a) == fmt.Sprintf("%v", b)
|
||
}
|
||
|
||
// FindByIndex находит документы по значению индексированного поля.
|
||
func (c *Collection) FindByIndex(indexName string, value interface{}) ([]*Document, error) {
|
||
idxVal, ok := c.indexes.Load(indexName)
|
||
if !ok {
|
||
return nil, fmt.Errorf("index not found: %s", indexName)
|
||
}
|
||
index := idxVal.(*Index)
|
||
docs := make([]*Document, 0)
|
||
if index.data == nil {
|
||
return docs, nil
|
||
}
|
||
docIDs := index.data.SearchAll(value)
|
||
for _, docID := range docIDs {
|
||
if doc, err := c.Find(docID); err == nil {
|
||
docs = append(docs, doc)
|
||
}
|
||
}
|
||
return docs, nil
|
||
}
|
||
|
||
// FindByIndexPrefix находит документы по префиксу индекса.
|
||
func (c *Collection) FindByIndexPrefix(indexName string, prefix string) ([]*Document, error) {
|
||
idxVal, ok := c.indexes.Load(indexName)
|
||
if !ok {
|
||
return nil, fmt.Errorf("index not found: %s", indexName)
|
||
}
|
||
index := idxVal.(*Index)
|
||
docs := make([]*Document, 0)
|
||
if index.data == nil {
|
||
return docs, nil
|
||
}
|
||
index.data.RangeWithKeyPrefix(prefix, func(key interface{}, docID string) bool {
|
||
if doc, err := c.Find(docID); err == nil {
|
||
docs = append(docs, doc)
|
||
}
|
||
return true
|
||
})
|
||
return docs, nil
|
||
}
|
||
|
||
// Update обновляет документ по ID.
|
||
func (c *Collection) Update(id string, updates map[string]interface{}) error {
|
||
val, ok := c.docs.Load(id)
|
||
if !ok {
|
||
return fmt.Errorf("key not found")
|
||
}
|
||
oldDoc := val.(*Document)
|
||
if oldDoc.IsDeleted() && c.metadata.Settings.SoftDelete {
|
||
return fmt.Errorf("cannot update deleted document")
|
||
}
|
||
|
||
newDoc := oldDoc.Clone()
|
||
if err := newDoc.Update(updates); err != nil {
|
||
return err
|
||
}
|
||
newDoc.UpdatedAt = time.Now().UnixMilli()
|
||
|
||
if err := c.constraints.ValidateDocument(newDoc); err != nil {
|
||
return fmt.Errorf("constraint violation: %v", err)
|
||
}
|
||
|
||
c.indexMu.Lock()
|
||
defer c.indexMu.Unlock()
|
||
|
||
if err := c.checkUniqueConstraintsUpdate(oldDoc, newDoc); err != nil {
|
||
return err
|
||
}
|
||
|
||
c.executeTriggers("BEFORE_UPDATE", id, newDoc.GetFields())
|
||
|
||
c.removeFromIndexes(oldDoc)
|
||
c.addToIndexes(newDoc)
|
||
|
||
c.docs.Store(id, newDoc)
|
||
|
||
c.mu.Lock()
|
||
c.metadata.UpdatedAt = time.Now().UnixMilli()
|
||
c.mu.Unlock()
|
||
|
||
AuditDocumentOperation("UPDATE", c.dbName, c.name, id, updates)
|
||
c.executeTriggers("AFTER_UPDATE", id, newDoc.GetFields())
|
||
return nil
|
||
}
|
||
|
||
// Delete удаляет документ по ID.
|
||
//
|
||
// ИСПРАВЛЕНО: при soft-delete c.docCount больше НЕ уменьшается —
|
||
// документ остаётся в c.docs, и CountAll() продолжает его учитывать.
|
||
// Для подсчёта активных используется Count() (перебирает c.docs и
|
||
// пропускает soft-deleted).
|
||
func (c *Collection) Delete(id string) error {
|
||
val, ok := c.docs.Load(id)
|
||
if !ok {
|
||
return fmt.Errorf("key not found")
|
||
}
|
||
doc := val.(*Document)
|
||
|
||
c.executeTriggers("BEFORE_DELETE", id, doc.GetFields())
|
||
|
||
c.indexMu.Lock()
|
||
defer c.indexMu.Unlock()
|
||
|
||
if c.metadata.Settings.SoftDelete {
|
||
doc.SoftDelete()
|
||
c.docs.Store(id, doc)
|
||
c.removeFromIndexes(doc)
|
||
|
||
AuditDocumentOperation("SOFT_DELETE", c.dbName, c.name, id, map[string]interface{}{
|
||
"deleted_at": doc.DeletedAt,
|
||
})
|
||
} else {
|
||
c.removeFromIndexes(doc)
|
||
c.docs.Delete(id)
|
||
// Физическое удаление уменьшает общий счётчик.
|
||
c.docCount.Add(-1)
|
||
|
||
AuditDocumentOperation("DELETE", c.dbName, c.name, id, nil)
|
||
}
|
||
|
||
c.mu.Lock()
|
||
c.metadata.DocumentCount = c.docCount.Load()
|
||
c.metadata.UpdatedAt = time.Now().UnixMilli()
|
||
c.mu.Unlock()
|
||
|
||
c.executeTriggers("AFTER_DELETE", id, nil)
|
||
return nil
|
||
}
|
||
|
||
// PermanentDelete выполняет физическое удаление мягко удалённого документа.
|
||
func (c *Collection) PermanentDelete(id string) error {
|
||
val, ok := c.docs.Load(id)
|
||
if !ok {
|
||
return fmt.Errorf("key not found")
|
||
}
|
||
doc := val.(*Document)
|
||
if !doc.IsDeleted() {
|
||
return fmt.Errorf("document is not soft deleted, use Delete() instead")
|
||
}
|
||
|
||
c.indexMu.Lock()
|
||
c.removeFromIndexes(doc)
|
||
c.docs.Delete(id)
|
||
c.indexMu.Unlock()
|
||
|
||
c.docCount.Add(-1)
|
||
c.mu.Lock()
|
||
c.metadata.DocumentCount = c.docCount.Load()
|
||
c.metadata.UpdatedAt = time.Now().UnixMilli()
|
||
c.mu.Unlock()
|
||
|
||
AuditDocumentOperation("PERMANENT_DELETE", c.dbName, c.name, id, nil)
|
||
return nil
|
||
}
|
||
|
||
// RestoreDeleted восстанавливает мягко удалённый документ.
|
||
func (c *Collection) RestoreDeleted(id string) error {
|
||
val, ok := c.docs.Load(id)
|
||
if !ok {
|
||
return fmt.Errorf("key not found")
|
||
}
|
||
doc := val.(*Document)
|
||
if !doc.IsDeleted() {
|
||
return fmt.Errorf("document is not deleted")
|
||
}
|
||
|
||
c.indexMu.Lock()
|
||
doc.Restore()
|
||
c.addToIndexes(doc)
|
||
c.docs.Store(id, doc)
|
||
c.indexMu.Unlock()
|
||
|
||
c.mu.Lock()
|
||
c.metadata.UpdatedAt = time.Now().UnixMilli()
|
||
c.mu.Unlock()
|
||
|
||
AuditDocumentOperation("RESTORE", c.dbName, c.name, id, nil)
|
||
return nil
|
||
}
|
||
|
||
// removeFromIndexes удаляет документ из всех индексов.
|
||
func (c *Collection) removeFromIndexes(doc *Document) {
|
||
c.indexes.Range(func(key, value interface{}) bool {
|
||
index := value.(*Index)
|
||
if index.data == nil {
|
||
return true
|
||
}
|
||
indexValue := c.extractIndexValue(doc, index.Fields)
|
||
index.data.Delete(indexValue)
|
||
return true
|
||
})
|
||
}
|
||
|
||
// addToIndexes добавляет документ во все индексы.
|
||
func (c *Collection) addToIndexes(doc *Document) {
|
||
c.indexes.Range(func(key, value interface{}) bool {
|
||
index := value.(*Index)
|
||
if index.data == nil {
|
||
return true
|
||
}
|
||
indexValue := c.extractIndexValue(doc, index.Fields)
|
||
index.data.Insert(indexValue, doc.ID)
|
||
return true
|
||
})
|
||
}
|
||
|
||
// CreateIndex создаёт новый индекс на коллекции.
|
||
func (c *Collection) CreateIndex(name string, fields []string, unique bool) error {
|
||
c.mu.Lock()
|
||
defer c.mu.Unlock()
|
||
|
||
if _, exists := c.indexes.Load(name); exists {
|
||
return fmt.Errorf("index %s already exists", name)
|
||
}
|
||
|
||
now := time.Now().UnixMilli()
|
||
index := &Index{
|
||
Name: name,
|
||
Fields: fields,
|
||
Unique: unique,
|
||
CreatedAt: now,
|
||
UpdatedAt: now,
|
||
data: NewSkipList(),
|
||
}
|
||
|
||
var buildErr error
|
||
c.docs.Range(func(key, value interface{}) bool {
|
||
doc := value.(*Document)
|
||
if doc.IsDeleted() && c.metadata.Settings.SoftDelete {
|
||
return true
|
||
}
|
||
indexValue := c.extractIndexValue(doc, fields)
|
||
if unique {
|
||
if _, exists := index.data.Search(indexValue); exists {
|
||
buildErr = fmt.Errorf("duplicate key for index %s: %v", name, indexValue)
|
||
return false
|
||
}
|
||
}
|
||
index.data.Insert(indexValue, doc.ID)
|
||
return true
|
||
})
|
||
|
||
if buildErr != nil {
|
||
return buildErr
|
||
}
|
||
|
||
c.indexes.Store(name, index)
|
||
c.metadata.IndexCount++
|
||
|
||
AuditIndexOperation("CREATE_INDEX", c.dbName, c.name, name, fields, unique)
|
||
return nil
|
||
}
|
||
|
||
// DropIndex удаляет индекс.
|
||
func (c *Collection) DropIndex(name string) error {
|
||
if _, exists := c.indexes.LoadAndDelete(name); !exists {
|
||
return fmt.Errorf("index not found: %s", name)
|
||
}
|
||
c.metadata.IndexCount--
|
||
AuditIndexOperation("DROP_INDEX", c.dbName, c.name, name, nil, false)
|
||
return nil
|
||
}
|
||
|
||
// GetIndexes возвращает список всех индексов.
|
||
func (c *Collection) GetIndexes() []string {
|
||
names := make([]string, 0)
|
||
c.indexes.Range(func(key, value interface{}) bool {
|
||
names = append(names, key.(string))
|
||
return true
|
||
})
|
||
return names
|
||
}
|
||
|
||
// GetIndexesInfo возвращает подробную информацию об индексах.
|
||
func (c *Collection) GetIndexesInfo() []map[string]interface{} {
|
||
indexes := make([]map[string]interface{}, 0)
|
||
c.indexes.Range(func(key, value interface{}) bool {
|
||
idx := value.(*Index)
|
||
indexes = append(indexes, map[string]interface{}{
|
||
"name": idx.Name,
|
||
"fields": idx.Fields,
|
||
"unique": idx.Unique,
|
||
"created_at": idx.CreatedAt,
|
||
"updated_at": idx.UpdatedAt,
|
||
})
|
||
return true
|
||
})
|
||
return indexes
|
||
}
|
||
|
||
// extractIndexValue извлекает значение из документа для индексации.
|
||
func (c *Collection) extractIndexValue(doc *Document, fields []string) interface{} {
|
||
if len(fields) == 1 {
|
||
val, _ := doc.GetField(fields[0])
|
||
return val
|
||
}
|
||
parts := make([]string, 0, len(fields))
|
||
for _, field := range fields {
|
||
if val, err := doc.GetField(field); err == nil {
|
||
parts = append(parts, fmt.Sprintf("%v", val))
|
||
} else {
|
||
parts = append(parts, "NULL")
|
||
}
|
||
}
|
||
return strings.Join(parts, "|")
|
||
}
|
||
|
||
// checkUniqueConstraints проверяет уникальные индексы перед вставкой.
|
||
// ВАЖНО: вызывается под c.indexMu.
|
||
func (c *Collection) checkUniqueConstraints(doc *Document) error {
|
||
var errs []string
|
||
c.indexes.Range(func(key, value interface{}) bool {
|
||
index := value.(*Index)
|
||
if index.Unique && index.data != nil {
|
||
indexValue := c.extractIndexValue(doc, index.Fields)
|
||
if _, exists := index.data.Search(indexValue); exists {
|
||
errs = append(errs, fmt.Sprintf("duplicate key for index %s: %v", index.Name, indexValue))
|
||
}
|
||
}
|
||
return true
|
||
})
|
||
if len(errs) > 0 {
|
||
return fmt.Errorf("%s", strings.Join(errs, "; "))
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// checkUniqueConstraintsUpdate проверяет уникальность при обновлении.
|
||
// ВАЖНО: вызывается под c.indexMu.
|
||
func (c *Collection) checkUniqueConstraintsUpdate(oldDoc, newDoc *Document) error {
|
||
var errs []string
|
||
c.indexes.Range(func(key, value interface{}) bool {
|
||
index := value.(*Index)
|
||
if index.Unique && index.data != nil {
|
||
oldValue := c.extractIndexValue(oldDoc, index.Fields)
|
||
newValue := c.extractIndexValue(newDoc, index.Fields)
|
||
if fmt.Sprintf("%v", oldValue) != fmt.Sprintf("%v", newValue) {
|
||
if _, exists := index.data.Search(newValue); exists {
|
||
errs = append(errs, fmt.Sprintf("duplicate key for index %s: %v", index.Name, newValue))
|
||
}
|
||
}
|
||
}
|
||
return true
|
||
})
|
||
if len(errs) > 0 {
|
||
return fmt.Errorf("%s", strings.Join(errs, "; "))
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// validateDocument валидирует документ согласно схеме коллекции.
|
||
func (c *Collection) validateDocument(doc *Document) error {
|
||
if doc.ID == "" {
|
||
return fmt.Errorf("document must have _id field")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// ttlCleanupLoop периодически удаляет просроченные документы.
|
||
func (c *Collection) ttlCleanupLoop() {
|
||
if c.metadata.Settings.TTLSeconds <= 0 {
|
||
return
|
||
}
|
||
interval := time.Duration(c.metadata.Settings.TTLSeconds/2) * time.Second
|
||
if interval <= 0 {
|
||
interval = time.Second
|
||
}
|
||
ticker := time.NewTicker(interval)
|
||
defer ticker.Stop()
|
||
|
||
for range ticker.C {
|
||
now := time.Now().UnixMilli()
|
||
toDelete := make([]string, 0)
|
||
c.docs.Range(func(key, value interface{}) bool {
|
||
doc := value.(*Document)
|
||
if !doc.IsDeleted() && now-doc.CreatedAt > int64(c.metadata.Settings.TTLSeconds*1000) {
|
||
toDelete = append(toDelete, doc.ID)
|
||
}
|
||
return true
|
||
})
|
||
for _, id := range toDelete {
|
||
c.Delete(id)
|
||
}
|
||
}
|
||
}
|
||
|
||
// =============================================================================
|
||
// ПОДСЧЁТ ДОКУМЕНТОВ
|
||
// =============================================================================
|
||
|
||
// Count возвращает количество активных документов в коллекции.
|
||
//
|
||
// В режиме SoftDelete перебирает c.docs и пропускает soft-deleted.
|
||
// В обычном режиме равно CountAll.
|
||
func (c *Collection) Count() int64 {
|
||
if c.metadata.Settings.SoftDelete {
|
||
count := int64(0)
|
||
c.docs.Range(func(key, value interface{}) bool {
|
||
doc := value.(*Document)
|
||
if !doc.IsDeleted() {
|
||
count++
|
||
}
|
||
return true
|
||
})
|
||
return count
|
||
}
|
||
return c.docCount.Load()
|
||
}
|
||
|
||
// CountAll возвращает общее количество документов в c.docs
|
||
// (включая soft-deleted в режиме SoftDelete).
|
||
//
|
||
// ИСПРАВЛЕНО: c.docCount теперь всегда отражает число элементов
|
||
// в c.docs, включая soft-deleted. Раньше в режиме SoftDelete
|
||
// c.docCount уменьшался при каждом Delete, из-за чего CountAll
|
||
// занижался.
|
||
func (c *Collection) CountAll() int64 {
|
||
return c.docCount.Load()
|
||
}
|
||
|
||
// CountDeleted возвращает количество soft-deleted документов.
|
||
func (c *Collection) CountDeleted() int64 {
|
||
if !c.metadata.Settings.SoftDelete {
|
||
return 0
|
||
}
|
||
count := int64(0)
|
||
c.docs.Range(func(key, value interface{}) bool {
|
||
doc := value.(*Document)
|
||
if doc.IsDeleted() {
|
||
count++
|
||
}
|
||
return true
|
||
})
|
||
return count
|
||
}
|
||
|
||
// Size возвращает размер коллекции в байтах.
|
||
func (c *Collection) Size() int64 { return c.sizeBytes.Load() }
|
||
|
||
// GetAllDocuments возвращает все активные документы коллекции.
|
||
func (c *Collection) GetAllDocuments() []*Document {
|
||
docs := make([]*Document, 0, c.docCount.Load())
|
||
c.docs.Range(func(key, value interface{}) bool {
|
||
doc := value.(*Document)
|
||
if !c.metadata.Settings.SoftDelete || !doc.IsDeleted() {
|
||
docs = append(docs, doc)
|
||
}
|
||
return true
|
||
})
|
||
return docs
|
||
}
|
||
|
||
// GetAllDocumentsIncludingDeleted возвращает все документы (включая soft-deleted).
|
||
func (c *Collection) GetAllDocumentsIncludingDeleted() []*Document {
|
||
docs := make([]*Document, 0, c.docCount.Load())
|
||
c.docs.Range(func(key, value interface{}) bool {
|
||
docs = append(docs, value.(*Document))
|
||
return true
|
||
})
|
||
return docs
|
||
}
|
||
|
||
// FindByFilter находит документы по произвольному фильтру.
|
||
func (c *Collection) FindByFilter(filter func(*Document) bool) []*Document {
|
||
results := make([]*Document, 0)
|
||
c.docs.Range(func(key, value interface{}) bool {
|
||
doc := value.(*Document)
|
||
if (!c.metadata.Settings.SoftDelete || !doc.IsDeleted()) && filter(doc) {
|
||
results = append(results, doc)
|
||
}
|
||
return true
|
||
})
|
||
return results
|
||
}
|
||
|
||
// GetMetadata возвращает метаданные коллекции.
|
||
func (c *Collection) GetMetadata() *CollectionMetadata {
|
||
c.mu.RLock()
|
||
defer c.mu.RUnlock()
|
||
return c.metadata
|
||
}
|
||
|
||
// GetTimestamps возвращает временные метки коллекции.
|
||
func (c *Collection) GetTimestamps() map[string]int64 {
|
||
c.mu.RLock()
|
||
defer c.mu.RUnlock()
|
||
return map[string]int64{
|
||
"created_at": c.metadata.CreatedAt,
|
||
"updated_at": c.metadata.UpdatedAt,
|
||
"deleted_at": c.metadata.DeletedAt,
|
||
}
|
||
}
|
||
|
||
// Drop удаляет все документы из коллекции.
|
||
//
|
||
// ИСПРАВЛЕНО: больше не пересоздаёт sync.Map — очищает содержимое
|
||
// через Range + Delete. Это устраняет data race с читателями
|
||
// (Find/Insert/GetAllDocuments читают c.docs без c.mu).
|
||
func (c *Collection) Drop() error {
|
||
// 1. Очищаем c.docs.
|
||
c.docs.Range(func(key, value interface{}) bool {
|
||
c.docs.Delete(key)
|
||
return true
|
||
})
|
||
|
||
// 2. Очищаем c.indexes (сбрасываем SkipList).
|
||
c.indexes.Range(func(key, value interface{}) bool {
|
||
if idx, ok := value.(*Index); ok && idx.data != nil {
|
||
idx.data.Clear()
|
||
}
|
||
c.indexes.Delete(key)
|
||
return true
|
||
})
|
||
|
||
// 3. Очищаем c.triggers.
|
||
c.triggers.Range(func(key, value interface{}) bool {
|
||
c.triggers.Delete(key)
|
||
return true
|
||
})
|
||
|
||
// 4. Сбрасываем счётчики.
|
||
c.docCount.Store(0)
|
||
c.sizeBytes.Store(0)
|
||
|
||
c.mu.Lock()
|
||
c.metadata.DocumentCount = 0
|
||
c.metadata.SizeBytes = 0
|
||
c.metadata.IndexCount = 0
|
||
c.metadata.UpdatedAt = time.Now().UnixMilli()
|
||
c.mu.Unlock()
|
||
|
||
// 5. Восстанавливаем _id индекс, если он был включён.
|
||
if c.metadata.Settings.AutoIndexID {
|
||
_ = c.CreateIndex("_id_", []string{"_id"}, true)
|
||
}
|
||
|
||
AuditCollectionOperation("DROP", c.dbName, c.name, nil)
|
||
return nil
|
||
}
|
||
|
||
// logConstraintChange логирует изменение ограничения.
|
||
func (c *Collection) logConstraintChange(action, constraintType, field string, oldVal, newVal interface{}) {
|
||
LogAudit("CONSTRAINT_"+action, "CONSTRAINT",
|
||
fmt.Sprintf("%s.%s", c.dbName, c.name), map[string]interface{}{
|
||
"constraint_type": constraintType,
|
||
"field": field,
|
||
"old_value": oldVal,
|
||
"new_value": newVal,
|
||
})
|
||
}
|
||
|
||
// logACLChange логирует изменение ACL.
|
||
func (c *Collection) logACLChange(action, role, permission string, granted bool) {
|
||
LogAudit("ACL_"+action, "ACL",
|
||
fmt.Sprintf("%s.%s", c.dbName, c.name), map[string]interface{}{
|
||
"role": role,
|
||
"permission": permission,
|
||
"granted": granted,
|
||
})
|
||
}
|
||
|
||
// =============================================================================
|
||
// МЕТОДЫ ОГРАНИЧЕНИЙ (Constraints)
|
||
// =============================================================================
|
||
|
||
// AddRequiredField добавляет обязательное поле.
|
||
func (c *Collection) AddRequiredField(field string) {
|
||
c.constraints.mu.Lock()
|
||
oldMap := c.constraints.loadRequiredFieldsUnsafe()
|
||
oldVal := oldMap[field]
|
||
newMap := make(map[string]bool, len(oldMap)+1)
|
||
for k, v := range oldMap {
|
||
newMap[k] = v
|
||
}
|
||
newMap[field] = true
|
||
c.constraints.requiredFieldsPtr.Store(newMap)
|
||
c.constraints.mu.Unlock()
|
||
|
||
c.logConstraintChange("ADD", "required", field, oldVal, true)
|
||
}
|
||
|
||
// AddUniqueConstraint добавляет ограничение уникальности.
|
||
func (c *Collection) AddUniqueConstraint(field string) {
|
||
c.constraints.mu.Lock()
|
||
oldMap := c.constraints.loadUniqueFieldsUnsafe()
|
||
oldVal := oldMap[field]
|
||
newMap := make(map[string]bool, len(oldMap)+1)
|
||
for k, v := range oldMap {
|
||
newMap[k] = v
|
||
}
|
||
newMap[field] = true
|
||
c.constraints.uniqueFieldsPtr.Store(newMap)
|
||
c.constraints.mu.Unlock()
|
||
|
||
c.logConstraintChange("ADD", "unique", field, oldVal, true)
|
||
_ = c.CreateIndex("unique_"+field, []string{field}, true)
|
||
}
|
||
|
||
// AddMinConstraint добавляет минимальное значение.
|
||
func (c *Collection) AddMinConstraint(field string, min float64) {
|
||
c.constraints.mu.Lock()
|
||
oldMap := c.constraints.loadMinValuesUnsafe()
|
||
oldVal := oldMap[field]
|
||
newMap := make(map[string]float64, len(oldMap)+1)
|
||
for k, v := range oldMap {
|
||
newMap[k] = v
|
||
}
|
||
newMap[field] = min
|
||
c.constraints.minValuesPtr.Store(newMap)
|
||
c.constraints.mu.Unlock()
|
||
|
||
c.logConstraintChange("ADD", "min", field, oldVal, min)
|
||
}
|
||
|
||
// AddMaxConstraint добавляет максимальное значение.
|
||
func (c *Collection) AddMaxConstraint(field string, max float64) {
|
||
c.constraints.mu.Lock()
|
||
oldMap := c.constraints.loadMaxValuesUnsafe()
|
||
oldVal := oldMap[field]
|
||
newMap := make(map[string]float64, len(oldMap)+1)
|
||
for k, v := range oldMap {
|
||
newMap[k] = v
|
||
}
|
||
newMap[field] = max
|
||
c.constraints.maxValuesPtr.Store(newMap)
|
||
c.constraints.mu.Unlock()
|
||
|
||
c.logConstraintChange("ADD", "max", field, oldVal, max)
|
||
}
|
||
|
||
// AddRegexConstraint добавляет regex паттерн.
|
||
func (c *Collection) AddRegexConstraint(field string, pattern string) {
|
||
c.constraints.mu.Lock()
|
||
oldMap := c.constraints.loadPatternFieldsUnsafe()
|
||
oldVal := oldMap[field]
|
||
newMap := make(map[string]string, len(oldMap)+1)
|
||
for k, v := range oldMap {
|
||
newMap[k] = v
|
||
}
|
||
newMap[field] = pattern
|
||
c.constraints.patternFieldsPtr.Store(newMap)
|
||
c.constraints.mu.Unlock()
|
||
|
||
c.logConstraintChange("ADD", "regex", field, oldVal, pattern)
|
||
}
|
||
|
||
// AddEnumConstraint добавляет допустимые значения.
|
||
func (c *Collection) AddEnumConstraint(field string, values []interface{}) {
|
||
c.constraints.mu.Lock()
|
||
oldMap := c.constraints.loadEnumFieldsUnsafe()
|
||
oldVal := oldMap[field]
|
||
newMap := make(map[string][]interface{}, len(oldMap)+1)
|
||
for k, v := range oldMap {
|
||
copiedVals := make([]interface{}, len(v))
|
||
copy(copiedVals, v)
|
||
newMap[k] = copiedVals
|
||
}
|
||
copiedValues := make([]interface{}, len(values))
|
||
copy(copiedValues, values)
|
||
newMap[field] = copiedValues
|
||
c.constraints.enumFieldsPtr.Store(newMap)
|
||
c.constraints.mu.Unlock()
|
||
|
||
c.logConstraintChange("ADD", "enum", field, oldVal, values)
|
||
}
|
||
|
||
// RemoveRequiredField удаляет обязательное поле.
|
||
func (c *Collection) RemoveRequiredField(field string) {
|
||
c.constraints.mu.Lock()
|
||
oldMap := c.constraints.loadRequiredFieldsUnsafe()
|
||
oldVal := oldMap[field]
|
||
newMap := make(map[string]bool, len(oldMap))
|
||
for k, v := range oldMap {
|
||
if k != field {
|
||
newMap[k] = v
|
||
}
|
||
}
|
||
c.constraints.requiredFieldsPtr.Store(newMap)
|
||
c.constraints.mu.Unlock()
|
||
c.logConstraintChange("REMOVE", "required", field, oldVal, nil)
|
||
}
|
||
|
||
// RemoveUniqueConstraint удаляет ограничение уникальности.
|
||
func (c *Collection) RemoveUniqueConstraint(field string) {
|
||
c.constraints.mu.Lock()
|
||
oldMap := c.constraints.loadUniqueFieldsUnsafe()
|
||
oldVal := oldMap[field]
|
||
newMap := make(map[string]bool, len(oldMap))
|
||
for k, v := range oldMap {
|
||
if k != field {
|
||
newMap[k] = v
|
||
}
|
||
}
|
||
c.constraints.uniqueFieldsPtr.Store(newMap)
|
||
c.constraints.mu.Unlock()
|
||
c.logConstraintChange("REMOVE", "unique", field, oldVal, nil)
|
||
_ = c.DropIndex("unique_" + field)
|
||
}
|
||
|
||
// RemoveMinConstraint удаляет минимальное значение.
|
||
func (c *Collection) RemoveMinConstraint(field string) {
|
||
c.constraints.mu.Lock()
|
||
oldMap := c.constraints.loadMinValuesUnsafe()
|
||
oldVal := oldMap[field]
|
||
newMap := make(map[string]float64, len(oldMap))
|
||
for k, v := range oldMap {
|
||
if k != field {
|
||
newMap[k] = v
|
||
}
|
||
}
|
||
c.constraints.minValuesPtr.Store(newMap)
|
||
c.constraints.mu.Unlock()
|
||
c.logConstraintChange("REMOVE", "min", field, oldVal, nil)
|
||
}
|
||
|
||
// RemoveMaxConstraint удаляет максимальное значение.
|
||
func (c *Collection) RemoveMaxConstraint(field string) {
|
||
c.constraints.mu.Lock()
|
||
oldMap := c.constraints.loadMaxValuesUnsafe()
|
||
oldVal := oldMap[field]
|
||
newMap := make(map[string]float64, len(oldMap))
|
||
for k, v := range oldMap {
|
||
if k != field {
|
||
newMap[k] = v
|
||
}
|
||
}
|
||
c.constraints.maxValuesPtr.Store(newMap)
|
||
c.constraints.mu.Unlock()
|
||
c.logConstraintChange("REMOVE", "max", field, oldVal, nil)
|
||
}
|
||
|
||
// RemoveRegexConstraint удаляет regex паттерн.
|
||
func (c *Collection) RemoveRegexConstraint(field string) {
|
||
c.constraints.mu.Lock()
|
||
oldMap := c.constraints.loadPatternFieldsUnsafe()
|
||
oldVal := oldMap[field]
|
||
newMap := make(map[string]string, len(oldMap))
|
||
for k, v := range oldMap {
|
||
if k != field {
|
||
newMap[k] = v
|
||
}
|
||
}
|
||
c.constraints.patternFieldsPtr.Store(newMap)
|
||
c.constraints.mu.Unlock()
|
||
c.logConstraintChange("REMOVE", "regex", field, oldVal, nil)
|
||
}
|
||
|
||
// RemoveEnumConstraint удаляет допустимые значения.
|
||
func (c *Collection) RemoveEnumConstraint(field string) {
|
||
c.constraints.mu.Lock()
|
||
oldMap := c.constraints.loadEnumFieldsUnsafe()
|
||
oldVal := oldMap[field]
|
||
newMap := make(map[string][]interface{}, len(oldMap))
|
||
for k, v := range oldMap {
|
||
if k != field {
|
||
copiedVals := make([]interface{}, len(v))
|
||
copy(copiedVals, v)
|
||
newMap[k] = copiedVals
|
||
}
|
||
}
|
||
c.constraints.enumFieldsPtr.Store(newMap)
|
||
c.constraints.mu.Unlock()
|
||
c.logConstraintChange("REMOVE", "enum", field, oldVal, nil)
|
||
}
|
||
|
||
// GetRequiredFields возвращает список обязательных полей.
|
||
func (c *Collection) GetRequiredFields() []string {
|
||
fieldsMap := c.constraints.loadRequiredFields()
|
||
fields := make([]string, 0, len(fieldsMap))
|
||
for field := range fieldsMap {
|
||
fields = append(fields, field)
|
||
}
|
||
return fields
|
||
}
|
||
|
||
// GetUniqueConstraints возвращает список уникальных полей.
|
||
func (c *Collection) GetUniqueConstraints() []string {
|
||
fieldsMap := c.constraints.loadUniqueFields()
|
||
fields := make([]string, 0, len(fieldsMap))
|
||
for field := range fieldsMap {
|
||
fields = append(fields, field)
|
||
}
|
||
return fields
|
||
}
|
||
|
||
// GetMinConstraints возвращает карту минимальных значений.
|
||
func (c *Collection) GetMinConstraints() map[string]float64 {
|
||
result := c.constraints.loadMinValues()
|
||
resultCopy := make(map[string]float64, len(result))
|
||
for k, v := range result {
|
||
resultCopy[k] = v
|
||
}
|
||
return resultCopy
|
||
}
|
||
|
||
// GetMaxConstraints возвращает карту максимальных значений.
|
||
func (c *Collection) GetMaxConstraints() map[string]float64 {
|
||
result := c.constraints.loadMaxValues()
|
||
resultCopy := make(map[string]float64, len(result))
|
||
for k, v := range result {
|
||
resultCopy[k] = v
|
||
}
|
||
return resultCopy
|
||
}
|
||
|
||
// GetEnumConstraints возвращает карту enum ограничений.
|
||
func (c *Collection) GetEnumConstraints() map[string][]interface{} {
|
||
result := c.constraints.loadEnumFields()
|
||
resultCopy := make(map[string][]interface{}, len(result))
|
||
for k, v := range result {
|
||
copied := make([]interface{}, len(v))
|
||
copy(copied, v)
|
||
resultCopy[k] = copied
|
||
}
|
||
return resultCopy
|
||
}
|
||
|
||
// GetRegexConstraints возвращает карту regex паттернов.
|
||
func (c *Collection) GetRegexConstraints() map[string]string {
|
||
result := c.constraints.loadPatternFields()
|
||
resultCopy := make(map[string]string, len(result))
|
||
for k, v := range result {
|
||
resultCopy[k] = v
|
||
}
|
||
return resultCopy
|
||
}
|
||
|
||
// GetConstraints возвращает все ограничения коллекции.
|
||
func (c *Collection) GetConstraints() map[string]interface{} {
|
||
return map[string]interface{}{
|
||
"required_fields": c.GetRequiredFields(),
|
||
"unique_fields": c.GetUniqueConstraints(),
|
||
"min_values": c.GetMinConstraints(),
|
||
"max_values": c.GetMaxConstraints(),
|
||
"enum_values": c.GetEnumConstraints(),
|
||
"regex_patterns": c.GetRegexConstraints(),
|
||
}
|
||
}
|
||
|
||
// GetConstraintTimestamps возвращает временные метки ограничений.
|
||
func (c *Collection) GetConstraintTimestamps() map[string]interface{} {
|
||
return map[string]interface{}{
|
||
"created_at": c.constraints.createdAt,
|
||
"updated_at": c.constraints.updatedAt.Load(),
|
||
"history_count": len(c.constraints.loadConstraintHistory()),
|
||
}
|
||
}
|
||
|
||
// GetConstraintHistory возвращает историю изменений ограничений.
|
||
func (c *Collection) GetConstraintHistory() []ConstraintChange {
|
||
history := c.constraints.loadConstraintHistory()
|
||
result := make([]ConstraintChange, len(history))
|
||
copy(result, history)
|
||
return result
|
||
}
|
||
|
||
// ValidateDocument проверяет документ на соответствие ограничениям.
|
||
//
|
||
// ИСПРАВЛЕНО: regexp-ограничения теперь используют regexp.MatchString,
|
||
// а не strings.Contains (см. AddRegexConstraint).
|
||
func (cons *Constraints) ValidateDocument(doc *Document) error {
|
||
requiredFields := cons.loadRequiredFields()
|
||
for field := range requiredFields {
|
||
if !doc.HasField(field) {
|
||
return fmt.Errorf("required field '%s' is missing", field)
|
||
}
|
||
}
|
||
|
||
minValues := cons.loadMinValues()
|
||
for field, minVal := range minValues {
|
||
if val, err := doc.GetField(field); err == nil {
|
||
if numVal, ok := toFloat64(val); ok {
|
||
if numVal < minVal {
|
||
return fmt.Errorf("field '%s' value %v is less than minimum %v", field, numVal, minVal)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
maxValues := cons.loadMaxValues()
|
||
for field, maxVal := range maxValues {
|
||
if val, err := doc.GetField(field); err == nil {
|
||
if numVal, ok := toFloat64(val); ok {
|
||
if numVal > maxVal {
|
||
return fmt.Errorf("field '%s' value %v exceeds maximum %v", field, numVal, maxVal)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
patternFields := cons.loadPatternFields()
|
||
for field, pattern := range patternFields {
|
||
if val, err := doc.GetField(field); err == nil {
|
||
if strVal, ok := val.(string); ok {
|
||
if pattern == "" {
|
||
continue
|
||
}
|
||
re, err := regexp.Compile(pattern)
|
||
if err != nil {
|
||
return fmt.Errorf("invalid regex pattern '%s' for field '%s': %v", pattern, field, err)
|
||
}
|
||
if !re.MatchString(strVal) {
|
||
return fmt.Errorf("field '%s' value '%s' does not match pattern '%s'", field, strVal, pattern)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
enumFields := cons.loadEnumFields()
|
||
for field, allowedValues := range enumFields {
|
||
if val, err := doc.GetField(field); err == nil {
|
||
found := false
|
||
for _, allowed := range allowedValues {
|
||
if fmt.Sprintf("%v", val) == fmt.Sprintf("%v", allowed) {
|
||
found = true
|
||
break
|
||
}
|
||
}
|
||
if !found {
|
||
return fmt.Errorf("field '%s' value '%v' not in allowed list", field, val)
|
||
}
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// =============================================================================
|
||
// МЕТОДЫ ACL
|
||
// =============================================================================
|
||
|
||
// SetACL устанавливает ACL для коллекции.
|
||
func (c *Collection) SetACL(role string, canRead, canWrite, canDelete, isAdmin bool) {
|
||
c.acl.updatedAt.Store(time.Now().UnixMilli())
|
||
|
||
if canRead {
|
||
c.acl.mu.Lock()
|
||
oldRoles := c.acl.loadReadRolesUnsafe()
|
||
if !oldRoles[role] {
|
||
newRoles := make(map[string]bool, len(oldRoles)+1)
|
||
for k, v := range oldRoles {
|
||
newRoles[k] = v
|
||
}
|
||
newRoles[role] = true
|
||
c.acl.readRolesPtr.Store(newRoles)
|
||
c.acl.mu.Unlock()
|
||
c.logACLChange("GRANT", role, "read", true)
|
||
} else {
|
||
c.acl.mu.Unlock()
|
||
}
|
||
}
|
||
if canWrite {
|
||
c.acl.mu.Lock()
|
||
oldRoles := c.acl.loadWriteRolesUnsafe()
|
||
if !oldRoles[role] {
|
||
newRoles := make(map[string]bool, len(oldRoles)+1)
|
||
for k, v := range oldRoles {
|
||
newRoles[k] = v
|
||
}
|
||
newRoles[role] = true
|
||
c.acl.writeRolesPtr.Store(newRoles)
|
||
c.acl.mu.Unlock()
|
||
c.logACLChange("GRANT", role, "write", true)
|
||
} else {
|
||
c.acl.mu.Unlock()
|
||
}
|
||
}
|
||
if canDelete {
|
||
c.acl.mu.Lock()
|
||
oldRoles := c.acl.loadDeleteRolesUnsafe()
|
||
if !oldRoles[role] {
|
||
newRoles := make(map[string]bool, len(oldRoles)+1)
|
||
for k, v := range oldRoles {
|
||
newRoles[k] = v
|
||
}
|
||
newRoles[role] = true
|
||
c.acl.deleteRolesPtr.Store(newRoles)
|
||
c.acl.mu.Unlock()
|
||
c.logACLChange("GRANT", role, "delete", true)
|
||
} else {
|
||
c.acl.mu.Unlock()
|
||
}
|
||
}
|
||
if isAdmin {
|
||
c.acl.mu.Lock()
|
||
oldRoles := c.acl.loadAdminRolesUnsafe()
|
||
if !oldRoles[role] {
|
||
newRoles := make(map[string]bool, len(oldRoles)+1)
|
||
for k, v := range oldRoles {
|
||
newRoles[k] = v
|
||
}
|
||
newRoles[role] = true
|
||
c.acl.adminRolesPtr.Store(newRoles)
|
||
c.acl.mu.Unlock()
|
||
c.logACLChange("GRANT", role, "admin", true)
|
||
} else {
|
||
c.acl.mu.Unlock()
|
||
}
|
||
}
|
||
}
|
||
|
||
// RevokeACL отзывает разрешения у роли.
|
||
func (c *Collection) RevokeACL(role string, permission string) {
|
||
c.acl.updatedAt.Store(time.Now().UnixMilli())
|
||
|
||
switch permission {
|
||
case "read":
|
||
c.acl.mu.Lock()
|
||
oldRoles := c.acl.loadReadRolesUnsafe()
|
||
if oldRoles[role] {
|
||
newRoles := make(map[string]bool, len(oldRoles))
|
||
for k, v := range oldRoles {
|
||
if k != role {
|
||
newRoles[k] = v
|
||
}
|
||
}
|
||
c.acl.readRolesPtr.Store(newRoles)
|
||
c.acl.mu.Unlock()
|
||
c.logACLChange("REVOKE", role, "read", false)
|
||
} else {
|
||
c.acl.mu.Unlock()
|
||
}
|
||
case "write":
|
||
c.acl.mu.Lock()
|
||
oldRoles := c.acl.loadWriteRolesUnsafe()
|
||
if oldRoles[role] {
|
||
newRoles := make(map[string]bool, len(oldRoles))
|
||
for k, v := range oldRoles {
|
||
if k != role {
|
||
newRoles[k] = v
|
||
}
|
||
}
|
||
c.acl.writeRolesPtr.Store(newRoles)
|
||
c.acl.mu.Unlock()
|
||
c.logACLChange("REVOKE", role, "write", false)
|
||
} else {
|
||
c.acl.mu.Unlock()
|
||
}
|
||
case "delete":
|
||
c.acl.mu.Lock()
|
||
oldRoles := c.acl.loadDeleteRolesUnsafe()
|
||
if oldRoles[role] {
|
||
newRoles := make(map[string]bool, len(oldRoles))
|
||
for k, v := range oldRoles {
|
||
if k != role {
|
||
newRoles[k] = v
|
||
}
|
||
}
|
||
c.acl.deleteRolesPtr.Store(newRoles)
|
||
c.acl.mu.Unlock()
|
||
c.logACLChange("REVOKE", role, "delete", false)
|
||
} else {
|
||
c.acl.mu.Unlock()
|
||
}
|
||
case "admin":
|
||
c.acl.mu.Lock()
|
||
oldRoles := c.acl.loadAdminRolesUnsafe()
|
||
if oldRoles[role] {
|
||
newRoles := make(map[string]bool, len(oldRoles))
|
||
for k, v := range oldRoles {
|
||
if k != role {
|
||
newRoles[k] = v
|
||
}
|
||
}
|
||
c.acl.adminRolesPtr.Store(newRoles)
|
||
c.acl.mu.Unlock()
|
||
c.logACLChange("REVOKE", role, "admin", false)
|
||
} else {
|
||
c.acl.mu.Unlock()
|
||
}
|
||
}
|
||
}
|
||
|
||
// CheckPermission проверяет наличие разрешения у роли.
|
||
func (c *Collection) CheckPermission(role, operation string) bool {
|
||
return c.acl.CheckPermission(role, operation)
|
||
}
|
||
|
||
// GetACLTimestamps возвращает временные метки ACL.
|
||
func (c *Collection) GetACLTimestamps() map[string]interface{} {
|
||
return map[string]interface{}{
|
||
"created_at": c.acl.createdAt,
|
||
"updated_at": c.acl.updatedAt.Load(),
|
||
}
|
||
}
|
||
|
||
// GetACLHistory возвращает историю изменений ACL.
|
||
func (c *Collection) GetACLHistory() []ACLChange {
|
||
history := c.acl.loadACLHistory()
|
||
result := make([]ACLChange, len(history))
|
||
copy(result, history)
|
||
return result
|
||
}
|
||
|
||
// GetACLUpdatedAt возвращает время последнего обновления ACL.
|
||
func (c *Collection) GetACLUpdatedAt() int64 { return c.acl.updatedAt.Load() }
|
||
|
||
// GetACLCreatedAt возвращает время создания ACL.
|
||
func (c *Collection) GetACLCreatedAt() int64 { return c.acl.createdAt }
|
||
|
||
// =============================================================================
|
||
// ACL: CheckPermission
|
||
// =============================================================================
|
||
|
||
// CheckPermission проверяет наличие разрешения у роли (lock-free).
|
||
func (acl *CollectionACL) CheckPermission(role, operation string) bool {
|
||
acl.mu.RLock()
|
||
defer acl.mu.RUnlock()
|
||
|
||
if val := acl.adminRolesPtr.Load(); val != nil {
|
||
if adminRoles, ok := val.(map[string]bool); ok && adminRoles[role] {
|
||
return true
|
||
}
|
||
}
|
||
|
||
switch operation {
|
||
case "read":
|
||
if val := acl.readRolesPtr.Load(); val != nil {
|
||
if readRoles, ok := val.(map[string]bool); ok {
|
||
return readRoles[role]
|
||
}
|
||
}
|
||
case "write":
|
||
if val := acl.writeRolesPtr.Load(); val != nil {
|
||
if writeRoles, ok := val.(map[string]bool); ok {
|
||
return writeRoles[role]
|
||
}
|
||
}
|
||
case "delete":
|
||
if val := acl.deleteRolesPtr.Load(); val != nil {
|
||
if deleteRoles, ok := val.(map[string]bool); ok {
|
||
return deleteRoles[role]
|
||
}
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// =============================================================================
|
||
// LOAD*/STORE* БЕЗ БЛОКИРОВКИ (используются под mu)
|
||
// =============================================================================
|
||
|
||
func (cons *Constraints) loadRequiredFields() map[string]bool {
|
||
cons.mu.RLock()
|
||
defer cons.mu.RUnlock()
|
||
return cons.loadRequiredFieldsUnsafe()
|
||
}
|
||
|
||
func (cons *Constraints) loadRequiredFieldsUnsafe() map[string]bool {
|
||
val := cons.requiredFieldsPtr.Load()
|
||
if val == nil {
|
||
return make(map[string]bool)
|
||
}
|
||
return val.(map[string]bool)
|
||
}
|
||
|
||
func (cons *Constraints) loadUniqueFields() map[string]bool {
|
||
cons.mu.RLock()
|
||
defer cons.mu.RUnlock()
|
||
return cons.loadUniqueFieldsUnsafe()
|
||
}
|
||
|
||
func (cons *Constraints) loadUniqueFieldsUnsafe() map[string]bool {
|
||
val := cons.uniqueFieldsPtr.Load()
|
||
if val == nil {
|
||
return make(map[string]bool)
|
||
}
|
||
return val.(map[string]bool)
|
||
}
|
||
|
||
func (cons *Constraints) loadMinValues() map[string]float64 {
|
||
cons.mu.RLock()
|
||
defer cons.mu.RUnlock()
|
||
return cons.loadMinValuesUnsafe()
|
||
}
|
||
|
||
func (cons *Constraints) loadMinValuesUnsafe() map[string]float64 {
|
||
val := cons.minValuesPtr.Load()
|
||
if val == nil {
|
||
return make(map[string]float64)
|
||
}
|
||
return val.(map[string]float64)
|
||
}
|
||
|
||
func (cons *Constraints) loadMaxValues() map[string]float64 {
|
||
cons.mu.RLock()
|
||
defer cons.mu.RUnlock()
|
||
return cons.loadMaxValuesUnsafe()
|
||
}
|
||
|
||
func (cons *Constraints) loadMaxValuesUnsafe() map[string]float64 {
|
||
val := cons.maxValuesPtr.Load()
|
||
if val == nil {
|
||
return make(map[string]float64)
|
||
}
|
||
return val.(map[string]float64)
|
||
}
|
||
|
||
func (cons *Constraints) loadPatternFields() map[string]string {
|
||
cons.mu.RLock()
|
||
defer cons.mu.RUnlock()
|
||
return cons.loadPatternFieldsUnsafe()
|
||
}
|
||
|
||
func (cons *Constraints) loadPatternFieldsUnsafe() map[string]string {
|
||
val := cons.patternFieldsPtr.Load()
|
||
if val == nil {
|
||
return make(map[string]string)
|
||
}
|
||
return val.(map[string]string)
|
||
}
|
||
|
||
func (cons *Constraints) loadEnumFields() map[string][]interface{} {
|
||
cons.mu.RLock()
|
||
defer cons.mu.RUnlock()
|
||
return cons.loadEnumFieldsUnsafe()
|
||
}
|
||
|
||
func (cons *Constraints) loadEnumFieldsUnsafe() map[string][]interface{} {
|
||
val := cons.enumFieldsPtr.Load()
|
||
if val == nil {
|
||
return make(map[string][]interface{})
|
||
}
|
||
return val.(map[string][]interface{})
|
||
}
|
||
|
||
func (cons *Constraints) loadConstraintHistory() []ConstraintChange {
|
||
val := cons.constraintHistory.Load()
|
||
if val == nil {
|
||
return make([]ConstraintChange, 0)
|
||
}
|
||
return val.([]ConstraintChange)
|
||
}
|
||
|
||
func (acl *CollectionACL) loadReadRolesUnsafe() map[string]bool {
|
||
val := acl.readRolesPtr.Load()
|
||
if val == nil {
|
||
return make(map[string]bool)
|
||
}
|
||
return val.(map[string]bool)
|
||
}
|
||
|
||
func (acl *CollectionACL) loadWriteRolesUnsafe() map[string]bool {
|
||
val := acl.writeRolesPtr.Load()
|
||
if val == nil {
|
||
return make(map[string]bool)
|
||
}
|
||
return val.(map[string]bool)
|
||
}
|
||
|
||
func (acl *CollectionACL) loadDeleteRolesUnsafe() map[string]bool {
|
||
val := acl.deleteRolesPtr.Load()
|
||
if val == nil {
|
||
return make(map[string]bool)
|
||
}
|
||
return val.(map[string]bool)
|
||
}
|
||
|
||
func (acl *CollectionACL) loadAdminRolesUnsafe() map[string]bool {
|
||
val := acl.adminRolesPtr.Load()
|
||
if val == nil {
|
||
return make(map[string]bool)
|
||
}
|
||
return val.(map[string]bool)
|
||
}
|
||
|
||
func (acl *CollectionACL) loadACLHistory() []ACLChange {
|
||
val := acl.aclHistory.Load()
|
||
if val == nil {
|
||
return make([]ACLChange, 0)
|
||
}
|
||
return val.([]ACLChange)
|
||
}
|
||
|
||
// toFloat64 конвертирует interface{} в float64.
|
||
func toFloat64(val interface{}) (float64, bool) {
|
||
switch v := val.(type) {
|
||
case int:
|
||
return float64(v), true
|
||
case int32:
|
||
return float64(v), true
|
||
case int64:
|
||
return float64(v), true
|
||
case uint:
|
||
return float64(v), true
|
||
case uint32:
|
||
return float64(v), true
|
||
case uint64:
|
||
return float64(v), true
|
||
case float32:
|
||
return float64(v), true
|
||
case float64:
|
||
return v, true
|
||
default:
|
||
return 0, false
|
||
}
|
||
} |