第213章 ICAI 数据持久化体系

213.1 数据持久化体系的提出

在 ICAI（Individual Cognitive AI）系统中，前面已经建立了 Individual、Object、State、Relation、Knowledge、Capability、Method、Behavior、Memory、Experience、Learning 等大量认知对象。

这些对象在系统运行过程中首先存在于 PHP 程序的内存中。

例如：

Individual
Object
State
Capability
Method
Decision
Behavior
Execution
Result
Feedback
Memory
Experience
Learning

但是 PHP 请求结束之后，内存中的对象通常会被释放。

因此，ICAI 必须解决一个基础问题：

当前运行中的对象，如何被保存为下一次运行仍然可以恢复的数据？

这就是数据持久化体系。

其基本关系为：

MemoryObject→PersistenceObject→DatabaseMemoryObject \rightarrow PersistenceObject \rightarrow Database

再次运行时：

Database→PersistenceObject→MemoryObjectDatabase \rightarrow PersistenceObject \rightarrow MemoryObject

因此，持久化不是简单的“保存数据库”，而是：

RuntimeObject↔PersistenceObjectRuntimeObject \leftrightarrow PersistenceObject

之间的双向转换体系。

---

213.2 持久化的基本定义

**Data Persistence（数据持久化）**是指将程序运行期间存在于内存中的有效对象、状态、关系、历史和认知数据，以稳定的数据结构保存到长期存储介质中，使系统在当前运行结束之后仍然能够重新恢复这些数据。

基本模型：

Persistence=MemoryObject+Mapping+Storage+RecoveryPersistence= MemoryObject + Mapping + Storage + Recovery

其中：

• MemoryObject：内存对象；
• Mapping：对象与数据库之间的映射；
• Storage：持久化保存；
• Recovery：从持久化数据重新恢复对象。

因此：

Persistence≠DatabasePersistence \neq Database

数据库只是持久化体系中的存储层。

完整结构为：

Domain Object
      ↓
Memory Object
      ↓
Service
      ↓
Repository
      ↓
Persistence Object
      ↓
MySQL

读取时方向相反：

MySQL
      ↓
Persistence Object
      ↓
Repository
      ↓
Service
      ↓
Domain Object
      ↓
Memory Object

---

213.3 内存对象 Memory Object

**Memory Object（内存对象）**是指程序当前运行过程中，由 PHP 对象、数组和运行时上下文共同构成的当前对象实例。

例如：

$object = new Object();
$object->id = 1001;
$object->type = 'machine';
$object->state = 'ready';

此时：

$object

就是一个内存对象。

可以定义：

MO=(I,T,A,S,R,C,Tm)MO=(I,T,A,S,R,C,T_m)

其中：

• II：Identity，对象身份；
• TT：Type，对象类型；
• AA：Attributes，属性；
• SS：State，状态；
• RR：Relations，关系；
• CC：Context，上下文；
• TmT_m：当前运行时间。

内存对象的特点是：

1. 存在于当前 PHP 进程；
2. 可以被 Engine 直接计算；
3. 可以被 Service 组织；
4. 可以发生状态变化；
5. 可以暂时处于未保存状态；
6. PHP 请求结束后可能消失。

因此：

MemoryObject≠PersistentObjectMemoryObject \neq PersistentObject

---

213.4 持久化对象 Persistence Object

**Persistence Object（持久化对象）**是指能够以稳定数据结构保存到数据库中的对象表示。

例如一个内存对象：

Object-A
type = machine
state = ready
capacity = 100

经过 Repository 映射后，可以成为：

objects
----------------
id = 1001
type = machine
state = ready

其模型可以表示为：

PO=(I,T,A,S,R,V,Tu)PO=(I,T,A,S,R,V,T_u)

其中：

• II：Identity；
• TT：Type；
• AA：Attributes；
• SS：Persisted State；
• RR：Persisted Relations；
• VV：Version；
• TuT_u：更新时间。

持久化对象必须具有稳定身份。

因此：

PersistentIdentityPersistentIdentity

不能依赖 PHP 当前对象的内存地址。

