第228章 ICAI核心数据表

228.1 核心数据表的定位

ICAI 的所有认知计算，都建立在一个最基础的数据事实体系之上。

在前面的章节中已经分别定义了：

• Individual：个体
• Object：对象
• Attribute：属性
• State：状态
• Relation：关系
• Scene：场景

这六类数据构成 ICAI 的基础认知数据层。

可以定义：

CoreData=Individual+Object+Attribute+State+Relation+SceneCoreData= Individual + Object + Attribute + State + Relation + Scene

其基本关系为：

Individual
    ↓
Object
    ↓
Attribute
    ↓
State
    ↓
Relation
    ↓
Scene

但这并不是简单的一条线性数据库关系。

实际上，六者构成的是一个多维结构：

                    Individual
                         │
              ┌──────────┴──────────┐
              ↓                     ↓
           Objects               Scenes
              │                     │
       ┌──────┼──────┐        ┌─────┼─────┐
       ↓      ↓      ↓        ↓     ↓     ↓
   Attributes States Relations Objects States Relations

因此：

Scene=F(Object,State,Relation,Condition,Environment,Time)Scene=F(Object,State,Relation,Condition,Environment,Time)

Scene 并不是简单复制 Objects。

---

228.2 Domain与数据库的对应关系

六个核心数据表必须遵循：

Domain Object
      ↓
Mapper
      ↓
Repository
      ↓
PDO
      ↓
MySQL

例如：

Object Domain
      ↓
ObjectMapper
      ↓
ObjectRepository
      ↓
objects

读取则相反：

objects
   ↓
PDO
   ↓
ObjectRepository
   ↓
ObjectMapper
   ↓
Object Domain

因此：

DomainObject≠DatabaseRowDomainObject\neq DatabaseRow

数据库只是 Domain Object 的持久化表示。

---

228.3 individuals——个体核心表

Individual 是 ICAI 的主体。

第166章已经定义：

I=(ID,T,A,S,C,M,B,MM,E)I=(ID,T,A,S,C,M,B,MM,E)

在组合体系中，一个 Individual 可以拥有：

Object
Knowledge
Capability
Method
Behavior
Memory
Experience
Relation
State

因此 individuals 只保存 Individual 的基础身份和当前核心状态。

---

228.3.1 individuals表设计

CREATE TABLE individuals (
    id BIGINT NOT NULL AUTO_INCREMENT,
    individual_code VARCHAR(100) NOT NULL,
    individual_type VARCHAR(100) NOT NULL,
    name VARCHAR(255) NULL,
    state VARCHAR(50) NOT NULL,
    description TEXT NULL,
    created_at DATETIME NOT NULL,
    updated_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_individual_code (individual_code),
    KEY idx_individual_type (individual_type),
    KEY idx_individual_state (state)
);

核心字段：

字段	含义
id	MySQL持久化ID
individual_code	Domain业务ID
individual_type	个体类型
name	个体名称
state	当前核心状态
description	描述
created_at	创建时间
updated_at	更新时间

其中：

DatabaseID≠DomainIDDatabaseID\neq DomainID

例如：

id = 15
individual_code = I-001

15 是数据库内部主键，I-001 是 ICAI Domain 层标识。

---

228.4 Individual与Object

Individual 与 Object 是 ICAI 最重要的组合关系之一。

Individual→ObjectIndividual\rightarrow Object

例如一个 Individual：

I-001

可以拥有：

O-001
O-002
O-003

数据库中：

individuals
      │
      │ 1:N
      ↓
objects

因此 objects.individual_id 可以保存所属 Individual 的数据库 ID。

但是这个关系不应该被理解为：

Object 永远只能属于 Individual。

因为未来可能存在系统级 Object。

因此：

individual_id = NULL

在特定设计下也是合法的。

---

228.5 objects——对象核心表

Object 是 ICAI 最基础的认知实体。

第167章定义：

O=(ID,T,A,S,R)O=(ID,T,A,S,R)

其中：

• IDID：对象标识
• TT：对象类型
• AA：对象属性
• SS：对象状态
• RR：对象关系

数据库不应该把所有内容全部塞入 objects。

