标签与类型 #

标签作用：
├── 分类顶点和边
├── 加速查询过滤
├── 组织数据结构
├── 提供语义信息
└── 支持多标签

标签特点：
├── 字符串类型
├── 区分大小写
├── 可有多个标签
├── 用于过滤和查询
└── 命名有规范

顶点标签示例：
┌─────────────────────────┐
│  [person] [employee]    │  ← 多标签
│─────────────────────────│
│  name: "Tom"            │
│  age: 30                │
└─────────────────────────┘

边标签示例：
┌─────┐                    ┌─────┐
│     │────[knows]────────▶│     │
│     │    since: 2020     │     │
└─────┘                    └─────┘

// 创建带标签的顶点
g.addV('person')

// 创建带多个标签的顶点
g.addV('person').addV('employee')

// Neptune多标签方式
g.addV('person').property('~label', 'person:employee')

// 获取顶点标签
g.V('1').label()

// 获取所有标签
g.V().label().dedup()

// 按标签查询
g.V().hasLabel('person')

// 按多标签查询
g.V().hasLabel('person', 'employee')

// 统计各标签数量
g.V().groupCount().by(label)

// 精确匹配
g.V().hasLabel('person')

// 多标签匹配
g.V().hasLabel('person', 'employee')

// 不匹配
g.V().has(label, neq('person'))

// 使用within
g.V().has(label, within('person', 'product', 'order'))

// 创建带标签的边
g.addE('knows').from(V('1')).to(V('2'))

// 创建带属性的边标签
g.addE('knows').
  from(V('1')).
  to(V('2')).
  property('since', 2020)

// 获取边标签
g.E('e1').label()

// 获取所有边标签
g.E().label().dedup()

// 按标签查询
g.E().hasLabel('knows')

// 按多标签查询
g.E().hasLabel('knows', 'follows')

// 统计各边标签数量
g.E().groupCount().by(label)

// 按标签遍历出边
g.V('1').out('knows')

// 按标签遍历入边
g.V('1').in('knows')

// 按标签遍历双向边
g.V('1').both('knows')

// 多标签遍历
g.V('1').out('knows', 'follows')

顶点标签命名规范：
├── 使用名词
├── 使用小写
├── 使用下划线分隔
├── 保持语义清晰
└── 避免特殊字符

推荐：
├── person（人）
├── product（产品）
├── order（订单）
├── user_account（用户账户）
└── blog_post（博客文章）

避免：
├── Person（大写）
├── userAccount（驼峰）
├── user-account（连字符）
└── u（缩写）

边标签命名规范：
├── 使用动词
├── 使用小写
├── 使用下划线分隔
├── 表示关系语义
└── 考虑方向性

推荐：
├── knows（认识）
├── follows（关注）
├── likes（喜欢）
├── works_for（工作于）
├── purchased（购买）
└── belongs_to（属于）

避免：
├── Knows（大写）
├── isFriend（驼峰）
├── relation（太通用）
└── edge1（无意义）

多标签用途：
├── 表示多种分类
├── 支持多维度查询
├── 实现角色继承
└── 灵活的数据组织

// Neptune使用冒号分隔多标签
g.addV('person').property('~label', 'person:employee:manager')

// 查询多标签
g.V().hasLabel('person')      // 匹配包含person标签
g.V().hasLabel('employee')    // 匹配包含employee标签
g.V().hasLabel('manager')     // 匹配包含manager标签

// 获取所有标签
g.V('1').label()  // 返回: "person:employee:manager"

多标签设计原则：
├── 标签之间有层次关系
├── 避免过多标签（建议不超过5个）
├── 保持标签语义独立
└── 考虑查询模式

用户多标签示例：
├── person（基础标签）
├── user（系统用户）
├── employee（员工）
├── manager（管理者）
└── admin（管理员）

产品多标签示例：
├── product（基础标签）
├── electronics（电子产品）
├── smartphone（智能手机）
└── apple_product（苹果产品）