正确方式应该使用：

object_id
individual_id
relation_id
knowledge_id
method_id

等稳定标识。

---

213.5 内存对象与持久化对象的关系

两者之间不是简单复制。

可以定义映射：

Map(MO)→POMap(MO)\rightarrow PO

以及恢复：

Map(PO)→MOMap(PO)\rightarrow MO

完整过程：

MO→Normalize→Validate→Map→PO→StorageMO \rightarrow Normalize \rightarrow Validate \rightarrow Map \rightarrow PO \rightarrow Storage

读取：

Storage→PO→Validate→Map→MOStorage \rightarrow PO \rightarrow Validate \rightarrow Map \rightarrow MO

因此：

MOt≠POtMO_t \neq PO_t

二者的生命周期和职责不同。

---

213.6 Runtime Object 与 Persistence Object

前面第168章已经定义 Runtime Object：

RO=(I,S,C,R,T)RO=(I,S,C,R,T)

Runtime Object 表示：

当前这一时刻，系统实际正在处理什么对象、处于什么状态、具有什么上下文。

Persistence Object 则表示：

系统需要长期保存什么事实。

因此：

RuntimeObject=CurrentRealityRuntimeObject = CurrentReality

而：

PersistenceObject=StoredRepresentationPersistenceObject = StoredRepresentation

例如：

Runtime:
Machine-A
State = running
Execution = E-100
Time = 15:30:20

数据库中可能只保存：

Machine-A
State = running
last_execution_id = E-100
updated_at = ...

Runtime 中的临时计算变量并不一定需要保存。

---

213.7 什么数据应该持久化

ICAI 并不是所有内存数据都必须保存。

可以分为三类：

第一类：必须持久化

包括：

Individual Identity
Object Identity
Current State
Relations
Knowledge
Capability
Method
Goal
Decision
Behavior History
Execution Result
Feedback
Memory
Experience
Learning Record
Verification
Diagnosis
Repair History

第二类：条件持久化

例如：

temporary calculation
candidate result
engine intermediate result
runtime context
temporary matching result
temporary scoring

只有在需要追踪、审计或恢复时才需要保存。

第三类：不需要持久化

例如：

temporary PHP variable
loop counter
temporary calculation variable
function local state

因此：

PersistableData≠AllMemoryDataPersistableData \neq AllMemoryData

---

213.8 数据生命周期

ICAI 数据必须具有生命周期。

基本生命周期：

Created→Loaded→Modified→Validated→Saved→Read→Updated→ArchivedCreated \rightarrow Loaded \rightarrow Modified \rightarrow Validated \rightarrow Saved \rightarrow Read \rightarrow Updated \rightarrow Archived

进一步展开：

Created
   ↓
Initialized
   ↓
Loaded
   ↓
Active
   ↓
Modified
   ↓
Validated
   ↓
Saved
   ↓
Updated
   ↓
Archived

异常状态：

Modified
   ↓
Validation Failed
   ↓
Rejected

或者：

Saved
   ↓
Corrupted
   ↓
Recovery

---

213.9 数据状态与对象状态必须分离

一个非常重要的原则：

DataState≠DomainStateDataState \neq DomainState

例如：

Object State:
running

与：

Persistence State:
saved

是两个不同维度。

可以定义：

Domain State

ready
running
failed
completed
blocked

Persistence State

new
dirty
saving
saved
failed
archived

因此一个对象可以同时处于：

Domain State = running
Persistence State = dirty

表示：

对象当前正在运行，但最新状态尚未保存。

这在 ICAI 中非常重要。

---

213.10 Dirty Object

**Dirty Object（脏对象）**表示：

内存对象已经发生变化，但数据库中的持久化数据仍然是旧版本。

例如：

Database:
State = ready

运行后：

Memory:
State = running

此时：

MemoryState≠PersistedStateMemoryState \neq PersistedState

因此对象：

dirty = true

当保存完成：

Memory State = running
Database State = running
dirty = false

即：

Dirty→Save→CleanDirty \rightarrow Save \rightarrow Clean

---

213.11 数据版本