应该进行结构拆分：

objects
   ├── attributes
   ├── states
   └── relations

---

228.5.1 objects表

CREATE TABLE objects (
    id BIGINT NOT NULL AUTO_INCREMENT,
    object_code VARCHAR(100) NOT NULL,
    individual_id BIGINT NULL,
    object_type VARCHAR(100) NOT NULL,
    name VARCHAR(255) NULL,
    state VARCHAR(50) NOT NULL,
    description TEXT NULL,
    created_at DATETIME NOT NULL,
    updated_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_object_code (object_code),
    KEY idx_object_individual (individual_id),
    KEY idx_object_type (object_type),
    KEY idx_object_state (state)
);

主要字段：

id
object_code
individual_id
object_type
name
state
description
created_at
updated_at

其中：

object_code

用于 Domain 层。

id

用于数据库内部关联。

---

228.6 Object不直接保存全部Attribute

Object模型中的：

A=AttributesA=Attributes

不应该理解为所有属性都必须作为 objects 的物理字段。

例如：

Object O-001

可能具有：

name = Device A
type = device
weight = 1200
capacity = 500
temperature = 35

如果这些属性全部作为数据库字段：

name
type
weight
capacity
temperature
...

随着系统扩展，objects 会不断增加字段。

因此将属性独立出来：

objects
    ↓
attributes

更适合 ICAI 的动态对象体系。

---

228.7 attributes——属性表

属性模型：

A=(N,V,T,S,Tm)A=(N,V,T,S,T_m)

其中：

• NN：属性名称
• VV：属性值
• TT：属性类型
• SS：属性状态
• TmT_m：属性时间

因此数据库：

CREATE TABLE attributes (
    id BIGINT NOT NULL AUTO_INCREMENT,
    attribute_code VARCHAR(100) NOT NULL,
    object_id BIGINT NOT NULL,
    attribute_name VARCHAR(100) NOT NULL,
    attribute_value TEXT NULL,
    attribute_type VARCHAR(50) NULL,
    state VARCHAR(50) NULL,
    attribute_time DATETIME NULL,
    created_at DATETIME NOT NULL,
    updated_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_attribute_code (attribute_code),
    KEY idx_attribute_object (object_id),
    KEY idx_attribute_name (attribute_name),
    KEY idx_attribute_type (attribute_type)
);

---

228.8 为什么Attribute必须独立

属性具有自己的生命周期。

例如：

temperature = 20

经过运行：

temperature = 35

再经过运行：

temperature = 48

这实际上形成：

At→At+1A_t\rightarrow A_{t+1}

属性不是永远不变的。

因此：

Object
    ↓
Attribute
    ↓
Attribute Change

可以进一步形成属性历史：

attribute_history

例如：

CREATE TABLE attribute_history (
    id BIGINT NOT NULL AUTO_INCREMENT,
    history_code VARCHAR(100) NOT NULL,
    attribute_code VARCHAR(100) NOT NULL,
    value_before TEXT NULL,
    value_after TEXT NULL,
    reason_data TEXT NULL,
    evidence TEXT NULL,
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_attribute_history_code (history_code),
    KEY idx_attribute_history_attribute (attribute_code),
    KEY idx_attribute_history_time (created_at)
);

因此：

CurrentAttribute≠AttributeHistoryCurrentAttribute\neq AttributeHistory

---

228.9 states——状态核心表

State 是 ICAI 运行过程中最重要的动态数据之一。

状态模型：

S=(O,V,T,C,R)S=(O,V,T,C,R)

其中：

• OO：状态所属对象
• VV：状态值
• TT：状态时间
• CC：状态上下文
• RR：状态原因

数据库保存当前状态：

CREATE TABLE states (
    id BIGINT NOT NULL AUTO_INCREMENT,
    state_code VARCHAR(100) NOT NULL,
    owner_type VARCHAR(100) NOT NULL,
    owner_id BIGINT NOT NULL,
    state_value VARCHAR(100) NOT NULL,
    context_data TEXT NULL,
    reason_data TEXT NULL,
    state_time DATETIME NOT NULL,
    created_at DATETIME NOT NULL,
    updated_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_state_code (state_code),
    KEY idx_state_owner (owner_type, owner_id),
    KEY idx_state_value (state_value),
    KEY idx_state_time (state_time)
);

