Gentics Mesh（开发版本）

简介

此图示用于记录 Gentics Mesh 图结构。

根树

MeshRootImpl 顶点是网格图数据结构的根。整个图中仅存在一个 MeshRootImpl。各种聚合顶点连接到网格根顶点。

CREATE (meshRoot:MeshRootImpl { name: 'MeshRootImpl'}),

 (nodeRoot:NodeRootImpl { name: 'NodeRootImpl'}),
 (meshRoot)-[:HAS_NODE_ROOT]->(nodeRoot),

 (tagRoot:TagRootImpl { name: 'TagRootImpl'}),
 (meshRoot)-[:HAS_TAG_ROOT]->(tagRoot),

 (tagFamilyRoot:TagFamilyRootImpl { name: 'TagFamilyRootImpl'}),
 (meshRoot)-[:HAS_TAGFAMILY_ROOT]->(tagFamilyRoot),

 (projectRoot:ProjectRootImpl { name: 'ProjectRootImpl'}),
 (meshRoot)-[:HAS_PROJECT_ROOT]->(projectRoot),

 (userRoot:UserRootImpl { name: 'UserRootImpl'}),
 (meshRoot)-[:HAS_USER_ROOT]->(userRoot),

 (groupRoot:GroupRootImpl { name: 'GroupRootImpl'}),
 (meshRoot)-[:HAS_GROUP_ROOT]->(groupRoot),

 (roleRoot:RoleRootImpl { name: 'RoleRootImpl'}),
 (meshRoot)-[:HAS_ROLE_ROOT]->(roleRoot),

 (changelogRoot:ChangelogRootImpl { name: 'ChangelogRootImpl'}),
 (meshRoot)-[:HAS_CHANGELOG_ROOT]->(changelogRoot),

 (languageRoot:LanguageRootImpl { name: 'LanguageRootImpl'}),
 (meshRoot)-[:HAS_LANGUAGE_ROOT]->(languageRoot),

 (sqRoot:SearchQueueRootImpl { name: 'SearchQueueRootImpl'}),
 (meshRoot)-[:HAS_SEARCH_QUEUE_ROOT]->(sqRoot),

 (schemaRoot:SchemaContainerRootImpl { name: 'SchemaContainerRootImpl'}),
 (meshRoot)-[:HAS_ROOT_SCHEMA]->(schemaRoot),

 (microschemaRoot:MicroschemaContainerRootImpl { name: 'MicroschemaContainerRootImpl'}),
 (meshRoot)-[:HAS_MICROSCHEMA_ROOT]->(microschemaRoot)

节点根

有多个节点根顶点。一个连接到中央网格根，每个项目也有自己的节点根顶点。

MATCH (n) DETACH DELETE n;
CREATE (meshRoot:MeshRootImpl { name: 'MeshRootImpl'}),
 (node1:NodeImpl { name: 'NodeImpl' }),
 (node2:NodeImpl { name: 'NodeImpl' }),
 (node3:NodeImpl { name: 'NodeImpl' }),
 (centralNodeRoot:NodeRootImpl { name: 'NodeRootImpl'}),
 (projectNodeRoot:NodeRootImpl { name: 'NodeRootImpl'}),
 (meshRoot)-[:HAS_NODE_ROOT]->(centralNodeRoot),
 (projectRoot:ProjectRootImpl { name: 'ProjectRootImpl'}),
 (meshRoot)-[:HAS_PROJECT_ROOT]->(projectRoot),
 (project:ProjectImpl { name: 'ProjectImpl'}),
 (projectRoot)-[:HAS_PROJECT]->(project),
 (project)-[:HAS_NODE_ROOT]->(projectNodeRoot),
 (projectNodeRoot)-[:HAS_NODE]->(node1),
 (projectNodeRoot)-[:HAS_NODE]->(node2),
 (centralNodeRoot)-[:HAS_NODE]->(node1),
 (centralNodeRoot)-[:HAS_NODE]->(node2),
 (centralNodeRoot)-[:HAS_NODE]->(node3);