为了避免新旧数据覆盖，可以引入版本：

Version=(Vo,Vp)Version=(V_o,V_p)

其中：

• VoV_o：Object Version；
• VpV_p：Persistence Version。

例如：

Object Version = 8
Database Version = 7

表示：

内存中的对象比数据库更新一个版本。

保存前可以检查：

Vmemory=Vdatabase+1V_{memory}=V_{database}+1

如果数据库已经被其他操作修改：

Memory Version = 8
Database Version = 9

则：

VersionConflict=trueVersionConflict=true

系统不能无条件覆盖。

---

213.12 数据保存 Save

**Save（数据保存）**是将经过验证的内存对象变化正式写入持久化存储的过程。

基本模型：

Save(MO)→PO→DatabaseSave(MO) \rightarrow PO \rightarrow Database

完整过程：

Object→DetectChange→Validate→Map→Transaction→Persist→VerifyObject \rightarrow DetectChange \rightarrow Validate \rightarrow Map \rightarrow Transaction \rightarrow Persist \rightarrow Verify

因此：

SaveSuccess≠SQLExecutedSaveSuccess \neq SQLExecuted

SQL 执行成功只是数据库操作成功。

真正的数据保存成功还需要：

Persisted∧VerifiedPersisted \land Verified

---

213.13 数据保存条件

ICAI 可以定义：

CanSave=Identity∧ValidData∧ValidState∧ValidRelation∧RuleCanSave= Identity \land ValidData \land ValidState \land ValidRelation \land Rule

其中：

• Identity：身份有效；
• ValidData：数据结构有效；
• ValidState：状态合法；
• ValidRelation：关系合法；
• Rule：符合保存规则。

如果对象身份不存在：

CanSave=falseCanSave=false

如果关系指向不存在对象：

CanSave=falseCanSave=false

如果状态转换非法：

CanSave=falseCanSave=false

因此 Repository 不能简单执行：

INSERT

然后就认为对象已经成为合法持久化对象。

---

213.14 Insert 与 Update

保存通常包含两种基本操作：

Save=Insert+UpdateSave=Insert+Update

Insert

对象不存在于数据库：

MO→INSERT→POMO \rightarrow INSERT \rightarrow PO

Update

对象已经存在：

MO→Compare→UPDATE→POMO \rightarrow Compare \rightarrow UPDATE \rightarrow PO

必须避免错误的重复插入。

因此可以首先判断：

Exists(ID)Exists(ID)

然后：

Not Exists → Insert
Exists → Compare → Update

---

213.15 数据差异计算

保存之前可以计算：

ΔD=Compare(MO,PO)\Delta D=Compare(MO,PO)

例如：

Before:
state = ready
capacity = 100

After:
state = running
capacity = 100

得到：

ΔD={state:ready→running}\Delta D= \{state:ready\rightarrow running\}

此时只需要更新 State。

这与前面的 **Minimal Update Principle（最小更新原则）**一致。

即：

Update=OnlyNecessaryChangedFieldsUpdate = OnlyNecessaryChangedFields

而不是：

DELETE old object
INSERT new object

---

213.16 数据读取 Read

**Read（数据读取）**是从持久化存储中获取数据，并重新构建为可以参与 ICAI 计算的内存对象的过程。

基本模型：

Read(Database)→PO→MORead(Database) \rightarrow PO \rightarrow MO

完整过程：

Database→Repository→PersistenceObject→Validate→Hydrate→DomainObject→RuntimeObjectDatabase \rightarrow Repository \rightarrow PersistenceObject \rightarrow Validate \rightarrow Hydrate \rightarrow DomainObject \rightarrow RuntimeObject

---

213.17 Hydration

**Hydration（对象恢复）**是指根据数据库数据重新构造 PHP Domain Object 的过程。

例如数据库：

objects
----------------
id = 1001
type = machine
state = ready

读取之后：

$object = new Object();
$object->id = 1001;
$object->type = 'machine';
$object->state = 'ready';

这个过程就是 Hydration。

反方向：

PHP Object
   ↓
Extract
   ↓
Persistence Data

