第219章　KnowledgeRepository

219.1 KnowledgeRepository定义

在 ICAI 系统中，Object、State、Relation 解决的是对象、状态以及对象之间关系的结构化表达。

在此基础上，系统还需要保存能够被后续认知计算使用的知识事实。

因此建立：

$KnowledgeRepositoryKnowledgeRepository$

KnowledgeRepository 是 Knowledge Domain Object 与持久化系统之间的边界，负责知识的保存、查询和更新。

其核心模型为：

$KR=(K,M,Q,U,P,T)KR=(K,M,Q,U,P,T)$

其中：

$KK$ ：Knowledge，知识对象；
$MM$ ：Mapping，知识对象与数据库数据之间的映射；
$QQ$ ：Query，知识查询；
$UU$ ：Update，知识更新；
$PP$ ：Persistence，知识持久化；
$TT$ ：Time，操作时间。

因此：

$KnowledgeRepository=KnowledgeSave+KnowledgeQuery+KnowledgeUpdate\boxed{ KnowledgeRepository = KnowledgeSave + KnowledgeQuery + KnowledgeUpdate }$

基本结构：

Knowledge Domain Object
        ↓
KnowledgeRepository
        ↓
KnowledgeMapper
        ↓
PDO
        ↓
MySQL

读取方向：

MySQL
   ↓
PDO
   ↓
KnowledgeRepository
   ↓
KnowledgeMapper
   ↓
Knowledge Domain Object

219.2 Knowledge领域对象

前面的 KnowledgeService 与 KnowledgeEngine 已经定义：

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

其中：

$SS$ ：Subject，知识主体；
$PP$ ：Predicate，知识谓词；
$OO$ ：Object，知识客体；
$CC$ ：Condition，知识成立条件；
$StS_t$ ：Knowledge State，知识状态。

例如：

Object-A
    ↓
supports
    ↓
Method-M1

可以表示：

$K=(Object-A,supports,Method-M1,C,St)K=(Object\text{-}A,supports,Method\text{-}M1,C,S_t)$

知识不是简单的一段文字。

在 ICAI 中，知识首先是可以被计算、匹配、验证和更新的结构化认知对象。

因此：

$Knowledge≠TextKnowledge\neq Text$

同时：

$Knowledge≠MySQL RecordKnowledge\neq MySQL\ Record$

数据库记录只是 Knowledge 的持久化形式。

219.3 KnowledgeRepository与KnowledgeEngine

这是本章最重要的职责边界。

KnowledgeEngine负责：

知识计算
知识匹配
知识推导
知识条件判断
知识验证
知识更新候选计算

KnowledgeRepository负责：

知识保存
知识查询
知识读取
知识更新

因此：

$KnowledgeEngine=KnowledgeCalculationKnowledgeEngine=KnowledgeCalculation$

而：

$KnowledgeRepository=KnowledgePersistenceKnowledgeRepository=KnowledgePersistence$

正确结构：

Facts
Rules
Conditions
Relations
States
      ↓
KnowledgeEngine
      ↓
Knowledge Candidate
      ↓
Verification
      ↓
UpdateEngine
      ↓
KnowledgeRepository
      ↓
MySQL

Repository 不应该自己进行知识推理。

例如：

$supports(A,B)∧supports(B,C)→supports(A,C)supports(A,B) \land supports(B,C) \rightarrow supports(A,C)$

这个计算属于 KnowledgeEngine。

Repository 只负责保存最终被允许持久化的知识事实。

219.4 知识保存

知识保存的基本流程：

Knowledge
   ↓
Validate
   ↓
Map
   ↓
Check Existing
   ↓
Insert
   ↓
ReadBack
   ↓
Verify

公式：

$Save(K)→Validate→Map→Persist→VerifySave(K) \rightarrow Validate \rightarrow Map \rightarrow Persist \rightarrow Verify$

这里的 Verify 是持久化验证，不等于知识内容本身的推理。

219.5 知识保存条件

知识保存至少需要检查：

$ValidKnowledge=Subject∧Predicate∧Object∧Condition∧Rule∧EvidenceValidKnowledge = Subject \land Predicate \land Object \land Condition \land Rule \land Evidence$

其中：

Subject：主体合法；
Predicate：谓词合法；
Object：客体合法；
Condition：成立条件合法；
Rule：允许形成该知识；
Evidence：存在依据。

但是必须进一步区分：

$KnowledgeExists≠KnowledgeValidKnowledgeExists \neq KnowledgeValid$

以及：