---

228.10 State为什么使用owner_type + owner_id

ICAI 中不仅 Object 有状态。

以下对象都可能具有状态：

Individual
Object
Goal
Capability
Method
Decision
Behavior
Action
Execution
Relation
Risk
Conflict
Diagnosis
Repair

因此如果建立：

object_id

就无法支持完整的 ICAI。

采用：

owner_type
owner_id

可以表达：

owner_type = object
owner_id = 10

也可以：

owner_type = behavior
owner_id = 25

或者：

owner_type = execution
owner_id = 31

这是一种多 Domain 状态持久化设计。

---

228.11 Current State与State History

必须严格区分：

states

和：

state_history

当前状态：

Object O-001
state = ready

历史：

created
→ ready
→ running
→ failed
→ repairing
→ ready

数据库：

states
    ↓
当前状态

state_history
    ↓
完整变化过程

因此：

CurrentState≠StateHistoryCurrentState\neq StateHistory

---

228.12 state_history

CREATE TABLE state_history (
    id BIGINT NOT NULL AUTO_INCREMENT,
    history_code VARCHAR(100) NOT NULL,
    owner_type VARCHAR(100) NOT NULL,
    owner_id BIGINT NOT NULL,
    state_before VARCHAR(100) NULL,
    state_after VARCHAR(100) NOT NULL,
    event_data TEXT NULL,
    condition_data TEXT NULL,
    reason_data TEXT NULL,
    evidence TEXT NULL,
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_state_history_code (history_code),
    KEY idx_state_history_owner (owner_type, owner_id),
    KEY idx_state_history_time (created_at)
);

StateEngine计算：

T(St,E,C)→St+1T(S_t,E,C)\rightarrow S_{t+1}

StateRepository保存：

S_t
S_{t+1}

以及：

StateHistory

---

228.13 relations——关系核心表

Relation模型：

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

其中：

• O1O_1：源对象
• TT：关系类型
• O2O_2：目标对象
• CC：关系条件
• SS：关系状态
• TmT_m：关系时间

核心数据库：

CREATE TABLE relations (
    id BIGINT NOT NULL AUTO_INCREMENT,
    relation_code VARCHAR(100) NOT NULL,
    object1_id BIGINT NOT NULL,
    relation_type VARCHAR(100) NOT NULL,
    object2_id BIGINT NOT NULL,
    condition_data TEXT NULL,
    state VARCHAR(50) NOT NULL,
    evidence TEXT NULL,
    relation_time DATETIME NULL,
    created_at DATETIME NOT NULL,
    updated_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_relation_code (relation_code),
    KEY idx_relation_object1 (object1_id),
    KEY idx_relation_object2 (object2_id),
    KEY idx_relation_type (relation_type),
    KEY idx_relation_state (state)
);

---

228.14 Relation的方向性

Relation必须具有明确方向。

例如：

Object A
   |
   | supports
   ↓
Object B

数据库：

object1_id = A
relation_type = supports
object2_id = B

不能自动转换成：

B supports A

除非规则明确规定：

supports
    ↔
supported_by

因此：

RelationDirectionRelationDirection

是关系数据的重要组成部分。

---

228.15 Relation存在不等于Relation有效

数据库中存在：

relation_code = R-001

不代表该关系一定有效。

必须区分：

Exists
Active
Valid
Verified

因此：

Exists≠ValidExists\neq Valid

RelationEngine负责：

关系计算
关系匹配
关系合法性判断
关系更新候选

Repository负责：

保存
查询
更新

---

228.16 relations与Object的关系

Object模型：

O=(ID,T,A,S,R)O=(ID,T,A,S,R)

其中的 RR 就是 Object 参与的关系集合。

因此：

Object A
   ↓
Relations
   ↓
Object B

形成：

Object→Relation→ObjectObject \rightarrow Relation \rightarrow Object

数据库可以形成对象网络：

O1 ──supports────→ O2
 │                  │
 │uses              │located_in
 ↓                  ↓
O3 ───────────────→ O4