可以称为：

Dehydration / Mapping。

因此：

Database→HydrationDomainObjectDatabase \xrightarrow{Hydration} DomainObject

以及：

DomainObject→MappingDatabaseDataDomainObject \xrightarrow{Mapping} DatabaseData

---

213.18 Repository 的作用

Repository 是持久化体系的核心边界。

它不负责：

• 决策；
• 学习；
• 风险计算；
• 方法选择；
• 行为执行。

Repository 负责：

• Save；
• Read；
• Update；
• Delete；
• Find；
• Exists；
• Mapping。

因此：

Repository=PersistenceBoundaryRepository = PersistenceBoundary

完整架构：

Controller
      ↓
Service
      ↓
Domain Object / Engine
      ↓
Repository
      ↓
MySQL

读取：

MySQL
      ↓
Repository
      ↓
Domain Object
      ↓
Service
      ↓
Controller

---

213.19 Individual 的持久化

Individual 是 ICAI 的核心主体，因此需要持久化其组成结构。

Individual：

I=(O,K,C,M,B,MM,E)I=(O,K,C,M,B,MM,E)

其中：

• OO：Objects；
• KK：Knowledge；
• CC：Capabilities；
• MM：Methods；
• BB：Behaviors；
• MMMM：Memory；
• EE：Experience。

因此 Individual 不应该全部压缩到一张表中。

推荐：

individuals
individual_objects
individual_knowledge
individual_capabilities
individual_methods
individual_behaviors
individual_memories
individual_experiences

同时通过关系表维护：

object_relations
knowledge_relations
memory_relations
experience_relations

---

213.20 State 的持久化

当前状态与状态历史应该分离。

例如：

states

保存当前状态：

object_id
state_type
state_value
updated_at

而：

state_history

保存历史：

object_id
old_state
new_state
reason
event
created_at

因此：

CurrentState≠StateHistoryCurrentState \neq StateHistory

读取当前状态：

Read(states)Read(states)

读取历史：

Read(state_history)Read(state\_history)

---

213.21 Relation 的持久化

Relation：

R=(ID,O1,T,O2,C,S,Tm)R=(ID,O_1,T,O_2,C,S,T_m)

持久化必须保存：

• Source；
• Relation Type；
• Target；
• Condition；
• State；
• Time。

例如：

object_relations
----------------
id
source_object_id
relation_type
target_object_id
condition
state
created_at
updated_at

关系不能只保存为 PHP 内存数组，否则程序重新启动后：

Relation=LostRelation=Lost

因此：

Object+Relation→PersistentStructureObject + Relation \rightarrow PersistentStructure

---

213.22 Knowledge 的持久化

Knowledge：

K=(S,P,O,C,St)K=(S,P,O,C,S_t)

数据库可以设计：

knowledge
----------------
id
subject_id
predicate
object_value
condition_data
state
verification_status
created_at
updated_at

如果知识经过验证，还应该保存：

knowledge_evidence
knowledge_history
knowledge_relations

这样系统能够回答：

当前知识是什么？

以及：

这个知识是如何形成的？

---

213.23 Memory 与 Experience 的持久化

Memory：

M=(I,C,W,T,R)M=(I,C,W,T,R)

Experience：

E=(H,M,C,R,P)E=(H,M,C,R,P)

因此数据库至少可以建立：

memories
memory_relations
memory_history

experiences
experience_relations
experience_history

特别是 Experience 不能只保存：

success_rate = 0.8

而应该保存：

history
condition
result
pattern
verification

否则经验无法被重新解释。

---

213.24 Learning 的持久化

LearningEngine 产生的学习记录也必须持久化。

例如：

learning_records
learning_evidence
learning_candidates
learning_history

一个学习记录：

L-001

Target:
Method-M1

Before:
Resource >= 1

New:
Resource >= 2

Reason:
Repeated verified resource insufficiency

Status:
candidate

经过 UpdateEngine：

Status:
applied

验证之后：

Status:
verified

因此学习本身也有生命周期。

---

213.25 数据保存生命周期

一个典型对象保存流程：