$KnowledgeValid≠KnowledgeVerifiedKnowledgeValid \neq KnowledgeVerified$

因此知识可以存在以下状态：

candidate
valid
verified
unverified
outdated
invalid
conflicted
archived

219.6 知识状态

Knowledge State 是知识生命周期的一部分。

例如：

candidate
    ↓
valid
    ↓
verified

异常路径：

verified
    ↓
outdated

或者：

verified
    ↓
conflicted

最终：

archived

因此：

$SK∈{candidate,valid,verified,unverified,outdated,invalid,conflicted,archived}S_K\in \{ candidate, valid, verified, unverified, outdated, invalid, conflicted, archived \}$

KnowledgeRepository 保存状态。

但状态如何变化，应由 KnowledgeEngine、Verification、UpdateEngine 等组件计算或确认。

219.7 知识查询

KnowledgeRepository 的第二项核心职责是查询。

基本模型：

$Query(C)→{K1,K2,…,Kn}Query(C)\rightarrow\{K_1,K_2,\ldots,K_n\}$

其中：

$CC$ ：查询条件；
$KiK_i$ ：查询得到的 Knowledge Object。

常见查询：

按照知识ID查询
按照Subject查询
按照Predicate查询
按照Object查询
按照Subject + Predicate查询
按照Predicate + Object查询
按照状态查询
按照条件查询
按照时间查询

219.8 按ID查询

$findById(ID)→KfindById(ID)\rightarrow K$

PHP：