这个网络是后续：

KnowledgeEngine
SceneEngine
MatchingEngine
DecisionEngine

计算的重要基础。

---

228.17 scenes——场景核心表

Scene不是简单的Object集合。

第190章定义：

Sc=(ID,T,O,S,R,C,E,Tm)Sc=(ID,T,O,S,R,C,E,T_m)

其中：

• IDID：场景标识
• TT：场景类型
• OO：场景对象集合
• SS：场景状态集合
• RR：场景关系集合
• CC：场景条件
• EE：环境
• TmT_m：时间

Scene的核心本质是：

在特定条件、环境和时间下，由一组对象、状态和关系形成的可计算结构。

---

228.18 Scene不能简单放进一个JSON

例如：

Scene
{
    objects: [...]
    states: [...]
    relations: [...]
}

虽然可以作为计算结果暂存，但不能把它作为唯一数据库结构。

因为 Scene 中的：

Object
State
Relation

本身都是独立 Domain。

因此应该：

scenes
    ↓
scene_objects
scene_states
scene_relations

而不是：

scenes.scene_data = 全部对象

---

228.19 scenes表

CREATE TABLE scenes (
    id BIGINT NOT NULL AUTO_INCREMENT,
    scene_code VARCHAR(100) NOT NULL,
    scene_type VARCHAR(100) NOT NULL,
    name VARCHAR(255) NULL,
    condition_data TEXT NULL,
    environment_data TEXT NULL,
    state VARCHAR(50) NOT NULL,
    scene_time DATETIME NOT NULL,
    created_at DATETIME NOT NULL,
    updated_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_scene_code (scene_code),
    KEY idx_scene_type (scene_type),
    KEY idx_scene_state (state),
    KEY idx_scene_time (scene_time)
);

---

228.20 scene_objects

Scene与Object是多对多关系。

CREATE TABLE scene_objects (
    id BIGINT NOT NULL AUTO_INCREMENT,
    scene_id BIGINT NOT NULL,
    object_id BIGINT NOT NULL,
    role_type VARCHAR(100) NULL,
    state VARCHAR(50) NULL,
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_scene_object (scene_id, object_id),
    KEY idx_scene_objects_scene (scene_id),
    KEY idx_scene_objects_object (object_id)
);

例如：

Scene S-001
   ├── Object O-001
   ├── Object O-002
   └── Object O-003

不同 Object 在 Scene 中可以具有不同角色：

subject
target
resource
environment
tool
obstacle

---

228.21 scene_states

场景中的状态不是简单复制 Object 当前状态。

因为 Scene 是时间和条件相关的认知结构。

因此：

CREATE TABLE scene_states (
    id BIGINT NOT NULL AUTO_INCREMENT,
    scene_id BIGINT NOT NULL,
    owner_type VARCHAR(100) NOT NULL,
    owner_id BIGINT NOT NULL,
    state_value VARCHAR(100) NOT NULL,
    context_data TEXT NULL,
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    KEY idx_scene_state_scene (scene_id),
    KEY idx_scene_state_owner (owner_type, owner_id)
);

例如：

Scene S-001
    ↓
Object O-001
    ↓
State = running

这个状态属于该 Scene 下的状态事实。

---

228.22 scene_relations

场景也可以保存当前场景中的关系。

CREATE TABLE scene_relations (
    id BIGINT NOT NULL AUTO_INCREMENT,
    scene_id BIGINT NOT NULL,
    relation_id BIGINT NOT NULL,
    state VARCHAR(50) NULL,
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_scene_relation (scene_id, relation_id),
    KEY idx_scene_relation_scene (scene_id),
    KEY idx_scene_relation_relation (relation_id)
);

这样 Scene 可以引用已经存在的 Relation。

因此：

Scene
   ↓
Relation
   ↓
Object

而不是重复创建另一套 Object。

---

228.23 Scene的计算来源

SceneEngine的核心计算：

Sc=F(O,S,R,C,Env,T)Sc=F(O,S,R,C,Env,T)

其中：

• OO：当前对象事实
• SS：当前状态事实
• RR：当前关系事实
• CC：条件
• EnvEnv：环境
• TT：时间