标签根

有多个标签根顶点。一个中央根连接到网格根顶点 (MeshRootImpl)，并且为每个标签族创建了额外的根。

MATCH (n) DETACH DELETE n;
CREATE (meshRoot:MeshRootImpl { name: 'MeshRootImpl'}),
 (tagRoot:TagRootImpl { name: 'TagRootImpl'}),
 (tag:TagImpl { name: 'TagImpl'}),
 (tagRoot)-[:HAS_TAG]->(tag),
 (meshRoot)-[:HAS_TAG_ROOT]->(tagRoot);

标签族根

有多个标签族根顶点。一个中央根连接到网格根顶点，并且为每个项目创建了额外的标签族根顶点。

MATCH (n) DETACH DELETE n;
CREATE (meshRoot:MeshRootImpl { name: 'MeshRootImpl'}),
 (tagfamilyRoot:TagFamilyRootImpl { name: 'TagFamilyRootImpl'}),
 (tagFamily:TagFamilyImpl { name: 'TagFamilyImpl'}),
 (tag1:TagImpl { name: 'TagImpl'}),
 (tag1)-[:HAS_TAGFAMILY_ROOT]->(tagFamily),
 (tag2:TagImpl { name: 'TagImpl'}),
 (tag2)-[:HAS_TAGFAMILY_ROOT]->(tagFamily),
 (tagFamily)-[:HAS_TAG]->(tag1),
 (tagFamily)-[:HAS_TAG]->(tag2),
 (tagfamilyRoot)-[:HAS_TAG_FAMILY]->(tagFamily),
 (meshRoot)-[:HAS_TAGFAMILY_ROOT]->(tagfamilyRoot),
 (projectTagfamilyRoot:TagFamilyRootImpl { name: 'TagFamilyRootImpl'}),
 (projectRoot:ProjectRootImpl { name: 'ProjectRootImpl'}),
 (meshRoot)-[:HAS_PROJECT_ROOT]->(projectRoot),
 (project:ProjectImpl { name: 'ProjectImpl'}),
 (projectRoot)-[:HAS_PROJECT]->(project),
 (project)-[:HAS_TAGFAMILY_ROOT]->(projectTagfamilyRoot),
 (projectTagfamilyRoot)-[:HAS_TAG_FAMILY]->(tagFamily);

标签与其他元素（节点、项目）的关系

MATCH (n) DETACH DELETE n;
CREATE (tag:TagImpl { name: 'TagImpl'}),
 (node:NodeImpl {name: 'NodeImpl'}),
 (project:ProjectImpl {name: 'ProjectImpl'}),
 (user1:UserImpl {name: 'UserImpl'}),
 (user2:UserImpl {name: 'UserImpl'}),
 (tag)<-[:HAS_TAG]-(node),
 (tag)-[:ASSIGNED_TO_PROJECT]->(project),
 (tag)-[:HAS_EDITOR]->(user1),
 (tag)-[:HAS_CREATOR]->(user2);

项目根

项目根顶点用于聚合所有项目顶点。