Create→Initialize→Modify→Dirty→Validate→Map→Transaction→Persist→Verify→CleanCreate \rightarrow Initialize \rightarrow Modify \rightarrow Dirty \rightarrow Validate \rightarrow Map \rightarrow Transaction \rightarrow Persist \rightarrow Verify \rightarrow Clean

如果失败：

Persist→Failure→RollbackPersist \rightarrow Failure \rightarrow Rollback

但必须注意：

DatabaseRollback≠ExternalWorldRollbackDatabaseRollback \neq ExternalWorldRollback

数据库事务只能回滚数据库操作。

如果一个 Action 已经真实执行：

External Execution

数据库回滚不能让外部世界自动回到执行前状态。

这与第185章 IndividualService 的事务原则保持一致。

---

213.26 数据读取生命周期

完整读取：

Request→Repository→Database→PersistenceObject→Validation→Hydration→DomainObject→RuntimeContextRequest \rightarrow Repository \rightarrow Database \rightarrow PersistenceObject \rightarrow Validation \rightarrow Hydration \rightarrow DomainObject \rightarrow RuntimeContext

例如：

Request:
Load Individual I-001

系统执行：

individuals
↓
objects
↓
states
↓
relations
↓
knowledge
↓
capabilities
↓
methods
↓
memory
↓
experience

最终恢复：

Individual=Object+Knowledge+Capability+Method+Behavior+Memory+ExperienceIndividual = Object + Knowledge + Capability + Method + Behavior + Memory + Experience

---

213.27 部分读取与完整读取

并不是每一次请求都需要恢复完整 Individual。

可以：

Read(I,O)Read(I,O)

只读取对象。

也可以：

Read(I,O,S)Read(I,O,S)

读取对象与状态。

或者：

Read(I,O,S,R,K)Read(I,O,S,R,K)

读取：

Object
State
Relation
Knowledge

因此 Repository 应支持：

findById()
findObjects()
findState()
findRelations()
findKnowledge()
findCapabilities()
findMethods()
findMemory()
findExperience()

这样可以减少不必要的数据加载。

---

213.28 Persistence Context

在一次完整 ICAI 运行过程中，可以建立：

Persistence Context（持久化上下文）。

定义：

PC=(I,O,S,R,K,C,M,E,T)PC=(I,O,S,R,K,C,M,E,T)

其中：

• II：Individual；
• OO：Object；
• SS：State；
• RR：Relation；
• KK：Knowledge；
• CC：Capability；
• MM：Memory；
• EE：Experience；
• TT：Time。

Persistence Context 的作用是：

管理一次运行过程中已经加载、修改、待保存和需要验证的数据对象。

---

213.29 Unit of Work

为了避免每修改一个对象就立即执行一次数据库操作，可以建立：

Unit of Work（工作单元）。

例如：

Object-A changed
State-A changed
Relation-A changed
Memory-A created
Learning-L1 created

全部登记到：

UnitOfWork

然后：

UnitOfWork→Validate→Transaction→SaveUnitOfWork \rightarrow Validate \rightarrow Transaction \rightarrow Save

这样可以保证一个认知过程产生的多个数据变化保持一致。

---

213.30 PHP UnitOfWork

PHP 5.6/7 可以实现：

<?php

class UnitOfWork
{
    protected $newObjects = array();
    protected $dirtyObjects = array();
    protected $deletedObjects = array();

    public function registerNew($object)
    {
        $this->newObjects[] = $object;
    }

    public function registerDirty($object)
    {
        $this->dirtyObjects[] = $object;
    }

    public function registerDeleted($object)
    {
        $this->deletedObjects[] = $object;
    }

    public function getNewObjects()
    {
        return $this->newObjects;
    }

    public function getDirtyObjects()
    {
        return $this->dirtyObjects;
    }

    public function getDeletedObjects()
    {
        return $this->deletedObjects;
    }

    public function clear()
    {
        $this->newObjects = array();
        $this->dirtyObjects = array();
        $this->deletedObjects = array();
    }
}

这个类不负责数据库操作。

它只负责记录：