PREFIX ex: <http://example.org/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

INSERT DATA {
  ex:Tom rdf:type ex:Person .
  ex:Jerry rdf:type ex:Person .
}

PREFIX ex: <http://example.org/>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>

# 定义类型层次
INSERT DATA {
  ex:Employee rdfs:subClassOf ex:Person .
  ex:Manager rdfs:subClassOf ex:Employee .
  
  ex:Tom rdf:type ex:Manager .
}

PREFIX ex: <http://example.org/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>

# 查询所有Person实例（包括子类）
SELECT ?person
WHERE {
  ?person rdf:type/rdfs:subClassOf* ex:Person .
}

# 查询直接类型
SELECT ?person
WHERE {
  ?person rdf:type ex:Person .
}

// 查看所有顶点标签
g.V().label().dedup()

// 查看所有边标签
g.E().label().dedup()

// 统计标签使用情况
g.V().groupCount().by(label)
g.E().groupCount().by(label)

// 各标签顶点数量
g.V().groupCount().by(label).order(local).by(values, desc)

// 各标签边数量
g.E().groupCount().by(label).order(local).by(values, desc)

// 标签属性统计
g.V().hasLabel('person').properties().groupCount().by(key)

标签索引优势：
├── 加速标签过滤查询
├── 减少全图扫描
├── 优化查询计划
└── 提高查询性能

// 使用标签过滤（推荐）
g.V().hasLabel('person').has('name', 'Tom')

// 避免全图扫描
g.V().has('name', 'Tom')  // 慢，扫描所有顶点

// 使用标签+属性组合
g.V().hasLabel('person').has('age', gt(25))

优化建议：
├── 总是使用标签过滤
├── 选择性高的标签优先
├── 合理使用多标签
├── 避免过多标签
└── 监控查询性能

设计原则：
├── 语义清晰
├── 层次分明
├── 易于理解
├── 便于查询
└── 考虑扩展

命名约定：
├── 统一使用小写
├── 使用下划线分隔
├── 顶点用名词
├── 边用动词
└── 保持一致性

标签数量建议：
├── 单标签：简单场景
├── 2-3个标签：中等复杂度
├── 最多5个标签：复杂场景
└── 避免过多标签

// 用户标签
g.addV('user').property('~label', 'user:person:member').
  property('name', 'Tom')

// 内容标签
g.addV('post').property('~label', 'post:content:published').
  property('title', 'Hello World')

// 关系标签
g.addE('follows').from(V('user1')).to(V('user2'))
g.addE('likes').from(V('user1')).to(V('post1'))
g.addE('comments').from(V('user1')).to(V('post1'))

// 商品标签
g.addV('product').property('~label', 'product:electronics:smartphone').
  property('name', 'iPhone 15')

// 用户标签
g.addV('customer').property('~label', 'customer:user:vip').
  property('name', 'Tom')

// 订单标签
g.addV('order').property('~label', 'order:transaction:completed').
  property('orderId', 'ORD001')

// 关系标签
g.addE('purchased').from(V('customer1')).to(V('order1'))
g.addE('contains').from(V('order1')).to(V('product1'))
g.addE('related').from(V('product1')).to(V('product2'))

PREFIX ex: <http://example.org/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>

# 定义类型层次
INSERT DATA {
  ex:Person rdf:type rdfs:Class .
  ex:Employee rdfs:subClassOf ex:Person .
  ex:Manager rdfs:subClassOf ex:Employee .
  
  ex:Organization rdf:type rdfs:Class .
  ex:Company rdfs:subClassOf ex:Organization .
  
  ex:worksFor rdf:type rdf:Property .
  ex:manages rdf:type rdf:Property .
}

# 创建实例
INSERT DATA {
  ex:Tom rdf:type ex:Manager ;
         ex:worksFor ex:ACME .
         
  ex:ACME rdf:type ex:Company .
}