因此：

Object Facts
      ↓
State Facts
      ↓
Relation Facts
      ↓
Condition
      ↓
Environment
      ↓
Time
      ↓
SceneEngine
      ↓
Scene Calculation

数据库中的 Scene 是持久化后的结构。

SceneEngine 才负责场景计算。

---

228.24 六个核心表之间的总体关系

完整数据库关系可以表示为：

individuals
     │
     │ 1:N
     ↓
objects
     │
     ├────────→ attributes
     │
     ├────────→ states
     │
     └────────→ relations
                    ↑
                    │
              object ←→ object

objects
   │
   ↓
scene_objects
   │
   ↓
scenes
   │
   ├────→ scene_states
   │
   └────→ scene_relations

---

228.25 六个核心Domain的关系

从 Domain 角度：

I→OI\rightarrow O

表示：

Individual拥有Object

O→AO\rightarrow A

表示：

Object具有Attribute

O→SO\rightarrow S

表示：

Object具有State

O1→R→O2O_1\rightarrow R\rightarrow O_2

表示：

Object之间存在Relation

O+S+R+C+Env+T→ScO+S+R+C+Env+T\rightarrow Sc

表示：

Objects + States + Relations
在条件、环境、时间下
形成Scene

---

228.26 六个核心表不是六个独立系统

不能设计成：

Individual System
Object System
Attribute System
State System
Relation System
Scene System

完全互相隔离。

它们实际上构成 ICAI 的底层数据基础。

正确结构：

                    Individual
                         │
                         ↓
                       Object
                    ↙    ↓    ↘
              Attribute State Relation
                         │       │
                         └───┬───┘
                             ↓
                           Scene

Scene是对当前对象、状态、关系及环境条件的组合性认知结果。

---

228.27 PHP Domain结构

对应的 PHP Domain 可以设计为：

class Individual
{
    protected $id;
    protected $type;
    protected $name;
    protected $state;

    protected $objects;
}

Object：

class ObjectEntity
{
    protected $id;
    protected $type;
    protected $name;
    protected $attributes;
    protected $state;
    protected $relations;
}

Attribute：

class Attribute
{
    protected $id;
    protected $name;
    protected $value;
    protected $type;
    protected $state;
    protected $time;
}

State：

class State
{
    protected $id;
    protected $ownerType;
    protected $ownerId;
    protected $value;
    protected $context;
    protected $reason;
    protected $time;
}

Relation：

class Relation
{
    protected $id;
    protected $object1Id;
    protected $type;
    protected $object2Id;
    protected $condition;
    protected $state;
    protected $time;
}

Scene：

class Scene
{
    protected $id;
    protected $type;
    protected $objects;
    protected $states;
    protected $relations;
    protected $condition;
    protected $environment;
    protected $time;
}

这些是 Domain Object。

它们不是数据库 Row。

---

228.28 Mapper映射

对应 Mapper：

IndividualMapper
ObjectMapper
AttributeMapper
StateMapper
RelationMapper
SceneMapper

例如：

class ObjectMapper
{
    public function toPersistence($object)
    {
        return array(
            'object_code'   => $object->getId(),
            'object_type'   => $object->getType(),
            'name'          => $object->getName(),
            'state'         => $object->getState()
        );
    }
}

反向：

class ObjectMapper
{
    public function toDomain($row)
    {
        return new ObjectEntity(
            $row['object_code'],
            $row['object_type'],
            $row['name'],
            $row['state']
        );
    }
}

实际工程中可以根据现有 Domain 构造方式调整。

核心原则是：

Mapper=Domain↔PersistenceMapper=Domain\leftrightarrow Persistence

---

228.29 Repository对应关系

六个核心 Domain 对应：

Individual
    ↓
IndividualRepository

Object
    ↓
ObjectRepository

Attribute
    ↓
AttributeRepository

State
    ↓
StateRepository

Relation
    ↓
RelationRepository

Scene
    ↓
SceneRepository

调用关系：

Service
   ↓
Repository
   ↓
Mapper
   ↓
MySQL

如果某个 Repository 需要多个表，可以协调这些表，但不应该把 Engine 的计算逻辑放进去。