New
Dirty
Deleted

具体保存由 Repository 和 TransactionManager 完成。

---

213.31 PersistenceMapper

可以建立对象映射器：

<?php

class PersistenceMapper
{
    public function objectToData($object)
    {
        return array(
            'id' => $object->id,
            'type' => $object->type,
            'state' => $object->state
        );
    }

    public function dataToObject($data)
    {
        $object = new Object();

        $object->id = $data['id'];
        $object->type = $data['type'];
        $object->state = $data['state'];

        return $object;
    }
}

因此：

Object→objectToDataPersistenceDataObject \xrightarrow{objectToData} PersistenceData

以及：

PersistenceData→dataToObjectObjectPersistenceData \xrightarrow{dataToObject} Object

---

213.32 Repository PHP 实现

一个基础 Repository：

<?php

class ObjectRepository
{
    protected $db;
    protected $mapper;

    public function __construct($db, $mapper)
    {
        $this->db = $db;
        $this->mapper = $mapper;
    }

    public function findById($id)
    {
        $sql = "SELECT id, type, state
                FROM objects
                WHERE id = ?";

        $stmt = $this->db->prepare($sql);
        $stmt->execute(array($id));

        $data = $stmt->fetch(PDO::FETCH_ASSOC);

        if (!$data) {
            return null;
        }

        return $this->mapper->dataToObject($data);
    }

    public function insert($object)
    {
        $data = $this->mapper->objectToData($object);

        $sql = "INSERT INTO objects
                (id, type, state)
                VALUES (?, ?, ?)";

        $stmt = $this->db->prepare($sql);

        return $stmt->execute(array(
            $data['id'],
            $data['type'],
            $data['state']
        ));
    }

    public function update($object)
    {
        $data = $this->mapper->objectToData($object);

        $sql = "UPDATE objects
                SET type = ?, state = ?
                WHERE id = ?";

        $stmt = $this->db->prepare($sql);

        return $stmt->execute(array(
            $data['type'],
            $data['state'],
            $data['id']
        ));
    }
}

这里 Repository 只处理：

Database↔ObjectDatabase \leftrightarrow Object

并不进行认知推理。

---

213.33 Service 负责保存协调

Repository 有了之后，不能让 Controller 直接操作 Repository。

正确结构：

Controller
      ↓
ObjectService
      ↓
Validation
      ↓
ObjectEngine
      ↓
Repository
      ↓
MySQL

例如：

<?php

class ObjectService
{
    protected $repository;

    public function __construct($repository)
    {
        $this->repository = $repository;
    }

    public function save($object)
    {
        if (empty($object->id)) {
            return false;
        }

        if ($this->repository->findById($object->id)) {
            return $this->repository->update($object);
        }

        return $this->repository->insert($object);
    }

    public function load($id)
    {
        return $this->repository->findById($id);
    }
}

这里：

Service=OrchestrationService=Orchestration Repository=PersistenceRepository=Persistence Engine=CalculationEngine=Calculation

三者职责保持独立。

---

213.34 Transaction

多个认知对象同时发生变化时，需要事务。

例如一次执行完成：

Execution
Result
Feedback
State
Memory
Experience
Learning

可能全部需要保存。

正确结构：

BEGIN
   ↓
Save Execution
   ↓
Save Result
   ↓
Save Feedback
   ↓
Save State
   ↓
Save Memory
   ↓
Save Experience
   ↓
Save Learning
   ↓
COMMIT

如果数据库操作失败：

ROLLBACK

因此：

Transaction=AtomicPersistenceTransaction = AtomicPersistence

---

213.35 保存后的验证

保存不是最后一步。

应该：

Save→ReadBack→Compare→VerifySave \rightarrow ReadBack \rightarrow Compare \rightarrow Verify

例如：

Memory:
state = running

执行：

UPDATE

之后重新读取：

Database:
state = running

比较：

MemoryState=DatabaseStateMemoryState=DatabaseState

才可以认为：

PersistenceVerified=truePersistenceVerified=true

因此：

SQLSuccess≠PersistenceVerifiedSQLSuccess \neq PersistenceVerified

