首页 理论 架构 工程 规划 文档 白皮书 著作 研究 案例 下载 博客 关于 联系 开始使用 →

第七章 结构定义与结构数据管理

第七章 结构定义与结构数据管理

  1. 结构定义的数据表设计

  2. 结构元素及其属性的关联存储

  3. 结构关系与方法定义的持久化

  4. 结构版本与结构变更管理

  5. 结构完整性检查与数据验证程序

    第七章 结构定义与结构数据管理

    结构定义的工程化表达解决的是结构智能逻辑如何转化为程序能够识别和处理的数据对象,而结构数据管理进一步解决这些数据如何保存、组织、关联、更新、验证和持续使用的问题。结构定义并不是一次性生成后便不再变化的静态数据。随着需求变化、知识构建、对象认知和能力形成,原有结构可能需要增加元素、调整属性、改变元素关系、扩展方法定义,甚至重新组织整个结构。因此,WSaiOS智能控制后台必须建立与结构智能运行相适应的结构数据管理机制。

    本章围绕结构定义的数据持久化展开工程设计,将结构定义、结构元素、属性、元素关系和方法定义作为具有明确关联关系的数据对象进行管理,并通过版本管理、变更记录、完整性检查和数据验证程序,保证结构数据在持续构建与动态调整过程中保持可识别、可追溯和可调用。

    本章所设计的数据表和程序文件属于工程设计方案,后续实施时需要结合实际项目目录、数据库类型、程序运行环境和前序章节确定的对象模型进一步落地。

    7.1 结构定义的数据表设计

    结构定义的数据表设计首先需要确定数据保存的基本边界。结构定义不能仅以一段JSON文本保存在某个字段中,也不能将所有元素、属性、关系和方法混合存放在一张数据表中。前一种方式不利于对结构内部数据进行独立查询、关联和更新,后一种方式则容易造成字段重复、数据冗余和结构关系混乱。

    工程上需要将结构定义作为一个独立的数据管理对象,将其内部的元素、属性、方法和关系分别建立数据记录,并通过结构标识和元素标识建立关联。结构定义负责描述整体结构的身份、名称、类型、状态和版本信息;结构元素负责保存结构内部的组成单元;属性定义负责描述元素具有的属性及其数据约束;方法定义负责保存元素所具有的操作定义;关系数据负责描述不同元素之间的结构联系。

    这种数据组织方式并不意味着将结构拆分成彼此独立的知识。各数据表只是数据库中的持久化组织形式,结构的完整含义仍然由结构定义及其内部元素、属性、方法和关系共同构成。后台在读取结构时,需要依据结构标识和关联记录重新组织完整结构对象。

    在数据库设计中,首先建立结构定义主表。

    CREATE TABLE structure_definitions (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        structure_code VARCHAR(100) NOT NULL,
        structure_name VARCHAR(200) NOT NULL,
        structure_type VARCHAR(100) DEFAULT NULL,
        description TEXT,
        current_version_id BIGINT UNSIGNED DEFAULT NULL,
        status VARCHAR(30) NOT NULL DEFAULT 'draft',
        created_at DATETIME NOT NULL,
        updated_at DATETIME NOT NULL,
        UNIQUE KEY uk_structure_code (structure_code)
    );

    structure_definitions用于保存结构定义的基本身份信息。structure_code是结构定义在整个WSaiOS工程中的稳定标识,不应使用数据库自增ID代替。数据库ID负责数据记录定位,结构编码负责在不同程序、数据记录和部署环境之间识别同一个结构对象。

    structure_name用于保存结构名称,structure_type用于区分结构的类别,description用于记录结构定义的说明信息。current_version_id指向当前使用的结构版本,status用于表示结构定义所处的管理状态。

    结构定义的状态与结构版本不能混为一谈。状态表示结构当前处于草稿、待验证、已发布、已停用等管理阶段;版本表示结构内容在不同变更阶段形成的具体版本。一个结构可以具有多个历史版本,但在同一运行环境中应明确指定当前使用的版本。

    结构定义主表只保存整体身份信息,不直接保存所有元素的具体内容。这样,后台能够通过结构编码定位结构,再根据结构版本读取相应的元素、属性、方法和关系数据。

    结构数据的持久化还需要考虑版本独立性。不能在原有结构已经投入使用后,直接覆盖所有数据记录,使历史结构无法恢复。因此,需要建立结构版本表。

    CREATE TABLE structure_versions (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        structure_id BIGINT UNSIGNED NOT NULL,
        version_code VARCHAR(50) NOT NULL,
        version_number INT NOT NULL,
        change_summary TEXT,
        version_status VARCHAR(30) NOT NULL DEFAULT 'draft',
        created_by VARCHAR(100) DEFAULT NULL,
        created_at DATETIME NOT NULL,
        published_at DATETIME DEFAULT NULL,
        UNIQUE KEY uk_structure_version (
            structure_id,
            version_code
        ),
        KEY idx_structure_version_number (
            structure_id,
            version_number
        )
    );

    structure_versions保存每一次结构内容变更所形成的版本记录。structure_id指向结构定义主表,version_code表示版本编码,version_number用于进行版本顺序管理,change_summary记录本次版本的主要变更内容。

    结构版本与结构定义之间是一对多关系。一个结构定义可以形成多个版本,而每一个版本必须归属于一个明确的结构定义。

    在实际数据库实施中,还应根据数据库引擎和部署环境,为结构版本与结构定义之间建立外键约束。当前版本指针也应在发布事务中同步更新,避免出现主表指向不存在版本的情况。

    结构定义的数据表组织关系可以表示为:

    structure_definitions
            │
            ├── structure_versions
            │        │
            │        ├── structure_elements
            │        │        │
            │        │        ├── element_attributes
            │        │        │
            │        │        └── element_methods
            │        │
            │        └── structure_relations
            │
            └── current_version_id

    这套关系表达的是数据库持久化组织方式。结构版本是具体结构内容的管理边界,元素、属性、方法和关系均应能够确定所属版本。读取某个版本时,不能混入其他版本中的元素或关系记录,否则可能将不同阶段的结构内容错误组合。

    因此,结构数据表的设计原则是:结构身份独立管理,结构版本独立管理,结构组成数据按照对象关系分别持久化,并通过明确的标识建立完整关联。

    7.2 结构元素及其属性的关联存储

    结构元素是结构定义内部的基本组成单元。结构元素具有自身的标识、名称、类型和定义内容,同时可以包含多个属性和多个方法。数据库需要能够根据结构版本定位某个元素,并进一步读取其属性定义和方法定义。

    结构元素数据表首先需要建立版本关联。

    CREATE TABLE structure_elements (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        structure_id BIGINT UNSIGNED NOT NULL,
        version_id BIGINT UNSIGNED NOT NULL,
        element_code VARCHAR(100) NOT NULL,
        element_name VARCHAR(200) NOT NULL,
        element_type VARCHAR(100) DEFAULT NULL,
        element_definition TEXT,
        sort_order INT NOT NULL DEFAULT 0,
        status VARCHAR(30) NOT NULL DEFAULT 'active',
        created_at DATETIME NOT NULL,
        updated_at DATETIME NOT NULL,
        UNIQUE KEY uk_element_version (
            version_id,
            element_code
        ),
        KEY idx_element_structure (
            structure_id,
            version_id
        )
    );

    structure_elements保存具体结构版本中的元素记录。element_code是元素在结构内部的标识,必须在同一结构版本内保持唯一。element_name用于表达元素名称,element_type用于描述元素类别,element_definition保存元素的补充定义信息。

    元素记录同时保存structure_id和version_id,是为了便于进行结构范围查询和版本定位。但这两个字段必须保持一致,不能出现元素的structure_id与其所属version_id对应的结构不一致的情况。数据库可以通过复合外键或其他约束方式保证这一点,具体实现取决于所采用的数据库引擎。

    结构元素与属性之间是一对多关系。一个元素可以具有多个属性,每个属性属于一个明确的元素,并且属于该元素所在的结构版本。

    属性数据表设计如下:

    CREATE TABLE element_attributes (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        structure_id BIGINT UNSIGNED NOT NULL,
        version_id BIGINT UNSIGNED NOT NULL,
        element_id BIGINT UNSIGNED NOT NULL,
        attribute_code VARCHAR(100) NOT NULL,
        attribute_name VARCHAR(200) NOT NULL,
        data_type VARCHAR(50) NOT NULL,
        attribute_definition TEXT,
        default_value TEXT,
        is_required TINYINT(1) NOT NULL DEFAULT 0,
        validation_rule TEXT,
        sort_order INT NOT NULL DEFAULT 0,
        created_at DATETIME NOT NULL,
        updated_at DATETIME NOT NULL,
        UNIQUE KEY uk_element_attribute (
            element_id,
            attribute_code
        ),
        KEY idx_attribute_version (
            version_id,
            element_id
        )
    );

    element_attributes保存属性定义,而不是具体对象实例的属性值。属性定义与属性值必须分开处理。属性定义说明某个元素具有什么属性、属性名称是什么、数据类型是什么、是否必需以及需要满足什么约束;具体对象实例中的属性值则属于运行数据,应由对象实例数据管理机制负责保存。

    例如,某个设备结构定义中存在设备对象元素,该元素具有设备编号、设备状态、工作温度和运行速度等属性。上述属性名称、类型、约束属于结构定义;某一台具体设备当前的工作温度、运行速度和运行状态,则属于该设备实例的运行数据。

    如果将属性定义与运行值直接混合存储,结构定义就会受到具体实例状态变化的影响。多个实例使用同一个结构时,也无法明确区分共同的属性定义和各自不同的运行值。

    因此,结构属性表只负责定义属性。对象实例属性值应当在后续个体运行对象和运行环境的数据模型中单独建立关联。

    属性定义中的data_type应采用统一的数据类型约定。例如,整数、浮点数、字符串、布尔值、日期时间以及结构化数据等类型,需要在结构定义阶段形成明确规范。validation_rule用于保存属性约束,例如数值范围、字符串长度、枚举范围和格式要求。该字段可以保存结构化规则,但不能仅依靠保存一段规则文本来完成验证,后台还需要有相应的规则解析和执行程序。

    为了便于结构元素和属性数据的读取,程序层需要建立元素与属性的关联读取机制。其基本查询逻辑是先确定结构版本,再读取该版本中的元素,最后根据元素ID读取其属性。

    例如:

    SELECT
        e.id AS element_id,
        e.element_code,
        e.element_name,
        e.element_type,
        a.id AS attribute_id,
        a.attribute_code,
        a.attribute_name,
        a.data_type,
        a.is_required,
        a.validation_rule
    FROM structure_elements e
    LEFT JOIN element_attributes a
        ON a.element_id = e.id
       AND a.version_id = e.version_id
    WHERE e.version_id = :version_id
    ORDER BY
        e.sort_order,
        a.sort_order;

    这一查询返回的是指定版本中的元素与属性关联数据。程序层还需要将查询结果组织成结构对象,而不是直接把数据库查询结果作为最终结构定义使用。

    拟定的目录组织如下:

    app/
    └── Repositories/
        └── Structure/
            ├── StructureRepository.php       # 读取结构定义基本信息和当前版本
            ├── StructureVersionRepository.php # 读取和保存结构版本记录
            ├── ElementRepository.php         # 读取和保存结构元素
            └── AttributeRepository.php       # 读取和保存元素属性定义
    
    app/
    └── Intelligence/
        └── Structure/
            ├── StructureLoader.php            # 根据结构标识和版本组织完整结构数据
            ├── ElementLoader.php              # 读取元素并组织元素内部数据
            └── AttributeLoader.php            # 读取属性定义并组织属性约束

    上述目录是工程设计中的程序组织建议。Repository负责数据库持久化访问,Loader负责将持久化记录组织为可供智能控制后台使用的结构对象。二者不能混为一体,否则结构数据读取、数据库访问和结构解析将相互耦合。

    元素加载程序可以采用如下方式:

    <?php
    
    class ElementLoader
    {
        private $elementRepository;
        private $attributeRepository;
    
        public function __construct(
            ElementRepository $elementRepository,
            AttributeRepository $attributeRepository
        ) {
            $this->elementRepository = $elementRepository;
            $this->attributeRepository = $attributeRepository;
        }
    
        public function loadByVersion($versionId)
        {
            $elements = $this->elementRepository
                ->findByVersion($versionId);
    
            $result = array();
    
            foreach ($elements as $element) {
                $attributes = $this->attributeRepository
                    ->findByElement(
                        $element['id'],
                        $versionId
                    );
    
                $element['attributes'] = $attributes;
    
                $result[] = $element;
            }
    
            return $result;
        }
    }

    这里的ElementLoader不直接编写SQL,也不负责判断属性定义是否正确。它通过ElementRepository读取元素,通过AttributeRepository读取属性,再将两类数据组织到同一个元素结构中。

    其调用关系是:结构加载程序确定版本,元素加载程序读取该版本中的元素,属性加载程序读取元素属性,最终形成包含属性定义的结构元素集合。后续结构解析程序可以直接使用这一集合进行结构对象构建。

    7.3 结构关系与方法定义的持久化

    结构关系是结构定义中不可缺少的数据。仅仅保存元素和属性,无法完整表达一个结构。不同元素之间可能存在组成、从属、连接、依赖、控制、引用和其他关系。关系数据不仅用于描述结构内部的组织方式,也将影响后台对结构的解析、匹配和后续方法调用。

    因此,结构关系需要独立保存,不能仅仅依靠元素名称或元素定义文本推断关系。

    结构关系数据表设计如下:

    CREATE TABLE structure_relations (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        structure_id BIGINT UNSIGNED NOT NULL,
        version_id BIGINT UNSIGNED NOT NULL,
        relation_code VARCHAR(100) NOT NULL,
        source_element_id BIGINT UNSIGNED NOT NULL,
        target_element_id BIGINT UNSIGNED NOT NULL,
        relation_type VARCHAR(100) NOT NULL,
        relation_definition TEXT,
        relation_direction VARCHAR(30) DEFAULT NULL,
        relation_status VARCHAR(30) NOT NULL DEFAULT 'active',
        created_at DATETIME NOT NULL,
        updated_at DATETIME NOT NULL,
        KEY idx_relation_source (
            version_id,
            source_element_id
        ),
        KEY idx_relation_target (
            version_id,
            target_element_id
        ),
        UNIQUE KEY uk_relation_code (
            version_id,
            relation_code
        )
    );

    其中,source_element_id表示关系的起始元素,target_element_id表示关系的目标元素,relation_type表示关系类型,relation_definition用于保存关系的具体定义内容。

    关系数据必须同时指向同一个结构版本中的有效元素。不能允许一个关系的起始元素来自某个版本,而目标元素来自另一个版本。对于有方向性的关系,需要明确起始端和目标端;对于不具有方向性的关系,则应在关系类型定义中明确其语义,不能仅依赖程序开发人员对字段含义的理解。

    结构关系的保存还需要考虑关系约束。例如,某种关系可能要求目标元素必须属于指定类型,某种关系可能只允许一个目标元素,某种关系可能允许多个目标元素。上述要求应当在关系定义和验证程序中表达,而不是由数据库字段名称隐含决定。

    方法定义同样属于结构元素的组成内容。方法用于描述元素能够执行的操作。方法定义与方法实现必须分开。数据库保存的是方法标识、方法名称、输入参数、输出定义、执行约束和实现引用等定义信息;实际执行程序则由方法注册与调用机制负责定位和执行。

    方法定义数据表如下:

    CREATE TABLE element_methods (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        structure_id BIGINT UNSIGNED NOT NULL,
        version_id BIGINT UNSIGNED NOT NULL,
        element_id BIGINT UNSIGNED NOT NULL,
        method_code VARCHAR(100) NOT NULL,
        method_name VARCHAR(200) NOT NULL,
        method_definition TEXT,
        input_definition TEXT,
        output_definition TEXT,
        implementation_key VARCHAR(200) DEFAULT NULL,
        execution_rule TEXT,
        method_status VARCHAR(30) NOT NULL DEFAULT 'active',
        created_at DATETIME NOT NULL,
        updated_at DATETIME NOT NULL,
        UNIQUE KEY uk_element_method (
            element_id,
            method_code
        ),
        KEY idx_method_version (
            version_id,
            element_id
        )
    );

    method_code是方法在元素内部的稳定标识。method_definition描述方法的基本定义,input_definition和output_definition分别保存输入与输出的数据约定,implementation_key用于关联实际程序实现,execution_rule保存方法调用所需的约束。

    例如,一个设备对象元素可以定义状态读取、启动、停止、参数调整等方法。数据库中的方法记录只说明这些操作的结构定义和调用约定,并不意味着数据库本身能够直接执行设备控制。后台必须根据implementation_key找到相应的方法实现,再通过方法调用程序执行。

    方法定义与方法实现的分离,是为了避免结构数据直接绑定某个具体程序文件。一个方法定义可以根据运行环境关联不同的实现适配程序。例如,同一个逻辑方法在模拟环境、软件环境和真实设备环境中,可以具有不同的具体实现,但其输入、输出和方法语义应符合相同的定义约束。

    方法持久化还需要考虑实现引用的有效性。结构定义可以保存方法实现标识,但不能允许任意数据记录直接指定未经验证的文件路径并由后台执行。方法注册表应负责维护经过授权的实现标识、程序类和调用入口,方法分派程序则依据结构定义与注册信息完成调用。

    结构关系和方法定义的程序组织如下:

    app/
    ├── Repositories/
    │   └── Structure/
    │       ├── RelationRepository.php       # 保存和读取结构元素关系
    │       └── MethodRepository.php         # 保存和读取元素方法定义
    │
    ├── Intelligence/
    │   └── Structure/
    │       ├── RelationLoader.php           # 根据结构版本加载关系数据
    │       └── MethodDefinitionLoader.php   # 加载元素方法定义
    │
    ├── Intelligence/
    │   └── Method/
    │       ├── MethodResolver.php           # 根据方法标识解析实现引用
    │       └── MethodDispatcher.php         # 按调用约定分派方法执行
    │
    └── Runtime/
        └── MethodRegistry.php               # 管理经过验证的方法实现注册信息

    关系加载程序负责将关系记录组织为结构内部的关联关系,方法定义加载程序负责将方法记录组织为元素内部的方法集合。它们最终都由结构加载程序统一组织。

    在运行过程中,后台智能核心可以根据结构定义识别某个元素具有哪些关系、能够调用哪些方法。当需要执行具体方法时,再由方法解析程序和方法分派程序完成后续调用。

    因此,结构关系的持久化解决的是结构内部元素如何关联的问题,方法定义的持久化解决的是结构元素具有哪些操作定义的问题。二者共同构成完整结构定义的数据基础。

    7.4 结构版本与结构变更管理

    结构定义并不是固定不变的。需求驱动智能在处理新的需求时,可能发现已有结构缺少必要元素;知识结构化过程可能形成新的属性定义;能力构建过程可能需要增加新的方法;运行反馈也可能表明原有关系定义存在缺陷。这些变化都需要反映到结构数据中。

    如果直接修改当前使用的结构记录,就可能造成正在运行的个体与后台结构定义不一致。例如,某个个体已经按照旧版本获得知识能力和执行规则,而后台直接修改了原结构中的方法定义,个体下一次调用时就可能出现方法不存在、参数不一致或关系失效的问题。

    因此,结构变更需要采用版本化管理。一个已经发布的结构版本应当保持内容稳定。需要修改时,应基于当前版本创建新的草稿版本,在草稿版本中完成元素、属性、关系和方法定义的变更,经过验证后再发布。

    结构版本管理的核心不是简单地为结构增加一个版本号,而是保证每一个版本都具有独立、完整、可恢复的结构内容。

    版本创建时,首先读取当前版本的全部结构数据,然后将其复制到新版本。复制内容包括结构元素、元素属性、方法定义和元素关系。新版本创建后,所有修改只针对新版本进行,不直接修改原版本的数据。

    版本复制需要在数据库事务中完成,避免复制过程中部分数据成功、部分数据失败,形成不完整的新版本。

    版本创建程序可以设计为:

    <?php
    
    class StructureVersionManager
    {
        private $pdo;
    
        public function __construct(PDO $pdo)
        {
            $this->pdo = $pdo;
        }
    
        public function createDraft($structureId, $versionCode)
        {
            $this->pdo->beginTransaction();
    
            try {
                $currentVersionId = $this->getCurrentVersionId(
                    $structureId
                );
    
                if (!$currentVersionId) {
                    throw new Exception('当前结构版本不存在');
                }
    
                $versionNumber = $this->getNextVersionNumber(
                    $structureId
                );
    
                $newVersionId = $this->insertVersion(
                    $structureId,
                    $versionCode,
                    $versionNumber
                );
    
                $this->copyElements(
                    $currentVersionId,
                    $newVersionId,
                    $structureId
                );
    
                $this->copyAttributes(
                    $currentVersionId,
                    $newVersionId,
                    $structureId
                );
    
                $this->copyMethods(
                    $currentVersionId,
                    $newVersionId,
                    $structureId
                );
    
                $this->copyRelations(
                    $currentVersionId,
                    $newVersionId,
                    $structureId
                );
    
                $this->pdo->commit();
    
                return $newVersionId;
    
            } catch (Exception $e) {
                $this->pdo->rollBack();
                throw $e;
            }
        }
    
        private function getCurrentVersionId($structureId)
        {
            $sql = "SELECT current_version_id
                    FROM structure_definitions
                    WHERE id = :id";
    
            $stmt = $this->pdo->prepare($sql);
            $stmt->execute(array(
                ':id' => $structureId
            ));
    
            return $stmt->fetchColumn();
        }
    
        private function getNextVersionNumber($structureId)
        {
            $sql = "SELECT MAX(version_number)
                    FROM structure_versions
                    WHERE structure_id = :structure_id";
    
            $stmt = $this->pdo->prepare($sql);
            $stmt->execute(array(
                ':structure_id' => $structureId
            ));
    
            return ((int)$stmt->fetchColumn()) + 1;
        }
    
        private function insertVersion(
            $structureId,
            $versionCode,
            $versionNumber
        ) {
            $sql = "INSERT INTO structure_versions (
                        structure_id,
                        version_code,
                        version_number,
                        version_status,
                        created_at
                    ) VALUES (
                        :structure_id,
                        :version_code,
                        :version_number,
                        'draft',
                        NOW()
                    )";
    
            $stmt = $this->pdo->prepare($sql);
            $stmt->execute(array(
                ':structure_id' => $structureId,
                ':version_code' => $versionCode,
                ':version_number' => $versionNumber
            ));
    
            return $this->pdo->lastInsertId();
        }
    
        private function copyElements(
            $oldVersionId,
            $newVersionId,
            $structureId
        ) {
            // 根据旧版本复制元素记录,并重新建立新版本关联。
        }
    
        private function copyAttributes(
            $oldVersionId,
            $newVersionId,
            $structureId
        ) {
            // 根据新版本中的元素映射复制属性记录。
        }
    
        private function copyMethods(
            $oldVersionId,
            $newVersionId,
            $structureId
        ) {
            // 根据新版本中的元素映射复制方法定义。
        }
    
        private function copyRelations(
            $oldVersionId,
            $newVersionId,
            $structureId
        ) {
            // 根据新版本中的元素映射复制关系记录。
        }
    }

    这段程序展示版本创建的事务边界和调用结构,其中四个复制方法仍是待实现的工程接口,不能将其视为已经完成的数据复制程序。实际开发时,必须先建立旧元素ID与新元素ID的映射关系,再复制属性、方法和关系记录。特别是关系数据中的起始元素和目标元素,都必须替换为新版本中的元素ID。

    如果只是复制元素记录而没有同步替换关系引用,新版本的关系就可能继续指向旧版本元素,从而破坏版本隔离。

    结构版本创建完成后,需要进入结构变更阶段。变更程序不能直接绕过结构管理机制修改数据库,而应由结构管理服务统一处理。结构管理服务根据变更类型调用相应的数据访问程序,完成元素增加、元素删除、属性调整、方法更新和关系变更。

    为了使结构变更可以追溯,还应建立变更记录表。

    CREATE TABLE structure_change_logs (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        structure_id BIGINT UNSIGNED NOT NULL,
        version_id BIGINT UNSIGNED NOT NULL,
        change_type VARCHAR(50) NOT NULL,
        target_type VARCHAR(50) NOT NULL,
        target_code VARCHAR(100) DEFAULT NULL,
        change_description TEXT,
        before_data TEXT,
        after_data TEXT,
        operator VARCHAR(100) DEFAULT NULL,
        created_at DATETIME NOT NULL,
        KEY idx_change_version (
            structure_id,
            version_id
        )
    );

    变更记录用于保存结构调整的类型、目标对象、变更说明以及必要的变更前后数据。对于较大的结构数据,可以保存变更对象的标识和数据摘要,并将完整变更内容保存在专门的变更记录存储中。具体采用何种方式,需要根据数据规模和查询要求确定。

    结构变更记录不能替代结构版本。变更记录说明某个版本发生过什么变化,结构版本则保存某个时间点完整、可使用的结构内容。二者相互补充。

    结构版本发布时,需要经过完整性检查和数据验证。验证通过后,才能将版本状态调整为已发布,并更新结构定义主表中的current_version_id。

    版本发布应采用事务处理,确保版本状态和当前版本指针同步变更。若更新过程中发生异常,应回滚事务,不能出现版本已经标记为发布成功但主表仍指向旧版本,或者主表已经指向新版本而新版本尚未完成发布的情况。

    对于已经部署到个体运行环境中的结构版本,还需要保存部署时使用的版本标识。后台更新结构版本,并不意味着所有个体都应立即切换到新版本。个体是否更新,应结合任务状态、运行条件、方法兼容性和执行安全要求进行判断。对于正在执行关键任务的个体,可以继续使用原版本,待满足更新条件后再进行版本切换。

    这使结构版本管理与个体智能赋值、个体自主运行和中央控制形成明确的工程联系。后台负责结构版本的构建与发布,个体运行环境依据部署记录使用确定版本,中央控制根据任务和运行状态组织后续更新。

    7.5 结构完整性检查与数据验证程序

    结构数据能够被保存,并不代表结构定义就是完整和正确的。数据库只能保证部分基础约束,例如字段类型、唯一性和外键引用。结构本身还包含更高层次的逻辑关系,这些关系需要通过专门的结构验证程序进行检查。

    例如,某个结构版本中的元素可能缺少必要的标识;属性定义可能引用不存在的数据类型;方法定义可能缺少输入参数约定;关系记录可能指向已经删除的元素;方法实现标识可能没有对应的注册程序。这些问题即使能够通过数据库写入,也可能导致后续结构解析失败、知识能力构建错误或个体运行异常。

    因此,结构完整性检查必须同时覆盖数据记录层、对象关联层和结构逻辑层。

    数据记录层检查主要确认结构定义、结构版本、元素、属性、方法和关系是否具有必要字段,是否存在重复标识,是否满足数据类型和基本约束。

    对象关联层检查主要确认属性是否属于有效元素,方法是否属于有效元素,关系两端是否指向同一版本内存在的元素,结构版本是否属于正确的结构定义。

    结构逻辑层检查则需要根据具体结构定义的约束,判断元素之间的关系是否合理、必要元素是否齐全、属性是否满足定义要求、方法调用约定是否完整。

    结构验证程序应当独立于数据库Repository存在。Repository负责数据读取和保存,Validator负责判断结构数据是否满足规定。这样,后台无论通过管理界面、需求驱动构建程序还是其他内部程序创建结构,都必须经过同一套验证机制。

    拟定程序目录如下:

    app/
    └── Intelligence/
        └── Structure/
            ├── StructureValidator.php        # 结构完整性验证的统一入口
            ├── ElementValidator.php          # 检查元素标识、类型和定义完整性
            ├── AttributeValidator.php        # 检查属性类型、默认值和属性约束
            ├── RelationValidator.php         # 检查关系两端元素及关系约束
            ├── MethodValidator.php           # 检查方法定义、参数和实现引用
            ├── VersionValidator.php          # 检查版本归属、版本状态和版本引用
            └── ValidationResult.php          # 组织验证结果、错误和警告信息

    StructureValidator作为统一验证入口,不直接承担所有细节检查,而是组织各个验证程序执行。这样,新增结构元素类型、属性规则或关系类型时,可以扩展相应的验证程序,而不必不断扩大一个集中式验证类。

    验证结果需要区分错误和警告。错误表示结构不能通过当前验证,例如关系引用不存在、必要元素缺失、方法定义不完整等;警告表示结构可能存在风险,但是否允许发布需要结合具体应用要求判断。例如,某个可选属性没有设置默认值,未必意味着结构定义无效,但可能需要在后续运行时处理。

    统一验证入口可以设计为:

    <?php
    
    class StructureValidator
    {
        private $elementValidator;
        private $attributeValidator;
        private $relationValidator;
        private $methodValidator;
        private $versionValidator;
    
        public function __construct(
            ElementValidator $elementValidator,
            AttributeValidator $attributeValidator,
            RelationValidator $relationValidator,
            MethodValidator $methodValidator,
            VersionValidator $versionValidator
        ) {
            $this->elementValidator = $elementValidator;
            $this->attributeValidator = $attributeValidator;
            $this->relationValidator = $relationValidator;
            $this->methodValidator = $methodValidator;
            $this->versionValidator = $versionValidator;
        }
    
        public function validate($structure)
        {
            $errors = array();
            $warnings = array();
    
            $this->appendResult(
                $this->versionValidator->validate($structure),
                $errors,
                $warnings
            );
    
            $this->appendResult(
                $this->elementValidator->validate($structure),
                $errors,
                $warnings
            );
    
            $this->appendResult(
                $this->attributeValidator->validate($structure),
                $errors,
                $warnings
            );
    
            $this->appendResult(
                $this->relationValidator->validate($structure),
                $errors,
                $warnings
            );
    
            $this->appendResult(
                $this->methodValidator->validate($structure),
                $errors,
                $warnings
            );
    
            return array(
                'valid' => count($errors) === 0,
                'errors' => $errors,
                'warnings' => $warnings
            );
        }
    
        private function appendResult(
            $result,
            &$errors,
            &$warnings
        ) {
            if (!empty($result['errors'])) {
                $errors = array_merge(
                    $errors,
                    $result['errors']
                );
            }
    
            if (!empty($result['warnings'])) {
                $warnings = array_merge(
                    $warnings,
                    $result['warnings']
                );
            }
        }
    }

    上述程序明确了验证工作的组织关系。每一个专门验证器都需要提供统一的验证接口,返回错误和警告集合。统一验证入口负责汇总结果,不应在其中重复实现元素、属性、关系和方法的具体检查规则。

    例如,关系验证程序需要检查关系的两个端点是否都存在于当前结构版本中:

    <?php
    
    class RelationValidator
    {
        public function validate($structure)
        {
            $errors = array();
            $warnings = array();
    
            $elements = array();
    
            foreach ($structure['elements'] as $element) {
                $elements[$element['id']] = $element;
            }
    
            foreach ($structure['relations'] as $relation) {
    
                if (!isset(
                    $elements[$relation['source_element_id']]
                )) {
                    $errors[] = array(
                        'code' => 'RELATION_SOURCE_MISSING',
                        'message' => '关系起始元素不存在',
                        'relation' => $relation['relation_code']
                    );
                }
    
                if (!isset(
                    $elements[$relation['target_element_id']]
                )) {
                    $errors[] = array(
                        'code' => 'RELATION_TARGET_MISSING',
                        'message' => '关系目标元素不存在',
                        'relation' => $relation['relation_code']
                    );
                }
            }
    
            return array(
                'errors' => $errors,
                'warnings' => $warnings
            );
        }
    }

    这一示例检查关系端点是否存在。实际工程中还需要增加版本一致性检查、关系类型有效性检查、关系方向约束检查和关系数量约束检查。对于不允许形成循环的关系类型,还需要建立专门的图关系检查程序,不能将所有关系都简单地视为普通的两端引用。

    属性验证程序则需要检查属性数据类型是否属于系统允许的数据类型范围,必需属性是否具有完整定义,默认值是否符合属性类型,验证规则是否能够被相应的规则解析程序识别。方法验证程序需要检查方法标识、输入定义、输出定义和实现引用是否完整。若方法定义要求关联实际程序实现,则还必须通过方法注册表检查实现标识是否存在,且实现是否符合对应的调用约定。

    结构验证不仅发生在结构创建之后,也应当进入结构管理的整个生命周期。

    新结构创建时,后台需要检查基本结构定义是否完整;结构元素增加或属性修改时,需要执行局部数据验证;结构关系调整时,需要检查关系引用和关系约束;结构版本发布前,需要执行完整结构验证;结构部署到个体运行环境前,还需要检查个体运行环境是否支持该结构版本所要求的方法和数据类型。

    因此,结构验证存在两个不同层次。第一个层次是结构自身的完整性验证,确认结构定义内部没有缺失、冲突和无效引用。第二个层次是运行适配验证,确认该结构在指定的个体运行环境中能够被正确解析和调用。结构本身有效,不代表它一定能够在所有运行环境中执行。

    结构验证的程序调用关系可以表示为:

    结构创建或结构变更
            │
            ▼
    StructureManager
            │
            ▼
    StructureLoader
            │
            ▼
    StructureValidator
            │
            ├── VersionValidator
            │
            ├── ElementValidator
            │
            ├── AttributeValidator
            │
            ├── RelationValidator
            │
            └── MethodValidator
            │
            ▼
    验证结果
            │
            ├── 存在错误:拒绝发布,返回错误信息
            │
            ├── 存在警告:根据发布规则处理
            │
            └── 验证通过:允许进入版本发布流程

    这里的验证流程是结构管理的工程约束。任何程序只要需要创建或变更结构定义,就不能绕过统一验证入口直接将未验证数据设置为当前发布版本。

    结构数据管理的统一调用与持久化流程

    完成数据表设计、元素关联存储、关系和方法持久化、版本管理以及验证程序之后,还需要将这些程序组织为统一的数据管理流程。否则,各个Repository和Validator虽然分别存在,但无法构成完整的结构管理机制。

    在WSaiOS智能控制后台中,结构数据管理应由结构管理服务统一组织。上层的需求驱动智能、知识结构化和知识能力构建程序提出结构创建或调整要求,结构管理服务负责组织结构数据的读取、修改、验证、保存和版本发布。

    拟定的程序目录如下:

    app/
    ├── Intelligence/
    │   └── Structure/
    │       ├── StructureManager.php          # 统一组织结构创建、变更、验证和发布
    │       ├── StructureLoader.php           # 根据结构标识和版本读取完整结构
    │       ├── StructureValidator.php        # 执行结构完整性与逻辑约束检查
    │       ├── StructureVersionManager.php   # 创建结构版本并管理版本变更
    │       └── StructurePublisher.php        # 验证通过后执行结构版本发布
    │
    ├── Repositories/
    │   └── Structure/
    │       ├── StructureRepository.php       # 结构定义基本数据持久化
    │       ├── StructureVersionRepository.php # 结构版本数据持久化
    │       ├── ElementRepository.php         # 结构元素数据持久化
    │       ├── AttributeRepository.php       # 属性定义数据持久化
    │       ├── RelationRepository.php        # 结构关系数据持久化
    │       ├── MethodRepository.php          # 方法定义数据持久化
    │       └── StructureChangeRepository.php # 结构变更记录持久化
    │
    └── Runtime/
        └── StructureCache.php                # 管理已加载结构的运行缓存

    StructureManager是结构数据管理的业务组织入口,但不直接承担所有数据库操作。它调用版本管理程序创建草稿版本,调用数据访问程序保存元素、属性、方法和关系,调用加载程序重新组织完整结构,再调用验证程序检查数据,最后交由发布程序更新结构版本状态。

    其基本调用关系如下:

    WSaiOS智能控制后台
            │
            ▼
    需求驱动 / 知识结构化 / 知识能力构建
            │
            ▼
    StructureManager
            │
            ├── StructureVersionManager
            │       └── StructureVersionRepository
            │
            ├── ElementRepository
            ├── AttributeRepository
            ├── RelationRepository
            ├── MethodRepository
            │
            ▼
    StructureLoader
            │
            ▼
    StructureValidator
            │
            ▼
    StructurePublisher
            │
            ├── 更新结构版本状态
            ├── 更新当前版本指针
            └── 记录结构变更
            │
            ▼
    StructureCache
            │
            ▼
    后台结构解析与智能运行程序

    缓存并不是结构数据的权威存储位置。数据库保存结构定义及其版本,缓存只是为了减少运行时重复读取和解析。缓存必须以结构标识和版本标识作为基本定位依据,不能只使用结构名称作为缓存键。结构发布后,需要使旧版本的缓存失效,或者保留旧版本缓存供仍在使用旧版本的个体继续运行。

    结构数据管理还需要处理数据库事务与程序调用之间的一致性问题。结构创建和版本复制属于需要事务保护的操作。结构发布也需要保证版本状态和当前版本指针同步更新。对于涉及多个数据表的结构修改,不能分别执行互不关联的写入操作,否则一旦某个步骤失败,就可能留下不完整结构。

    在工程实施时,还应根据实际数据库引擎确认事务支持、外键约束、索引规则和字段类型。尤其是结构元素ID映射、跨表版本一致性和结构发布事务,需要在实际数据库中验证,不能仅依靠程序约定。

    本章小结

    结构定义与结构数据管理解决的是结构智能工程中的持久化和持续维护问题。结构定义主表确定结构身份,结构版本表保存不同阶段形成的结构内容,结构元素、属性、方法和关系数据表共同表达具体结构的内部组成。通过将结构定义与运行实例数据分离,将方法定义与方法实现分离,后台能够在不改变结构基本语义的情况下,持续扩展和调整结构内容。

    结构版本管理使结构变更不再依赖对当前数据的直接覆盖。每次调整都可以形成新的结构版本,并通过元素ID映射、关联数据复制、变更记录和事务控制,保持新旧版本之间的独立性。结构完整性检查与数据验证程序则负责发现结构缺失、引用错误、关系冲突和方法定义不完整等问题,为结构发布和后续运行提供数据依据。

    从整个WSaiOS工程来看,结构数据管理不是独立于智能控制后台的普通数据库管理工作。需求驱动智能提出结构调整要求,知识结构化机制形成新的结构定义,知识能力构建机制依据结构组织能力数据,结构管理程序负责将这些结构内容持久化、版本化和验证。完成验证的结构版本,才可以进入后续结构解析、能力构建、个体智能赋值和自主运行环节。

    由此,结构定义不再只是程序内部的一组数据对象,而成为能够持续创建、保存、修改、验证、发布和追溯的工程数据基础。下一章将进一步讨论结构解析与智能运行基础,重点研究后台如何从已保存的结构定义中恢复结构对象,建立结构元素之间的关系,并将结构数据交给智能运行程序处理。

Leave a Reply

Your email address will not be published. Required fields are marked *

客服咨询
● 欢迎咨询与合作
您好!欢迎咨询。 我可以帮助您了解人工智能技术研发、智能软件系统开发、网站建设、搜索优化及项目定制等相关信息。 请问有什么可以帮您?
免费申请
请填写以下信息,方便我们进一步沟通。
欢迎咨询 AI 系统开发、网站建设、搜索优化、项目定制合作
电话:15089196448
邮箱:1602401899@qq.com
地址:陕西省渭南市
服务时间:周一至周五 09:00 - 18:00 | 7×24小时技术值守