MATCH (n) DETACH DELETE n;
CREATE (meshRoot:MeshRootImpl { name: 'MeshRootImpl'}),
 (project:ProjectImpl { name: 'ProjectImpl'}),
 (projectRoot:ProjectRootImpl { name: 'ProjectRootImpl'}),
 (projectRoot)-[:HAS_PROJECT]->(project),
 (node:NodeImpl {name: 'NodeImpl'}),
 (nodeRoot:NodeRootImpl {name: 'NodeRootImpl'}),
 (language:LanguageImpl {name: 'LanguageImpl'}),
 (project)-[:HAS_LANGUAGE]->(language),
 (tagFamilyRoot:TagFamilyRootImpl {name: 'TagFamilyRootImpl'}),
 (schemaRoot:ProjectSchemaContainerRootImpl {name: 'ProjectSchemaContainerRootImpl'}),
 (microschemaRoot:ProjectMicroschemaContainerRootImpl {name: 'ProjectMicroschemaContainerRootImpl'}),
 (project)-[:HAS_SCHEMA_ROOT]->(schemaRoot),
 (project)-[:HAS_MICROSCHEMA_ROOT]->(microschemaRoot),
 (project)-[:HAS_TAGFAMILY_ROOT]->(tagFamilyRoot),
 (project)-[:HAS_BASE_NODE]->(node),
 (project)-[:HAS_NODE_ROOT]->(nodeRoot),
 (nodeRoot)-[:HAS_NODE]->(node),
 (meshRoot)-[:HAS_PROJECT_ROOT]->(projectRoot);

用户/组/角色根

每个元素类型（用户、角色、组）都有自己的根聚合顶点。用户分配给组，角色分配给组。额外的 ASSIGNED_TO_ROLE 边是快捷边，可以提高性能。

MATCH (n) DETACH DELETE n;
CREATE  (meshRoot:MeshRootImpl { name: 'MeshRootImpl'}),

 (user:UserImpl { name: 'UserImpl' }),
 (userRoot:UserRootImpl { name: 'UserRootImpl'}),
 (meshRoot)-[:HAS_USER_ROOT]->(userRoot),
 (userRoot)-[:HAS_USER]->(user),

 (groupRoot:GroupRootImpl { name: 'GroupRootImpl'}),
 (group:GroupImpl { name: 'GroupImpl' }),
 (meshRoot)-[:HAS_GROUP_ROOT]->(groupRoot),
 (groupRoot)-[:HAS_GROUP]->(group),

 (roleRoot:RoleRootImpl { name: 'RoleRootImpl'}),
 (role:RoleImpl { name: 'RoleImpl' }),
 (meshRoot)-[:HAS_ROLE_ROOT]->(roleRoot),
 (roleRoot)-[:HAS_ROLE]->(role),

 (user)-[:ASSIGNED_TO_ROLE]->(role),
 (group)<-[:HAS_USER]-(user),
 (group)<-[:HAS_ROLE]-(role);

用户节点引用

用户可以引用单个节点以构建 nodeReference 信息。

权限

Gentics Mesh 使用基于文档的权限系统。权限在角色和网格元素（例如标签、项目、节点、标签族）之间创建。

MATCH (n) DETACH DELETE n;
CREATE (user:UserImpl { name: 'UserImpl' }),
 (node1:NodeImpl { name: 'NodeImpl' }),
 (node2:NodeImpl { name: 'NodeImpl' }),
 (node3:NodeImpl { name: 'NodeImpl' }),
 (node4:NodeImpl { name: 'NodeImpl' }),
 (node5:NodeImpl { name: 'NodeImpl' }),
 (node6:NodeImpl { name: 'NodeImpl' }),
 (group:GroupImpl { name: 'GroupImpl' }),
 (role:RoleImpl { name: 'RoleImpl' }),
 (user)-[:ASSIGNED_TO_ROLE]->(role),
 (group)<-[:HAS_USER]-(user),
 (group)<-[:HAS_ROLE]-(role),
 (node1)<-[:HAS_READ_PERMISSION]-(role),
 (node2)<-[:HAS_CREATE_PERMISSION]-(role),
 (node3)<-[:HAS_UPDATE_PERMISSION]-(role),
 (node4)<-[:HAS_DELETE_PERMISSION]-(role),
 (node5)<-[:HAS_PUBLISH_PERMISSION]-(role),
 (node6)<-[:HAS_READ_PUBLISHED_PERMISSION]-(role);

模式根