---

213.36 数据读取后的验证

数据库中的数据也不能天然视为当前有效事实。

例如数据库中保存：

Capability:
available

但当前 Runtime 可能已经变成：

resource unavailable

因此：

PersistedFact≠CurrentFactPersistedFact \neq CurrentFact

读取之后仍然需要：

Load→Validate→CurrentStateCheckLoad \rightarrow Validate \rightarrow CurrentStateCheck

这与前面 CognitiveEngine 的原则一致：

历史持久化数据可以作为认知输入，但不能无条件覆盖当前事实。

---

213.37 持久化数据与历史数据

ICAI 必须保留变化历史。

例如：

states

保存当前状态：

running

而：

state_history

保存：

ready → running
running → failed
failed → recovering
recovering → running

因此：

Current+HistoryCurrent + History

共同构成完整的数据生命周期。

这对于：

• Memory；
• Experience；
• Diagnosis；
• Learning；
• Audit；
• Recovery；

都非常重要。

---

213.38 删除策略

ICAI 不建议无条件 Physical Delete。

数据删除可以分为：

Physical Delete

真正从数据库删除。

Logical Delete

增加：

deleted = 1

Archive

移动到历史/归档数据。

因此：

Delete≠DestroyHistoryDelete \neq DestroyHistory

尤其：

Decision
Execution
Feedback
Diagnosis
Repair
Learning

这类历史数据通常不应随意物理删除。

---

213.39 数据生命周期与认知生命周期的统一

最终可以把数据生命周期与 ICAI 认知生命周期连接起来：

ObjectCreated→ObjectLoaded→ObjectActive→ObjectChanged→Feedback→Memory→Experience→Learning→Update→PersistenceObjectCreated \rightarrow ObjectLoaded \rightarrow ObjectActive \rightarrow ObjectChanged \rightarrow Feedback \rightarrow Memory \rightarrow Experience \rightarrow Learning \rightarrow Update \rightarrow Persistence

更新后的数据再次：

Persistence→Load→Runtime→CognitiveEnginePersistence \rightarrow Load \rightarrow Runtime \rightarrow CognitiveEngine

由此形成：

Runtime→Persistence→Recovery→Runtime\boxed{ Runtime \rightarrow Persistence \rightarrow Recovery \rightarrow Runtime }

---

213.40 完整 ICAI 数据持久化闭环

ICAI 的数据流可以统一表示为：

                 ┌───────────────┐
                 │  MySQL Data   │
                 └───────┬───────┘
                         ↓
                  Persistence
                   Repository
                         ↓
                  Persistence Object
                         ↓
                     Hydration
                         ↓
                    Domain Object
                         ↓
                   Runtime Object
                         ↓
                 Cognitive Engine
                         ↓
             Service / Engine Processing
                         ↓
              Object / State / Relation
                         ↓
                Behavior / Execution
                         ↓
                     Result
                         ↓
                    Feedback
                         ↓
                 Memory / Experience
                         ↓
                     Learning
                         ↓
                  Update Candidate
                         ↓
                    UpdateEngine
                         ↓
                   Updated Object
                         ↓
                      Save
                         ↓
                 Persistence Object
                         ↓
                      MySQL

这形成完整闭环：

MySQL→Persistence→Runtime→Cognition→Execution→Learning→Update→Persistence\boxed{ MySQL \rightarrow Persistence \rightarrow Runtime \rightarrow Cognition \rightarrow Execution \rightarrow Learning \rightarrow Update \rightarrow Persistence }

---

213.41 ICAI 数据持久化的五层结构

最终可以把本章体系划分为五层。

第一层：Memory Object Layer

负责：

PHP Object
Runtime Object
Temporary Object
Context

第二层：Domain Layer

负责：

Individual
Object
State
Relation
Knowledge
Capability
Method
Behavior
Memory
Experience
Learning

第三层：Persistence Mapping Layer

负责：

Mapper
Hydration
Normalization
Change Detection
Version

第四层：Repository Layer

负责：

Insert
Update
Read
Delete
Exists
Transaction Support