---

228.30 Engine与核心表的关系

核心 Engine：

ObjectEngine
StateEngine
RelationEngine
SceneEngine

它们分别负责：

ObjectEngine
    → Object计算

StateEngine
    → State计算

RelationEngine
    → Relation计算

SceneEngine
    → Scene计算

因此：

ObjectEngine≠ObjectRepositoryObjectEngine\neq ObjectRepository StateEngine≠StateRepositoryStateEngine\neq StateRepository RelationEngine≠RelationRepositoryRelationEngine\neq RelationRepository SceneEngine≠SceneRepositorySceneEngine\neq SceneRepository

---

228.31 一次完整核心认知计算

假设系统读取一个 Individual。

首先：

IndividualRepository
        ↓
Individual

读取其 Objects：

ObjectRepository
        ↓
Objects

读取属性：

AttributeRepository
        ↓
Attributes

读取状态：

StateRepository
        ↓
States

读取关系：

RelationRepository
        ↓
Relations

然后进入 CognitiveEngine：

Individual
+
Object Facts
+
Attribute Facts
+
State Facts
+
Relation Facts
+
Condition
+
Environment
+
Time

进入：

ObjectEngine
    ↓
StateEngine
    ↓
RelationEngine
    ↓
SceneEngine

形成：

Object Result
State Result
Relation Result
Scene Result

最后进入 KnowledgeEngine 等后续认知计算。

---

228.32 核心数据读取顺序

一个合理的读取顺序是：

Individual→Object→Attribute→State→Relation→SceneIndividual \rightarrow Object \rightarrow Attribute \rightarrow State \rightarrow Relation \rightarrow Scene

但这只是 Repository 的数据准备顺序。

真正的 Engine 计算顺序应根据依赖关系：

Object→State→Relation→SceneObject \rightarrow State \rightarrow Relation \rightarrow Scene

原因是：

Scene=F(O,S,R,C,Env,T)Scene=F(O,S,R,C,Env,T)

Scene依赖 Object、State、Relation。

---

228.33 核心数据更新顺序

当运行结果产生变化：

Execution
    ↓
Result
    ↓
Feedback
    ↓
State Change

之后：

StateEngine
    ↓
Candidate State
    ↓
Verification
    ↓
UpdateEngine
    ↓
StateRepository

然后可能重新计算：

Relation
    ↓
Scene
    ↓
Knowledge
    ↓
Capability
    ↓
Method
    ↓
Decision

因此核心数据更新不是简单的：

UPDATE objects

而是一个受规则和验证约束的数据变化过程。

---

228.34 核心数据完整生命周期

六类核心数据可以统一表示为：

Create→Load→Calculate→Validate→Verify→Update→History→ArchiveCreate \rightarrow Load \rightarrow Calculate \rightarrow Validate \rightarrow Verify \rightarrow Update \rightarrow History \rightarrow Archive

例如 Object：

Create Object
     ↓
Save
     ↓
Load
     ↓
Calculate
     ↓
State Change
     ↓
Verify
     ↓
Update
     ↓
Object History

Relation：

Calculate Relation
     ↓
Validate
     ↓
Verify
     ↓
Save
     ↓
Update
     ↓
Relation History

Scene：

Object + State + Relation
     ↓
SceneEngine
     ↓
Scene Result
     ↓
Verify
     ↓
SceneRepository
     ↓
Scene

---

228.35 核心数据与历史数据

六个核心表并不意味着历史都放在核心表。

例如：

objects

保存当前 Object。

object_history

保存 Object 变化。

同样：

states
state_history

relations
relation_history

scenes
scene_history

因此：

CurrentData+HistoryDataCurrentData+HistoryData

共同形成完整生命周期。

---

228.36 六个核心数据的最小数据库结构

如果第一阶段只建立最小核心数据库，可以先建立：

individuals
objects
attributes
states
relations
scenes
scene_objects
scene_states
scene_relations
state_history

其中：

individuals
objects
attributes
states
relations
scenes

是六个核心主表。

而：

scene_objects
scene_states
scene_relations
state_history

属于核心关联/历史支撑表。

---