MATCH (n) DETACH DELETE n;
CREATE (meshRoot:MeshRootImpl { name: 'MeshRootImpl'}),
 (schemaRoot:SchemaContainerRootImpl { name: 'SchemaContainerRootImpl'}),
 (meshRoot)-[:HAS_ROOT_SCHEMA]->(schemaRoot),
 (sc:SchemaContainerImpl { name: 'SchemaContainerImpl'}),
 (scv1:SchemaContainerVersionImpl { name: 'SchemaContainerVersionImpl'}),
 (sc)-[:HAS_LATEST_VERSION]->(scv1),
 (node:NodeImpl { name: 'NodeImpl'}),
 (nodeFC:NodeGraphFieldContainerImpl { name: 'NodeGraphFieldContainerImpl'}),
 (schemaRoot)-[:HAS_SCHEMA_CONTAINER_ITEM]->(sc),
 (nodeFC)-[:HAS_SCHEMA_CONTAINER_VERSION]->(scv1),
 (node)-[:HAS_FIELD_CONTAINER]->(nodeFC);

变更日志根

变更日志根聚合顶点用于列出所有应用的变更日志条目。每个连接的更改顶点都包含有关执行的图变更日志操作的信息。这样，网格安装就可以确定哪些更改已执行。

MATCH (n) DETACH DELETE n;
CREATE (meshRoot:MeshRootImpl { name: 'MeshRootImpl'}),
 (changelogRoot:ChangelogRootImpl { name: 'ChangelogRootImpl'}),
 (change1:Change {name: 'Change'}),
 (change2:Change {name: 'Change'}),
 (change3:Change {name: 'Change'}),
 (changelogRoot)-[:HAS_CHANGE]->(change1),
 (changelogRoot)-[:HAS_CHANGE]->(change2),
 (changelogRoot)-[:HAS_CHANGE]->(change3),
 (meshRoot)-[:HAS_CHANGELOG_ROOT]->(changelogRoot);

带有字段的节点

节点可以有多个图字段容器。图字段容器表示特定语言、版本和版本的节点内容。边 HAS_FIELD_CONTAINER 包含其他信息，以便识别语言、版本和字段容器的类型。字段容器可以表示最新的草稿版本、当前发布的版本或图字段容器的任何旧版本。

HAS_FIELD_CONTAINER：边类型、版本 UUID、语言标签

MATCH (n) DETACH DELETE n;
CREATE (node:NodeImpl { name: 'NodeImpl'}),
 (nodeFC1:NodeGraphFieldContainerImpl { name: 'NodeGraphFieldContainerImpl' }),
 (nodeFC2:NodeGraphFieldContainerImpl { name: 'NodeGraphFieldContainerImpl' }),
 (schemaVersion:SchemaContainerVersionImpl { name: 'SchemaContainerVersionImpl'}),
 (nodeFC1)-[:HAS_SCHEMA_CONTAINER_VERSION]->(schemaVersion),
 (nodeFC2)-[:HAS_SCHEMA_CONTAINER_VERSION]->(schemaVersion),
 (node)-[:HAS_FIELD_CONTAINER]->(nodeFC1),
 (node)-[:HAS_FIELD_CONTAINER]->(nodeFC2);

节点关系

标签与其他元素（节点、项目）的关系

MATCH (n) DETACH DELETE n;
CREATE (tag:TagImpl { name: 'TagImpl'}),
 (node:NodeImpl {name: 'NodeImpl'}),
 (nodeFC:NodeGraphFieldContainerImpl { name: 'NodeGraphFieldContainerImpl' }),
 (project:ProjectImpl {name: 'ProjectImpl'}),
 (user1:UserImpl {name: 'UserImpl'}),
 (user2:UserImpl {name: 'UserImpl'}),
 (tag)<-[:HAS_TAG]-(node),
 (tag)-[:ASSIGNED_TO_PROJECT]->(project),
 (node)-[:ASSIGNED_TO_PROJECT]->(project),
 (nodeFC)-[:HAS_EDITOR]->(user1),
 (nodeFC)-[:HAS_CREATOR]->(user2);