public function findById($id)
{
    $sql = "
        SELECT *
        FROM knowledge
        WHERE id = :id
        LIMIT 1
    ";

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

    $stmt->execute(array(
        ':id' => $id
    ));

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

    if (!$data) {
        return null;
    }

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

Repository 返回 Knowledge Domain Object，而不是直接把数据库数组向上层无限传播。

219.9 按Subject查询

例如：

Object-A
   ↓
所有相关知识

表示：

$Query(S=Object-A)Query(S=Object\text{-}A)$

PHP：

public function findBySubject($subject)
{
    $sql = "
        SELECT *
        FROM knowledge
        WHERE subject = :subject
        ORDER BY id ASC
    ";

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

    $stmt->execute(array(
        ':subject' => $subject
    ));

    return $this->mapRows($stmt);
}

这可以让 KnowledgeEngine 获得某个对象相关的知识集合。

219.10 按Predicate查询

例如：

supports
uses
depends_on
contains
located_in
belongs_to

可以：

$Query(P)→{K}Query(P)\rightarrow\{K\}$

PHP：

public function findByPredicate($predicate)
{
    $sql = "
        SELECT *
        FROM knowledge
        WHERE predicate = :predicate
        ORDER BY id ASC
    ";

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

    $stmt->execute(array(
        ':predicate' => $predicate
    ));

    return $this->mapRows($stmt);
}

219.11 按Subject与Predicate查询

这是知识查询中非常重要的一种方式：

$Query(S,P)→{K}Query(S,P)\rightarrow\{K\}$

例如：

Subject = Object-A
Predicate = supports

查询：

Object-A
    ↓
supports
    ↓
Knowledge Objects

PHP：

public function findBySubjectAndPredicate($subject, $predicate)
{
    $sql = "
        SELECT *
        FROM knowledge
        WHERE subject = :subject
        AND predicate = :predicate
        ORDER BY id ASC
    ";

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

    $stmt->execute(array(
        ':subject' => $subject,
        ':predicate' => $predicate
    ));

    return $this->mapRows($stmt);
}

219.12 按Predicate与Object查询

也可以反向查询：

$Query(P,O)→{K}Query(P,O)\rightarrow\{K\}$

例如：

supports
    ↓
Method-M1

查询所有支持 Method-M1 的知识。

public function findByPredicateAndObject($predicate, $object)
{
    $sql = "
        SELECT *
        FROM knowledge
        WHERE predicate = :predicate
        AND object_value = :object_value
        ORDER BY id ASC
    ";

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

    $stmt->execute(array(
        ':predicate' => $predicate,
        ':object_value' => $object
    ));

    return $this->mapRows($stmt);
}

219.13 三元知识查询

如果知识结构：

$(S,P,O)(S,P,O)$

完整查询：

$Query(S,P,O)→KQuery(S,P,O)\rightarrow K$

例如：

Object-A
supports
Method-M1

可以形成：

$(Object-A,supports,Method-M1)(Object\text{-}A,supports,Method\text{-}M1)$

PHP：

public function findByTriple($subject, $predicate, $object)
{
    $sql = "
        SELECT *
        FROM knowledge
        WHERE subject = :subject
        AND predicate = :predicate
        AND object_value = :object_value
        LIMIT 1
    ";

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

    $stmt->execute(array(
        ':subject' => $subject,
        ':predicate' => $predicate,
        ':object_value' => $object
    ));

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

    if (!$data) {
        return null;
    }

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

219.14 知识状态查询

可以查询：

$Query(St)→{K}Query(S_t)\rightarrow\{K\}$

例如：

public function findByState($state)
{
    $sql = "
        SELECT *
        FROM knowledge
        WHERE state = :state
        ORDER BY id ASC
    ";

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

    $stmt->execute(array(
        ':state' => $state
    ));

    return $this->mapRows($stmt);
}

这样可以分别读取：

verified
outdated
conflicted
candidate

等知识集合。

219.15 知识查询不等于知识判断

这是 Repository 必须保持的边界。

例如 Repository 查询：

Object-A
supports
Method-M1

只能说明数据库中存在这一知识记录。

KnowledgeEngine 还需要判断：

当前条件是否成立？
当前状态是否仍然适用？
知识是否过期？
是否存在冲突？
是否有更高优先级知识？

因此：

$Query(K)≠Evaluate(K)Query(K)\neq Evaluate(K)$

完整流程：

KnowledgeRepository
       ↓
Load Knowledge
       ↓
KnowledgeEngine
       ↓
Condition Evaluation
       ↓
Matching
       ↓
Verification
       ↓
Knowledge Result

219.16 知识更新

知识更新模型：

$Kt+ΔK→Kt+1K_t+\Delta K\rightarrow K_{t+1}$

其中：

$KtK_t$ ：当前知识；
$ΔK\Delta K$ ：经过计算和验证的知识变化；
$Kt+1K_{t+1}$ ：更新后的知识。

例如：

原知识：

$Kt:Method-M1requiresResource≥1K_t: Method\text{-}M1 requires Resource\geq1$

实际执行以后发现：

$Resource≥2Resource\geq2$

经过 Diagnosis、Experience、Learning 和 Verification 后形成：

$ΔK:Resource≥1→Resource≥2\Delta K: Resource\geq1 \rightarrow Resource\geq2$

然后 UpdateEngine 将变化正式应用。

219.17 KnowledgeRepository不决定知识更新

正确架构：

Execution
   ↓
Result
   ↓
Feedback
   ↓
Diagnosis / Experience
   ↓
LearningEngine
   ↓
Knowledge Update Candidate
   ↓
Verification
   ↓
UpdateEngine
   ↓
KnowledgeRepository
   ↓
MySQL

因此：

$LearningEngine≠KnowledgeRepositoryLearningEngine \neq KnowledgeRepository$

并且：

$KnowledgeRepository≠KnowledgeEngineKnowledgeRepository \neq KnowledgeEngine$

三者分别承担：

KnowledgeEngine
    → 计算知识

LearningEngine
    → 计算应该学习什么

KnowledgeRepository
    → 保存已经确认的数据

219.18 知识最小更新原则

知识更新不能无条件覆盖。

例如：

K1:
Object-A supports Method-M1

如果只是知识状态变化：

$verified→outdatedverified\rightarrow outdated$

那么：

$ΔK=ΔSt\Delta K=\Delta S_t$

只更新状态。

如果只是 Condition 改变：

$ΔK=ΔC\Delta K=\Delta C$

只更新 Condition。

因此：

$Kt+ΔK→Kt+1\boxed{ K_t+\Delta K\rightarrow K_{t+1} }$

只修改实际发生变化且已经验证的字段。

219.19 知识更新条件

可以定义：

$CanUpdateKnowledge=ValidChange∧Condition∧Rule∧VerificationCanUpdateKnowledge = ValidChange \land Condition \land Rule \land Verification$

其中：

ValidChange：确实发生变化；
Condition：当前更新条件成立；
Rule：知识更新规则允许；
Verification：变化已经验证。

因此：

只有发现变化

并不意味着：

可以立即更新知识

必须经过验证。

219.20 知识冲突

知识之间可能发生冲突。

例如：

$K1:M1 requires Resource≥1K_1: M1\ requires\ Resource\geq1$

同时：

$K2:M1 requires Resource≥2K_2: M1\ requires\ Resource\geq2$

这并不能直接由 Repository 判断哪一个正确。

Repository 只能保存：

K1
K2

以及它们的状态。

ConflictEngine / KnowledgeEngine 负责计算：

K1
   ↕
Conflict
   ↕
K2

然后通过 Diagnosis、Decision、Learning、Update 等机制处理。

因此：

$KnowledgeConflict≠RepositoryErrorKnowledgeConflict \neq RepositoryError$

219.21 知识历史

知识变化需要保留历史。

可以建立：

knowledge_history

历史模型：

$KH=(K,Sb,Sa,ΔK,R,T)KH=(K,S_b,S_a,\Delta K,R,T)$

其中：

$KK$ ：知识对象；
$SbS_b$ ：更新前状态；
$SaS_a$ ：更新后状态；
$ΔK\Delta K$ ：知识变化；
$RR$ ：变化原因；
$TT$ ：变化时间。

例如：

Knowledge K1

Resource >= 1
      ↓
Learning
      ↓
Verification
      ↓
Resource >= 2

历史记录：

before:
Resource >= 1

after:
Resource >= 2

reason:
Verified Execution Feedback

这样能够追踪知识为什么改变。

219.22 KnowledgeMapper

KnowledgeMapper负责 Domain Object 与 Persistence Data 之间转换。

class KnowledgeMapper
{
    public function toPersistence($knowledge)
    {
        return array(
            'id' => $knowledge->getId(),
            'subject' => $knowledge->getSubject(),
            'predicate' => $knowledge->getPredicate(),
            'object_value' => $knowledge->getObject(),
            'condition' => $knowledge->getCondition(),
            'state' => $knowledge->getState()
        );
    }

    public function toDomain($data)
    {
        $knowledge = new Knowledge();

        $knowledge->setId($data['id']);
        $knowledge->setSubject($data['subject']);
        $knowledge->setPredicate($data['predicate']);
        $knowledge->setObject($data['object_value']);
        $knowledge->setCondition($data['condition']);
        $knowledge->setState($data['state']);

        return $knowledge;
    }
}

Mapper只负责映射。

它不负责：

知识推理
知识评分
知识冲突分析
知识学习
知识决策

219.23 KnowledgeRepository接口

兼容 PHP 5.6 / PHP 7：

interface KnowledgeRepositoryInterface
{
    public function findById($id);

    public function findBySubject($subject);

    public function findByPredicate($predicate);

    public function findBySubjectAndPredicate(
        $subject,
        $predicate
    );

    public function findByPredicateAndObject(
        $predicate,
        $object
    );

    public function findByTriple(
        $subject,
        $predicate,
        $object
    );

    public function findByState($state);

    public function save($knowledge);

    public function update($knowledge);

    public function exists(
        $subject,
        $predicate,
        $object
    );
}

该接口将知识持久化操作标准化。

219.24 MySQLKnowledgeRepository

基础实现：

class MySQLKnowledgeRepository
    implements KnowledgeRepositoryInterface
{
    protected $pdo;
    protected $mapper;

    public function __construct(
        PDO $pdo,
        KnowledgeMapper $mapper
    ) {
        $this->pdo = $pdo;
        $this->mapper = $mapper;
    }

    public function findById($id)
    {
        $sql = "
            SELECT *
            FROM knowledge
            WHERE id = :id
            LIMIT 1
        ";

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

        $stmt->execute(array(
            ':id' => $id
        ));

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

        if (!$data) {
            return null;
        }

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

    public function findBySubject($subject)
    {
        $sql = "
            SELECT *
            FROM knowledge
            WHERE subject = :subject
            ORDER BY id ASC
        ";

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

        $stmt->execute(array(
            ':subject' => $subject
        ));

        return $this->mapRows($stmt);
    }

    public function findByPredicate($predicate)
    {
        $sql = "
            SELECT *
            FROM knowledge
            WHERE predicate = :predicate
            ORDER BY id ASC
        ";

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

        $stmt->execute(array(
            ':predicate' => $predicate
        ));

        return $this->mapRows($stmt);
    }

    public function findBySubjectAndPredicate(
        $subject,
        $predicate
    ) {
        $sql = "
            SELECT *
            FROM knowledge
            WHERE subject = :subject
            AND predicate = :predicate
            ORDER BY id ASC
        ";

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

        $stmt->execute(array(
            ':subject' => $subject,
            ':predicate' => $predicate
        ));

        return $this->mapRows($stmt);
    }

    public function findByPredicateAndObject(
        $predicate,
        $object
    ) {
        $sql = "
            SELECT *
            FROM knowledge
            WHERE predicate = :predicate
            AND object_value = :object_value
            ORDER BY id ASC
        ";

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

        $stmt->execute(array(
            ':predicate' => $predicate,
            ':object_value' => $object
        ));

        return $this->mapRows($stmt);
    }

    public function findByTriple(
        $subject,
        $predicate,
        $object
    ) {
        $sql = "
            SELECT *
            FROM knowledge
            WHERE subject = :subject
            AND predicate = :predicate
            AND object_value = :object_value
            LIMIT 1
        ";

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

        $stmt->execute(array(
            ':subject' => $subject,
            ':predicate' => $predicate,
            ':object_value' => $object
        ));

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

        if (!$data) {
            return null;
        }

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

    public function findByState($state)
    {
        $sql = "
            SELECT *
            FROM knowledge
            WHERE state = :state
            ORDER BY id ASC
        ";

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

        $stmt->execute(array(
            ':state' => $state
        ));

        return $this->mapRows($stmt);
    }

    public function exists(
        $subject,
        $predicate,
        $object
    ) {
        $sql = "
            SELECT COUNT(*) AS total
            FROM knowledge
            WHERE subject = :subject
            AND predicate = :predicate
            AND object_value = :object_value
        ";

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

        $stmt->execute(array(
            ':subject' => $subject,
            ':predicate' => $predicate,
            ':object_value' => $object
        ));

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

        return ((int)$row['total'] > 0);
    }

    public function save($knowledge)
    {
        $data = $this->mapper->toPersistence(
            $knowledge
        );

        if ($this->exists(
            $data['subject'],
            $data['predicate'],
            $data['object_value']
        )) {
            return false;
        }

        $sql = "
            INSERT INTO knowledge
            (
                id,
                subject,
                predicate,
                object_value,
                condition,
                state
            )
            VALUES
            (
                :id,
                :subject,
                :predicate,
                :object_value,
                :condition,
                :state
            )
        ";

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

        return $stmt->execute(array(
            ':id' => $data['id'],
            ':subject' => $data['subject'],
            ':predicate' => $data['predicate'],
            ':object_value' => $data['object_value'],
            ':condition' => $data['condition'],
            ':state' => $data['state']
        ));
    }

    public function update($knowledge)
    {
        $data = $this->mapper->toPersistence(
            $knowledge
        );

        $sql = "
            UPDATE knowledge
            SET
                subject = :subject,
                predicate = :predicate,
                object_value = :object_value,
                condition = :condition,
                state = :state
            WHERE id = :id
        ";

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

        return $stmt->execute(array(
            ':id' => $data['id'],
            ':subject' => $data['subject'],
            ':predicate' => $data['predicate'],
            ':object_value' => $data['object_value'],
            ':condition' => $data['condition'],
            ':state' => $data['state']
        ));
    }

    protected function mapRows($stmt)
    {
        $knowledgeList = array();

        while ($data = $stmt->fetch(PDO::FETCH_ASSOC)) {
            $knowledgeList[] =
                $this->mapper->toDomain($data);
        }

        return $knowledgeList;
    }
}

以上代码用于说明 KnowledgeRepository 的工程结构。实际项目必须以真实数据库表结构、字段、主键策略、唯一约束以及现有 Repository 接口为准；这里没有对用户当前项目数据库进行实际连接和测试，因此不能把该代码描述为已经在实际系统中验证通过的版本。

219.25 知识保存后的读取验证

KnowledgeRepository 不应把：

INSERT成功

直接等同于：

Knowledge保存正确

更可靠的保存过程：

$Save(K)→Insert→ReadBack→CompareSave(K) \rightarrow Insert \rightarrow ReadBack \rightarrow Compare$

定义：

$VerifySave=Exists∧IdentityMatch∧ContentMatchVerifySave = Exists \land IdentityMatch \land ContentMatch$

其中：

Exists：记录存在；
IdentityMatch：知识 ID 正确；
ContentMatch：Subject、Predicate、Object、Condition、State 等核心字段一致。

219.26 知识更新后的验证

更新同样需要 ReadBack。

Current Knowledge
      ↓
Update
      ↓
ReadBack
      ↓
Compare
      ↓
Verified

公式：

$VerifyUpdate=Exists∧IdentityMatch∧ChangedFieldsMatchVerifyUpdate = Exists \land IdentityMatch \land ChangedFieldsMatch$

例如：

before:
Resource >= 1

after:
Resource >= 2

读取数据库后必须确认：

condition = Resource >= 2

而不是只检查 SQL 是否返回成功。

219.27 知识保存与事务

如果一次学习过程产生：

Knowledge
Knowledge History
Evidence
Learning Record

则可能需要在 Service / TransactionManager 层协调事务：

Begin
   ↓
Save Knowledge
   ↓
Save Evidence
   ↓
Save Knowledge History
   ↓
Verify
   ↓
Commit

Repository 可以参与事务，但：

$KnowledgeRepository≠TransactionManagerKnowledgeRepository \neq TransactionManager$

事务边界应该由上层 Service 或专门的 TransactionManager 统一控制。

219.28 KnowledgeRepository与LearningEngine

完整学习链：

Feedback
   ↓
History
   ↓
Memory
   ↓
Experience
   ↓
LearningEngine
   ↓
Knowledge Update Candidate
   ↓
UpdateEngine
   ↓
KnowledgeRepository

因此：

$Learning≠UpdateLearning \neq Update$

同时：

$Update≠PersistenceUpdate \neq Persistence$

三层关系：

$LearningEngine→UpdateEngine→KnowledgeRepositoryLearningEngine \rightarrow UpdateEngine \rightarrow KnowledgeRepository$

分别回答：

LearningEngine
什么应该改变？

UpdateEngine
已经确认的变化如何应用？

KnowledgeRepository
如何把应用后的知识持久化？

219.29 KnowledgeRepository与Individual

Individual 是 ICAI 的综合认知主体。

其结构包含：

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

其中 $KK$ 就是 Knowledge。

因此 IndividualRepository 加载 Individual Aggregate 时，可以根据实际用例加载：

Individual
   ↓
Objects
   ↓
States
   ↓
Relations
   ↓
Knowledge
   ↓
Capabilities
   ↓
Methods
   ↓
Memory
   ↓
Experience

其中 KnowledgeRepository 负责：

Knowledge Load
Knowledge Save
Knowledge Update

IndividualRepository 负责整个 Individual Aggregate 的组合协调。

因此：

$KnowledgeRepository⊂Individual Persistence StructureKnowledgeRepository \subset Individual\ Persistence\ Structure$

但不意味着 KnowledgeRepository 继承 IndividualRepository。

219.30 KnowledgeRepository与CognitiveEngine

CognitiveEngine 的知识部分来自：

KnowledgeRepository
        ↓
Knowledge Facts
        ↓
KnowledgeEngine

CognitiveEngine 的输入已经定义为：

$CI=(I,Of,Sf,Rf,Kf,C,Env,T,H,Ev,Ru)CI= (I,O_f,S_f,R_f,K_f,C,Env,T,H,E_v,Ru)$

其中：

$Kf=Knowledge FactsK_f=Knowledge\ Facts$

因此：

KnowledgeRepository
      ↓
Kf
      ↓
CognitiveEngine
      ↓
KnowledgeEngine
      ↓
Knowledge Calculation Result

这保持了前面第209章 CognitiveEngine 输入输出定义的一致性。

219.31 KnowledgeRepository的数据结构

基础知识表可以采用类似结构：

CREATE TABLE knowledge (
    id INT NOT NULL AUTO_INCREMENT,
    subject VARCHAR(255) NOT NULL,
    predicate VARCHAR(100) NOT NULL,
    object_value TEXT NOT NULL,
    condition TEXT,
    state VARCHAR(50) NOT NULL,
    created_at DATETIME,
    updated_at DATETIME,
    PRIMARY KEY (id)
);

可以进一步建立：

knowledge_evidence
knowledge_history
knowledge_relations
knowledge_conditions

用于保存：

知识依据
知识变化
知识关系
知识条件

但实际数据库结构必须根据工程需要确定，不能把示例表结构直接视为现有系统的正式数据库设计。

219.32 知识索引

如果 Knowledge 数量增加，查询性能会成为 Repository 的重要问题。

例如常用查询：

$(S,P,O)(S,P,O)$

可以考虑相应数据库索引。

例如：

INDEX idx_subject (subject)
INDEX idx_predicate (predicate)
INDEX idx_subject_predicate (subject, predicate)

对于完整三元关系查询，还可以根据实际字段长度和数据库版本设计组合索引。

这里仍然要区分：

$Database Index≠Knowledge InferenceDatabase\ Index \neq Knowledge\ Inference$

数据库索引只是提高查询效率，不产生认知推理。

219.33 知识查询缓存

在大量重复读取的情况下，可以增加缓存层：

KnowledgeRepository
        ↓
Cache
        ↓
MySQL

但缓存中的知识仍然属于持久化数据的读取优化。

不能因为缓存存在，就认为缓存数据自动成为当前有效知识。

必须考虑：

Cache Time
Knowledge State
Updated Time
Version

因此：

$CachedKnowledge≠CurrentVerifiedKnowledgeCachedKnowledge \neq CurrentVerifiedKnowledge$

除非经过有效性检查。

219.34 KnowledgeRepository与版本

知识具有明显的演化特点，因此可以加入版本概念：

$KvK_v$

例如：

K1 version 1
K1 version 2
K1 version 3

形成：

K1
 ↓
v1
 ↓
v2
 ↓
v3

这样能够支持：

知识追踪
知识回溯
知识比较
知识冲突分析
知识更新验证

但是版本管理本身仍然是持久化机制。

知识“为什么需要升级”仍由认知计算体系确定。

219.35 KnowledgeRepository完整调用链

正常读取：

Controller
    ↓
KnowledgeService
    ↓
KnowledgeRepository
    ↓
MySQL
    ↓
KnowledgeMapper
    ↓
Knowledge
    ↓
KnowledgeEngine

知识更新：

Execution
    ↓
Feedback
    ↓
Experience
    ↓
LearningEngine
    ↓
Knowledge Update Candidate
    ↓
UpdateEngine
    ↓
KnowledgeRepository
    ↓
MySQL

知识重新进入认知：

MySQL
    ↓
KnowledgeRepository
    ↓
Knowledge Facts
    ↓
KnowledgeEngine
    ↓
CognitiveEngine

219.36 KnowledgeRepository核心公式

知识保存：

$Save(K)→Validate→Map→Persist→Verify\boxed{ Save(K) \rightarrow Validate \rightarrow Map \rightarrow Persist \rightarrow Verify }$

知识查询：

$Query(C)→PersistenceData→Knowledge\boxed{ Query(C) \rightarrow PersistenceData \rightarrow Knowledge }$

知识更新：

$Kt+ΔK→Validate→Update→Verify\boxed{ K_t+\Delta K \rightarrow Validate \rightarrow Update \rightarrow Verify }$

知识更新条件：

$CanUpdateKnowledge=ValidChange∧Condition∧Rule∧Verification\boxed{ CanUpdateKnowledge = ValidChange \land Condition \land Rule \land Verification }$

知识有效性：

$KnowledgeExists≠KnowledgeValid≠KnowledgeVerified\boxed{ KnowledgeExists \neq KnowledgeValid \neq KnowledgeVerified }$

219.37 KnowledgeRepository与其他Repository的关系

到目前为止，Repository 层已经形成：

IndividualRepository
        ↓
ObjectRepository
        ↓
StateRepository
        ↓
RelationRepository
        ↓
KnowledgeRepository

它们分别保存：

Individual
Object
State
Relation
Knowledge

认知计算层则对应：

IndividualService
       ↓
ObjectEngine
       ↓
StateEngine
       ↓
RelationEngine
       ↓
KnowledgeEngine

形成：

$DomainObject↔RepositoryDomainObject \leftrightarrow Repository$

以及：

$DomainObject↔EngineDomainObject \leftrightarrow Engine$

两条不同的工程通道。

219.38 本章核心原则

原则一：Knowledge是独立Domain Object

$Knowledge≠TextKnowledge\neq Text$ $Knowledge≠DatabaseRecordKnowledge\neq DatabaseRecord$

原则二：Repository不负责知识推理

$KnowledgeRepository≠KnowledgeEngineKnowledgeRepository \neq KnowledgeEngine$

原则三：知识查询不等于知识判断

$Query(K)≠Evaluate(K)Query(K)\neq Evaluate(K)$

原则四：知识存在不等于知识有效

$Exists(K)≠Valid(K)Exists(K)\neq Valid(K)$

原则五：知识有效不等于已经验证

$Valid(K)≠Verified(K)Valid(K)\neq Verified(K)$

原则六：知识更新遵循最小更新原则

$Kt+ΔK→Kt+1K_t+\Delta K\rightarrow K_{t+1}$

原则七：知识更新必须具有依据

$CanUpdateKnowledge=ValidChange∧Condition∧Rule∧VerificationCanUpdateKnowledge = ValidChange \land Condition \land Rule \land Verification$

原则八：知识变化应该可追溯

$KnowledgeChange→KnowledgeHistoryKnowledgeChange \rightarrow KnowledgeHistory$

原则九：LearningEngine不直接承担持久化

$LearningEngine→UpdateEngine→KnowledgeRepositoryLearningEngine \rightarrow UpdateEngine \rightarrow KnowledgeRepository$

原则十：MySQL只负责数据存储

$MySQL≠CognitiveEngineMySQL \neq CognitiveEngine$

219.39 本章总结

KnowledgeRepository 将 ICAI 中的知识对象正式接入持久化体系。

其核心职责：

$KnowledgeRepository=Save+Query+Update\boxed{ KnowledgeRepository = Save + Query + Update }$

知识保存：

$Knowledge→Validate→Persist→VerifyKnowledge \rightarrow Validate \rightarrow Persist \rightarrow Verify$

知识查询：

$QueryCondition→MySQL→KnowledgeQueryCondition \rightarrow MySQL \rightarrow Knowledge$

知识更新：

$Kt+ΔK→Validate→Update→VerifyK_t+\Delta K \rightarrow Validate \rightarrow Update \rightarrow Verify$

完整知识生命周期：

Fact
 ↓
KnowledgeEngine
 ↓
Knowledge Candidate
 ↓
Verification
 ↓
Learning / Update
 ↓
KnowledgeRepository
 ↓
MySQL
 ↓
KnowledgeRepository
 ↓
Knowledge
 ↓
KnowledgeEngine
 ↓
CognitiveEngine

最终形成明确的职责分工：

$KnowledgeEngine=知识计算\boxed{ KnowledgeEngine=知识计算 }$ $LearningEngine=知识学习变化计算\boxed{ LearningEngine=知识学习变化计算 }$ $UpdateEngine=知识更新应用\boxed{ UpdateEngine=知识更新应用 }$ $KnowledgeRepository=知识持久化\boxed{ KnowledgeRepository=知识持久化 }$ $MySQL=知识数据存储\boxed{ MySQL=知识数据存储 }$

因此：

$Knowledge→KnowledgeEngine→LearningEngine→UpdateEngine→KnowledgeRepository→MySQL\boxed{ Knowledge \rightarrow KnowledgeEngine \rightarrow LearningEngine \rightarrow UpdateEngine \rightarrow KnowledgeRepository \rightarrow MySQL }$

读取方向则为：

$MySQL→KnowledgeRepository→Knowledge→KnowledgeEngine→CognitiveEngine\boxed{ MySQL \rightarrow KnowledgeRepository \rightarrow Knowledge \rightarrow KnowledgeEngine \rightarrow CognitiveEngine }$

至此，ICAI 已经形成从 Individual → Object → State → Relation → Knowledge 的基础认知数据持久化链条。知识不再只是静态数据库记录，而成为可以被 Engine 计算、被 Learning 更新、被 Update 应用、被 Repository 持久化，并重新进入 CognitiveEngine 的结构化认知数据。

第219章 KnowledgeRepository

第219章 KnowledgeRepository

219.1 KnowledgeRepository定义

219.2 Knowledge领域对象

219.3 KnowledgeRepository与KnowledgeEngine

219.4 知识保存

219.5 知识保存条件

219.6 知识状态

219.7 知识查询

219.8 按ID查询

219.9 按Subject查询

219.10 按Predicate查询

219.11 按Subject与Predicate查询

219.12 按Predicate与Object查询

219.13 三元知识查询

219.14 知识状态查询

219.15 知识查询不等于知识判断

219.16 知识更新

219.17 KnowledgeRepository不决定知识更新

219.18 知识最小更新原则

219.19 知识更新条件

219.20 知识冲突

219.21 知识历史

219.22 KnowledgeMapper

219.23 KnowledgeRepository接口

219.24 MySQLKnowledgeRepository

219.25 知识保存后的读取验证

219.26 知识更新后的验证

219.27 知识保存与事务

219.28 KnowledgeRepository与LearningEngine

219.29 KnowledgeRepository与Individual

219.30 KnowledgeRepository与CognitiveEngine

219.31 KnowledgeRepository的数据结构

219.32 知识索引

219.33 知识查询缓存

219.34 KnowledgeRepository与版本

219.35 KnowledgeRepository完整调用链

219.36 KnowledgeRepository核心公式

219.37 KnowledgeRepository与其他Repository的关系

219.38 本章核心原则

原则一：Knowledge是独立Domain Object

原则二：Repository不负责知识推理

原则三：知识查询不等于知识判断

原则四：知识存在不等于知识有效

原则五：知识有效不等于已经验证

原则六：知识更新遵循最小更新原则

原则七：知识更新必须具有依据

原则八：知识变化应该可追溯

原则九：LearningEngine不直接承担持久化

原则十：MySQL只负责数据存储

219.39 本章总结