第五层：Storage Layer

负责：

MySQL
Tables
Indexes
Constraints
Transactions

完整结构：

Memory→Domain→Mapping→Repository→StorageMemory \rightarrow Domain \rightarrow Mapping \rightarrow Repository \rightarrow Storage

---

213.42 ICAI 数据持久化核心公式

本章可以形成以下几个核心公式。

对象保存

MemoryObject→Validate→Map→Repository→Database\boxed{ MemoryObject \rightarrow Validate \rightarrow Map \rightarrow Repository \rightarrow Database }

对象读取

Database→Repository→Map→Validate→MemoryObject\boxed{ Database \rightarrow Repository \rightarrow Map \rightarrow Validate \rightarrow MemoryObject }

数据变化

ΔD=Compare(MemoryObject,PersistenceObject)\boxed{ \Delta D = Compare(MemoryObject,PersistenceObject) }

正式保存

CanSave=Identity∧ValidData∧ValidState∧ValidRelation∧Rule\boxed{ CanSave = Identity \land ValidData \land ValidState \land ValidRelation \land Rule }

保存验证

PersistenceVerified=Saved∧ReadBack∧Compared∧Valid\boxed{ PersistenceVerified = Saved \land ReadBack \land Compared \land Valid }

完整持久化闭环

Runtime→Persistence→Recovery→Runtime\boxed{ Runtime \rightarrow Persistence \rightarrow Recovery \rightarrow Runtime }

---

213.43 本章总结

ICAI 数据持久化体系解决的并不是单纯的“数据库保存问题”，而是：

如何让运行中的认知对象，在程序生命周期结束之后仍然能够被准确恢复，并继续参与下一次认知计算。

核心关系为：

MemoryObject↔PersistenceObjectMemoryObject \leftrightarrow PersistenceObject

其中：

概念	核心作用
内存对象	当前 PHP 运行中的对象
持久化对象	可以稳定保存的数据对象
数据生命周期	描述数据从创建到归档的完整过程
数据保存	将有效对象变化写入存储
数据读取	从存储恢复对象
Repository	负责持久化边界
Mapper	负责对象与持久化数据转换
Transaction	保证一组保存操作的一致性
Verification	验证数据是否真正保存并可恢复

最终 ICAI 不再是：

Program→DatabaseProgram \rightarrow Database

而是：

DomainObject↔RuntimeObject↔PersistenceObject↔Repository↔MySQL\boxed{ DomainObject \leftrightarrow RuntimeObject \leftrightarrow PersistenceObject \leftrightarrow Repository \leftrightarrow MySQL }

进一步与前面的认知体系连接：

Cognition→Execution→Feedback→Memory→Experience→Learning→Update→Persistence\boxed{ Cognition \rightarrow Execution \rightarrow Feedback \rightarrow Memory \rightarrow Experience \rightarrow Learning \rightarrow Update \rightarrow Persistence }

下一次系统启动时：

Persistence→Load→Hydration→Runtime→CognitiveEngine\boxed{ Persistence \rightarrow Load \rightarrow Hydration \rightarrow Runtime \rightarrow CognitiveEngine }

由此，ICAI 才真正具备跨请求、跨进程、跨运行周期保持自身对象、状态、关系、知识、能力、方法、记忆、经验和学习记录的工程基础。

数据持久化因此不是 ICAI 的附属数据库功能，而是连接：

Object+State+Knowledge+Memory+Experience+Learning+Runtime\boxed{ Object + State + Knowledge + Memory + Experience + Learning + Runtime }

与长期系统状态之间的基础设施。

其最终工程原则可以归纳为：

计算在内存，事实进入持久化，历史保持可追踪，读取必须可恢复，保存必须可验证。\boxed{ 计算在内存， 事实进入持久化， 历史保持可追踪， 读取必须可恢复， 保存必须可验证。 }

同时，Persistence Layer 本身不负责认知推理，不负责决策，不负责学习，也不负责修改认知规则。它只负责让经过 Service、Engine 和 Domain Object 处理后的合法数据获得可靠的长期存在能力。