节点字段

网格中有三种类型的字段元素。

基本字段类型，例如
- StringFieldImpl
- DateFieldImpl
- NumberFieldImpl
- BooleanFieldImpl
- HtmlFieldImpl

这些字段类型映射到字段容器的属性，因此不需要额外的顶点、边。

引用字段类型，例如
- MicronodeField
- NodeField

这些字段类型创建到引用元素的边（例如：NodeImpl 顶点或 MicronodeImpl）。

复杂字段类型，例如
- 各种列表

这些字段类型需要额外的顶点来存储信息。

MATCH (n) DETACH DELETE n;
CREATE (nodeFC:NodeGraphFieldContainerImpl { name: 'NodeGraphFieldContainerImpl' }),
 (node:NodeImpl { name: 'NodeImpl'}),
 (node2:NodeImpl { name: 'NodeImpl'}),
 (node3:NodeImpl { name: 'NodeImpl'}),
 (micronode:MicronodeImpl { name: 'MicronodeImpl'}),
 (nodeFC)-[:HAS_LIST]->(micronodeList:MicronodeGraphFieldListImpl { name: 'MicronodeGraphFieldListImpl'}),
 (nodeFC)-[:HAS_LIST]->(htmlList:HtmlGraphFieldListImpl { name: 'HtmlGraphFieldListImpl'}),
 (nodeFC)-[:HAS_LIST]->(dateList:DateGraphFieldListImpl { name: 'DateGraphFieldListImpl'}),
 (nodeFC)-[:HAS_LIST]->(booleanList:BooleanGraphFieldListImpl { name: 'BooleanGraphFieldListImpl'}),
 (nodeFC)-[:HAS_LIST]->(numberList:NumberGraphFieldListImpl { name: 'NumberGraphFieldListImpl'}),
 (nodeFC)-[:HAS_LIST]->(stringList:StringGraphFieldListImpl { name: 'StringGraphFieldListImpl'}),
 (nodeFC)-[:HAS_LIST]->(nodeList:NodeGraphFieldListImpl { name: 'NodeGraphFieldListImpl'}),
 (nodeList)-[:HAS_ITEM]->(node2),
 (nodeList)-[:HAS_ITEM]->(node3),
 (nodeFC)-[:HAS_FIELD {name: 'NodeGraphFieldImpl'}]->(node),
 (nodeFC)-[:HAS_FIELD {name: 'MicronodeGraphFieldImpl'}]->(micronode),
 (binaryField:BinaryGraphFieldImpl { name: 'BinaryGraphFieldImpl'}),
 (nodeFC)-[:HAS_FIELD]->(binaryField),
 (node)-[:HAS_FIELD_CONTAINER]->(nodeFC);

模式版本

MATCH (n) DETACH DELETE n;
CREATE (sc:SchemaContainerImpl { name: 'SchemaContainerImpl'}),
 (scv1:SchemaContainerVersionImpl { name: 'SchemaContainerVersionImpl'}),
 (scv2:SchemaContainerVersionImpl { name: 'SchemaContainerVersionImpl'}),
 (change1:AddFieldChangeImpl { name: 'AddFieldChangeImpl'}),
 (change2:AddFieldChangeImpl { name: 'AddFieldChangeImpl'}),
 (change3:UpdateSchemaChangeImpl { name: 'UpdateSchemaChangeImpl'}),
 (scv1)-[:HAS_CHANGE]->(change1),
 (change1)-[:HAS_CHANGE]->(change2),
 (change2)-[:HAS_CHANGE]->(change3),
 (change1)-[:HAS_SCHEMA_CONTAINER]->(scv1),
 (sc)-[:HAS_PARENT_CONTAINER]->(scv2),
 (sc)-[:HAS_PARENT_CONTAINER]->(scv1),
 (scv1)-[:HAS_VERSION]->(scv2),
 (sc)-[:HAS_LATEST_VERSION]->(scv1);