228.37 核心数据库结构总图

最终可以形成：

┌───────────────────────┐
│      individuals      │
│       个体核心表       │
└───────────┬───────────┘
            │
            ↓
┌───────────────────────┐
│        objects        │
│       对象核心表       │
└──────┬────┬────┬──────┘
       │    │    │
       ↓    ↓    ↓
 attributes states relations
       │    │    │
       │    ↓    │
       │ state   │
       │ history │
       │         │
       └────┬────┘
            ↓
┌───────────────────────┐
│        scenes         │
│       场景核心表       │
└──────┬────┬────┬──────┘
       ↓    ↓    ↓
 scene_objects
 scene_states
 scene_relations

---

228.38 核心数据与认知计算的关系

六个核心数据最终进入 ICAI 的认知计算链：

Individual→Object→State→Relation→Scene→KnowledgeIndividual \rightarrow Object \rightarrow State \rightarrow Relation \rightarrow Scene \rightarrow Knowledge

随后进入：

Knowledge→Capability→Matching→Method→DecisionKnowledge \rightarrow Capability \rightarrow Matching \rightarrow Method \rightarrow Decision

再进入：

Decision→Behavior→Action→ExecutionDecision \rightarrow Behavior \rightarrow Action \rightarrow Execution

形成：

Execution→Result→FeedbackExecution \rightarrow Result \rightarrow Feedback

最终反馈到：

State+Memory+Experience+Learning+UpdateState + Memory + Experience + Learning + Update

从而再次形成新的：

Object
State
Relation
Scene

因此核心数据库实际上处于 ICAI 整体认知循环的最底层。

---

228.39 核心原则

第一：

Individual≠ObjectIndividual\neq Object

Individual 是主体，Object 是被认知和操作的对象。

第二：

Object≠AttributeObject\neq Attribute

Object 是实体，Attribute 是实体的特征。

第三：

Attribute≠StateAttribute\neq State

Attribute 描述对象特征，State 描述对象当前运行状态。

第四：

Object≠RelationObject\neq Relation

Relation 表达对象之间的结构关系。

第五：

Scene≠ObjectScene\neq Object

Scene 是对象、状态、关系在条件、环境和时间下形成的组合认知结构。

第六：

CurrentState≠StateHistoryCurrentState\neq StateHistory

当前状态和历史状态必须分离。

第七：

Domain≠DatabaseDomain\neq Database

Domain Object 不能直接等同于数据库 Row。

第八：

Repository≠EngineRepository\neq Engine

Repository 保存和查询，Engine 计算和判断。

---

228.40 本章总结

第228章建立了 ICAI 最基础的六个核心数据实体：

Individual+Object+Attribute+State+Relation+Scene\boxed{ Individual + Object + Attribute + State + Relation + Scene }

其中：

Individual→ObjectIndividual\rightarrow Object

建立个体与对象之间的主体关系；

Object→AttributeObject\rightarrow Attribute

建立对象与属性之间的结构关系；

Object→StateObject\rightarrow State

建立对象与当前运行状态之间的关系；

Object1→Relation→Object2Object_1\rightarrow Relation\rightarrow Object_2

建立对象之间的显式关系；

最终：

Scene=F(Object,State,Relation,Condition,Environment,Time)Scene=F(Object,State,Relation,Condition,Environment,Time)

形成场景。

数据库层：

individuals
objects
attributes
states
relations
scenes

配合：

scene_objects
scene_states
scene_relations
state_history

形成 ICAI 的核心数据基础。

完整工程链为：

Domain→Mapper→Repository→PDO→MySQL\boxed{ Domain \rightarrow Mapper \rightarrow Repository \rightarrow PDO \rightarrow MySQL }

而认知计算链为：

Object→State→Relation→Scene→Knowledge\boxed{ Object \rightarrow State \rightarrow Relation \rightarrow Scene \rightarrow Knowledge }

这意味着 ICAI 的认知体系首先建立在真实、可保存、可查询、可验证、可追踪的结构化数据事实之上，再由各级 Engine 对这些事实进行离散计算、规则判断、状态转换、关系计算和场景计算，而不是把数据库本身当成智能计算主体。