SchemaContainerVersionImpl：版本

版本

版本是特定 SchemaContainerVersionImpl 顶点的捆绑。

MATCH (n) DETACH DELETE n;
CREATE (scv1:SchemaContainerVersionImpl { name: 'SchemaContainerVersionImpl'}),
 (scv2:SchemaContainerVersionImpl { name: 'SchemaContainerVersionImpl'}),
 (release:ReleaseImpl { name: 'ReleaseImpl' }),
 (release)-[:HAS_VERSION]->(scv1),
 (release)-[:HAS_VERSION]->(scv2),
 (releaseRoot:ReleaseRootImpl { name: 'ReleaseRootImpl'}),
 (releaseRoot)-[:HAS_INITIAL_RELEASE]->(release),
 (releaseRoot)-[:HAS_RELEASE]->(release),
 (releaseRoot)-[:HAS_LATEST_RELEASE]->(release),
 (projectRoot:ProjectRootImpl { name: 'ProjectRootImpl'}),
 (project:ProjectImpl { name: 'ProjectImpl'}),
 (project)-[:HAS_RELEASE_ROOT]->(releaseRoot),
 (projectRoot)-[:HAS_PROJECT]->(project),
 (meshRoot:MeshRootImpl { name: 'MeshRootImpl'}),
 (meshRoot)-[:HAS_PROJECT_ROOT]->(projectRoot);

节点版本控制

显示的节点有两个字段容器。一个表示节点内容的最新版本，另一个表示以前的版本。其中一个字段容器连接到两个字段顶点。这意味着旧字段 (DateGraphFieldListImpl) 在先前的修订版中没有更改，因此被重用。如果在两个版本之间的字段内容中检测到修改，则日期列表字段将不会被重用。

MATCH (n) DETACH DELETE n;
CREATE (node:NodeImpl { name: 'NodeImpl'}),
 (nodeFC1:NodeGraphFieldContainerImpl { name: 'NodeGraphFieldContainerImpl' }),
 (nodeFC2:NodeGraphFieldContainerImpl { name: 'NodeGraphFieldContainerImpl' }),
 (dateList:DateGraphFieldListImpl { name: 'DateGraphFieldListImpl'}),
 (nodeFC1)-[:HAS_LIST]->(dateList),
 (stringList:StringGraphFieldListImpl { name: 'StringGraphFieldListImpl'}),
 (nodeFC2)-[:HAS_LIST]->(stringList),
 (nodeFC1)-[:HAS_LIST]->(dateList),
 (nodeFC2)-[:HAS_LIST]->(dateList),
 (node)-[:HAS_FIELD_CONTAINER]->(nodeFC1),
 (node)-[:HAS_FIELD_CONTAINER]->(nodeFC2);

节点层次结构

项目节点树结构使用 HAS_PARENT_NODE 关系构建。

MATCH (n) DETACH DELETE n;
CREATE (node:NodeImpl { name: 'NodeImpl'}),
 (childNode1:NodeImpl { name: 'NodeImpl'}),
 (childNode2:NodeImpl { name: 'NodeImpl'}),
 (subchildNode1:NodeImpl { name: 'NodeImpl'}),
 (subchildNode2:NodeImpl { name: 'NodeImpl'}),
 (node)<-[:HAS_PARENT_NODE]-(childNode1),
 (node)<-[:HAS_PARENT_NODE]-(childNode2),
 (childNode1)<-[:HAS_PARENT_NODE]-(subchildNode1),
 (childNode1)<-[:HAS_PARENT_NODE]-(subchildNode2),
 (project:ProjectImpl { name: 'ProjectImpl'}),
 (basenode:NodeImpl {name: 'NodeImpl'}),
 (basenode)<-[:HAS_PARENT_NODE]-(node),
 (project)-[:HAS_BASE_NODE]->(basenode);

此页面是否有帮助？

GraphGists