SurrealDB 深度解析：Rust 打造的六合一多模型数据库如何用 Record Links + 向量检索 + ACID 事务让 AI Agent 的「记忆」不再碎片化——从 SurrealQL 语法到生产级知识图谱实战的完整指南

一、引言：AI Agent 的「数据碎片化」困境

2026 年，AI Agent 已经从实验室走进了生产环境。无论是自动化客服、代码生成助手，还是企业级知识管理系统，Agent 都需要在运行时维护复杂的「上下文」——包括用户的对话历史（文档数据）、实体之间的关系（图数据）、语义检索的向量嵌入（向量数据）、时间序列的事件流（时序数据），以及传统的结构化业务数据（关系型数据）。

问题来了：你需要多少个数据库才能满足这些需求？

• MongoDB 存文档？
• Neo4j 存图关系？
• Pinecone 或 Qdrant 存向量？
• PostgreSQL 存关系型数据？
• Redis 做实时订阅？
• Kafka 做事件流？

六个系统、六套 API、六种运维方式、六倍的一致性风险。当一个 Agent 需要同时更新用户的对话记忆、知识图谱关系和向量嵌入时，分布式事务的噩梦就开始了——写入一半成功、一半失败，上下文状态直接崩溃。

SurrealDB 的出现，正是为了解决这个根本性问题。

二、SurrealDB 是什么？

2.1 一句话定义

SurrealDB 是一个用 Rust 编写的多模型数据库，将文档存储、图数据库、关系型数据库、时序数据库、地理空间数据库和键值存储六种数据模型统一到一个引擎中，通过单一查询语言 SurrealQL 操作，并提供原生的向量搜索、全文检索和实时订阅能力。

2.2 核心定位

SurrealDB 官方将自己的定位从「数据库」升级为 「AI Agent 的上下文层」（The Context Layer for AI Agents）。这意味着它不只是存储数据，而是为 Agent 提供统一的记忆管理、语义检索和关系推理能力。

2.3 技术栈概览

三、为什么需要多模型数据库？

3.1 传统多数据库架构的痛点

在一个典型的 AI Agent 系统中，数据流是这样的：

用户输入 → LLM 处理 → 更新对话历史(MongoDB)
                     → 提取实体关系(Neo4j)
                     → 生成向量嵌入(Pinecone)
                     → 记录事件日志(TimescaleDB)
                     → 更新业务状态(PostgreSQL)

这种架构面临四个致命问题：

1. 一致性黑洞

跨数据库的分布式事务几乎不可能实现。当 Agent 需要在一个事务中同时更新图关系和向量嵌入时，你只能用最终一致性——但 AI Agent 的上下文状态不能容忍「中间态」。

2. 延迟叠加

每次跨数据库调用都有网络延迟。六个数据库意味着至少六次网络往返，在 Agent 需要实时响应的场景下，这是不可接受的。

3. 运维爆炸

六套数据库意味着六种备份策略、六种监控方案、六种扩容方式、六种安全配置。对于中小团队来说，运维成本是灾难性的。

4. 开发体验碎片化

开发者需要学习六种查询语言、六种数据建模方式、六种连接管理方式。心智负担巨大。

3.2 多模型数据库的解法

SurrealDB 的解法很简单：把六种数据模型塞进一个引擎，用一种语言操作，一次事务搞定。

用户输入 → LLM 处理 → SurrealDB 单事务：
  UPDATE user:john SET conversation += $new_msg;    -- 文档
  RELATE user:john->knows->user:jane;               -- 图
  UPDATE user:john SET embedding = $vector;          -- 向量
  CREATE event SET type = 'chat', ts = time::now();  -- 时序
  UPDATE account SET balance -= 100;                  -- 关系型
  -- 全部在同一个 ACID 事务中完成

四、SurrealDB 架构深度剖析

4.1 存储层：可插拔引擎

SurrealDB 的存储层设计为可插拔架构，支持多种后端：

// SurrealDB 存储引擎抽象
pub trait Transaction {
    async fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>>;
    async fn set(&self, key: &[u8], value: &[u8]) -> Result<()>;
    async fn del(&self, key: &[u8]) -> Result<()>;
    async fn scan(&self, range: Range<&[u8]>) -> Result<Vec<KV>>;
}

内置存储引擎：

• 内存引擎（Memory）：纯内存存储，适合测试和临时数据
• RocksDB：基于 LSM-Tree 的持久化引擎，适合单节点部署
• TiKV：分布式键值存储，适合集群部署
• SurrealKV：SurrealDB 自研引擎，针对多模型工作负载优化

4.2 查询层：SurrealQL

SurrealQL 是 SurrealDB 的查询语言，它不是简单的 SQL 翻版，而是在 SQL 基础上融合了文档数据库和图数据库的查询能力。

Record Links（记录链接）

这是 SurrealDB 最独特的特性之一。Record Links 类似于关系型数据库的外键，但它存储的是直接指向目标记录的引用，而不是简单的 ID 值。查询时可以自动解引用（dereference），无需 JOIN。

-- 创建用户和产品
CREATE user:john SET name = 'John';
CREATE product:laptop SET name = 'MacBook Pro', price = 1999;

-- 使用 Record Link 建立关系
CREATE order SET
    buyer = user:john,        -- Record Link，直接引用 user:john
    product = product:laptop,  -- Record Link，直接引用 product:laptop
    quantity = 1,
    created_at = time::now();

-- 查询时自动解引用
SELECT buyer.name, product.name, product.price FROM order;
-- 结果：{ buyer: { name: 'John' }, product: { name: 'MacBook Pro', price: 1999 } }

图查询语法

SurrealDB 原生支持图遍历，语法简洁到令人发指：

-- 创建图关系
RELATE user:john->purchased->product:laptop SET at = time::now();
RELATE user:john->follows->user:jane SET since = '2024';
RELATE user:jane->purchased->product:phone SET at = time::now();

-- 一跳查询：John 买了什么？
SELECT ->purchased->product FROM user:john;

-- 二跳查询：John 的朋友买了什么？（好友的好友推荐）
SELECT ->follows->user->purchased->product FROM user:john;

-- 带过滤的图遍历
SELECT
    ->purchased->product[WHERE price > 1000] AS expensive_items,
    ->follows->user[WHERE since > '2023'] AS recent_friends
FROM user:john;

4.3 向量搜索

SurrealDB 内置向量搜索能力，支持余弦相似度、欧氏距离和曼哈顿距离：

-- 定义向量索引
DEFINE INDEX idx_embedding ON user FIELDS embedding
    HNSW DIMENSION 1536 DISTANCE COSINE TYPE F64;

-- 存储向量嵌入
UPDATE user:john SET
    name = 'John',
    embedding = [0.1, 0.5, -0.3, ...];  -- 1536维向量

-- 向量相似度搜索
SELECT
    name,
    vector::similarity::cosine(embedding, $query_vector) AS score
FROM user
WHERE vector::similarity::cosine(embedding, $query_vector) > 0.8
ORDER BY score DESC
LIMIT 10;

-- 混合检索：向量 + 过滤条件
SELECT
    name,
    vector::similarity::cosine(embedding, $query_vector) AS score
FROM user
WHERE
    vector::similarity::cosine(embedding, $query_vector) > 0.7
    AND age > 25
    AND city = 'Shanghai'
ORDER BY score DESC
LIMIT 5;

4.4 实时订阅

SurrealDB 支持 WebSocket 实时订阅，当数据变化时自动推送通知：

// JavaScript SDK 实时订阅
const db = new Surreal();
await db.connect('ws://localhost:8000/rpc');
await db.use({ namespace: 'test', database: 'test' });

// 订阅整个表的变化
const liveQuery = await db.live('user', (action, record) => {
    switch (action) {
        case 'CREATE':
            console.log('新用户:', record);
            break;
        case 'UPDATE':
            console.log('用户更新:', record);
            break;
        case 'DELETE':
            console.log('用户删除:', record);
            break;
    }
});

// 订阅带条件的查询
await db.live('chat_message', (action, record) => {
    if (action === 'CREATE' && record.room === 'general') {
        broadcastToRoom(record);
    }
});

4.5 事务与隔离级别

SurrealDB 提供完整的 ACID 事务支持，使用快照隔离（Snapshot Isolation）：

-- 多语句事务
BEGIN TRANSACTION;

LET $user = CREATE user SET name = 'John', balance = 1000;
LET $product = SELECT * FROM product:laptop WHERE stock > 0;

UPDATE user:john SET balance -= 1999;
UPDATE product:laptop SET stock -= 1;

COMMIT TRANSACTION;
-- 如果任何一步失败，整个事务回滚

五、SurrealDB 对比传统方案

5.1 SurrealDB vs MongoDB + Neo4j + Pinecone

5.2 SurrealDB vs PostgreSQL + pgvector

PostgreSQL 通过扩展（pgvector、Apache AGE）也能支持向量和图，但：

• 向量性能：SurrealDB 的 HNSW 索引针对向量搜索专门优化，大规模检索性能更优
• 图遍历：PostgreSQL 的图能力是「附加」的，语法复杂且性能受限
• 嵌入式部署：SurrealDB 可以编译为 WASM 在浏览器运行，PostgreSQL 不行
• 实时订阅：PostgreSQL 的 LISTEN/NOTIFY 功能有限，SurrealDB 的实时订阅更强大

5.3 SurrealDB vs Neo4j

六、生产级实战：构建 AI Agent 知识图谱

6.1 场景设计

我们来构建一个完整的 AI Agent 知识图谱系统，实现以下功能：

1. 实体管理：创建和管理用户、文档、概念等实体
2. 关系图谱：建立实体之间的多种关系（引用、提及、属于、相似）
3. 语义检索：基于向量相似度搜索相关知识
4. 图谱推理：通过图遍历发现隐含关系
5. 实时更新：当知识库变化时实时通知 Agent

6.2 数据模型设计

-- 定义命名空间和数据库
USE NS ai_agent DB knowledge_graph;

-- 用户表
DEFINE TABLE user SCHEMAFULL;
DEFINE FIELD name ON user TYPE string;
DEFINE FIELD email ON user TYPE string;
DEFINE FIELD role ON user TYPE string ASSERT $value INSIDE ['admin', 'member', 'viewer'];
DEFINE FIELD embedding ON user TYPE array<float>;
DEFINE FIELD created_at ON user TYPE datetime DEFAULT time::now();

-- 文档表
DEFINE TABLE document SCHEMAFULL;
DEFINE FIELD title ON document TYPE string;
DEFINE FIELD content ON document TYPE string;
DEFINE FIELD summary ON document TYPE string;
DEFINE FIELD embedding ON document TYPE array<float>;
DEFINE FIELD metadata ON document TYPE object;
DEFINE FIELD created_at ON document TYPE datetime DEFAULT time::now();

-- 概念表
DEFINE TABLE concept SCHEMAFULL;
DEFINE FIELD name ON document TYPE string;
DEFINE FIELD description ON document TYPE string;
DEFINE FIELD embedding ON concept TYPE array<float>;
DEFINE FIELD category ON concept TYPE string;

-- 定义向量索引
DEFINE INDEX idx_user_embedding ON user FIELDS embedding
    HNSW DIMENSION 1536 DISTANCE COSINE TYPE F64;
DEFINE INDEX idx_doc_embedding ON document FIELDS embedding
    HNSW DIMENSION 1536 DISTANCE COSINE TYPE F64;
DEFINE INDEX idx_concept_embedding ON concept FIELDS embedding
    HNSW DIMENSION 1536 DISTANCE COSINE TYPE F64;

-- 定义全文索引
DEFINE INDEX idx_doc_content ON document FIELDS content FULLTEXT ANALYZER chinese;
DEFINE INDEX idx_doc_title ON document FIELDS title FULLTEXT;

6.3 核心操作实战

创建实体和关系：

-- 创建用户
CREATE user:alice SET
    name = 'Alice',
    email = 'alice@example.com',
    role = 'admin',
    embedding = fn::generate_embedding('Alice - 技术总监，专注分布式系统');

-- 创建文档
CREATE document:arch_doc SET
    title = '微服务架构设计指南',
    content = '本文详细介绍了微服务架构的核心原则...',
    summary = '微服务架构的完整设计指南，涵盖服务拆分、通信模式、数据管理等',
    embedding = fn::generate_embedding('微服务架构设计指南 - 服务拆分、通信模式、数据管理'),
    metadata = { tags: ['architecture', 'microservices'], version: '2.0' };

-- 创建概念
CREATE concept:microservice SET
    name = '微服务',
    description = '一种将应用程序构建为小型、自治服务集合的架构风格',
    embedding = fn::generate_embedding('微服务 架构 服务拆分 自治'),
    category = 'architecture';

-- 建立图关系
RELATE user:alice->authored->document:arch_doc SET
    at = time::now(),
    contribution = 'primary';

RELATE document:arch_doc->mentions->concept:microservice SET
    relevance = 0.95;

RELATE user:alice->expert_in->concept:microservice SET
    proficiency = 'expert';

图谱推理查询：

-- 查询 Alice 擅长的所有概念
SELECT ->expert_in->concept.* FROM user:alice;

-- 查询 Alice 写过的文档中提到的概念
SELECT
    ->authored->document.title AS documents,
    ->authored->document->mentions->concept.name AS related_concepts
FROM user:alice;

-- 推荐相关文档：找到与当前文档提到相同概念的其他文档
SELECT
    title,
    summary,
    ->mentions->concept.name AS concepts
FROM document
WHERE
    ->mentions->concept IN (
        SELECT ->mentions->concept FROM document:arch_doc
    )
    AND id != document:arch_doc;

-- 基于向量相似度搜索相关知识
SELECT
    title,
    summary,
    vector::similarity::cosine(embedding, $query_vector) AS relevance
FROM document
WHERE vector::similarity::cosine(embedding, $query_vector) > 0.75
ORDER BY relevance DESC
LIMIT 10;

-- 混合检索：向量 + 图关系 + 全文
SELECT
    title,
    summary,
    vector::similarity::cosine(embedding, $query_vector) AS semantic_score,
    ->mentions->concept.name AS concepts
FROM document
WHERE
    vector::similarity::cosine(embedding, $query_vector) > 0.7
    AND (->mentions->concept IN (SELECT ->expert_in->concept FROM user:alice))
ORDER BY semantic_score DESC
LIMIT 5;

6.4 Python SDK 集成

import asyncio
from surrealdb import Surreal
import openai

async def main():
    # 连接 SurrealDB
    db = Surreal("ws://localhost:8000/rpc")
    await db.use("ai_agent", "knowledge_graph")
    await db.signin({"user": "root", "pass": "root"})

    # 生成向量嵌入
    async def get_embedding(text: str) -> list[float]:
        response = await openai.embeddings.create(
            model="text-embedding-3-small",
            input=text
        )
        return response.data[0].embedding

    # 添加知识
    async def add_knowledge(title: str, content: str, concepts: list[str]):
        embedding = await get_embedding(f"{title} {content}")

        # 创建文档
        doc = await db.create("document", {
            "title": title,
            "content": content,
            "embedding": embedding,
        })

        # 关联概念
        for concept_name in concepts:
            concept = await db.query(
                "SELECT * FROM concept WHERE name = $name",
                {"name": concept_name}
            )
            if concept:
                await db.query(
                    "RELATE $doc->mentions->$concept SET relevance = 0.9",
                    {"doc": doc[0]["id"], "concept": concept[0]["id"]}
                )

        return doc

    # 语义搜索
    async def semantic_search(query: str, limit: int = 10):
        query_embedding = await get_embedding(query)
        results = await db.query("""
            SELECT
                title,
                summary,
                vector::similarity::cosine(embedding, $embedding) AS score
            FROM document
            WHERE vector::similarity::cosine(embedding, $embedding) > 0.7
            ORDER BY score DESC
            LIMIT $limit
        """, {"embedding": query_embedding, "limit": limit})
        return results

    # 实时订阅知识库变化
    await db.live("document", lambda action, doc: print(f"知识库变化: {action} - {doc['title']}"))

    # 使用示例
    await add_knowledge(
        "Kubernetes 最佳实践",
        "本文介绍了 K8s 集群的生产级部署最佳实践...",
        ["Kubernetes", "容器编排", "云原生"]
    )

    results = await semantic_search("如何部署微服务到 K8s？")
    for r in results:
        print(f"[{r['score']:.2f}] {r['title']}")

asyncio.run(main())

6.5 Go SDK 集成

package main

import (
    "context"
    "fmt"
    "log"

    surrealdb "github.com/surrealdb/surrealdb.go"
)

type Document struct {
    ID        string    `json:"id,omitempty"`
    Title     string    `json:"title"`
    Content   string    `json:"content"`
    Embedding []float32 `json:"embedding"`
}

func main() {
    // 连接
    db, err := surrealdb.New("ws://localhost:8000/rpc")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 认证
    _, err = db.Signin(map[string]string{
        "user": "root",
        "pass": "root",
    })
    if err != nil {
        log.Fatal(err)
    }

    // 选择命名空间和数据库
    _, err = db.Use("ai_agent", "knowledge_graph")
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()

    // 创建文档
    doc := Document{
        Title:     "Go 并发编程指南",
        Content:   "深入理解 Goroutine、Channel 和 sync 包...",
        Embedding: generateEmbedding("Go 并发编程 Goroutine Channel"),
    }

    created, err := surrealdb.Create[Document](ctx, db, "document", doc)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Created: %+v\n", created)

    // 向量搜索
    queryEmbedding := generateEmbedding("Go 并发编程")
    results, err := surrealdb.Query[[]Document](ctx, db, `
        SELECT title, content,
            vector::similarity::cosine(embedding, $embedding) AS score
        FROM document
        WHERE vector::similarity::cosine(embedding, $embedding) > 0.7
        ORDER BY score DESC
        LIMIT 5
    `, map[string]interface{}{
        "embedding": queryEmbedding,
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Results: %+v\n", results)
}

七、部署架构与最佳实践

7.1 单节点部署

最简单的部署方式——单个二进制文件：

# 安装
curl -sSf https://install.surrealdb.com | sh

# 启动（内存模式，适合开发）
surreal start --log debug --user root --pass root memory

# 启动（文件持久化，适合小规模生产）
surreal start --log info \
    --user root --pass root \
    --bind 0.0.0.0:8000 \
    file:///data/surrealdb

# 启动（RocksDB 引擎，适合中等规模）
surreal start --log info \
    --user root --pass root \
    --bind 0.0.0.0:8000 \
    rocksdb:///data/surrealdb

7.2 分布式集群部署

使用 TiKV 作为存储后端的分布式部署：

# docker-compose.yml
version: '3.8'
services:
  pd:
    image: pingcap/pd:latest
    command:
      - --name=pd
      - --client-urls=http://0.0.0.0:2379
      - --peer-urls=http://0.0.0.0:2380

  tikv:
    image: pingcap/tikv:latest
    command:
      - --addr=0.0.0.0:20160
      - --pd=pd:2379

  surrealdb:
    image: surrealdb/surrealdb:latest
    command: >
      start
      --log info
      --user root
      --pass ${SURREAL_PASS}
      --bind 0.0.0.0:8000
      tikv://pd:2379
    ports:
      - "8000:8000"

7.3 嵌入式部署

将 SurrealDB 作为库嵌入到 Rust 应用中：

use surrealdb::engine::local::RocksDb;
use surrealdb::Surreal;

#[tokio::main]
async fn main() -> surrealdb::Result<()> {
    // 嵌入式模式，无需外部数据库进程
    let db = Surreal::new::<RocksDb>("./my_data").await?;

    // 选择命名空间和数据库
    db.use_ns("production").use_db("app").await?;

    // 直接使用，零网络延迟
    let _: Vec<Record> = db.create("user").content(User {
        name: "John".to_string(),
        age: 30,
    }).await?;

    Ok(())
}

7.4 浏览器 WASM 部署

// 在浏览器中运行 SurrealDB
import Surreal from 'surrealdb.wasm';

const db = new Surreal();
await db.connect("mem://");  // 内存模式

// 在浏览器中维护本地数据
await db.use({ ns: "local", db: "cache" });
await db.create("todo", { title: "Learn SurrealDB", done: false });

const todos = await db.select("todo");
console.log(todos);

八、性能基准与优化

8.1 官方基准测试

SurrealDB 维护了一个开源基准测试工具 crud-bench，以下是典型场景的性能数据（仅供参考，具体取决于硬件和配置）：

8.2 性能优化建议

1. 索引策略

-- 为高频查询字段创建索引
DEFINE INDEX idx_user_email ON user FIELDS email UNIQUE;
DEFINE INDEX idx_doc_created ON document FIELDS created_at;

-- 向量索引参数调优
DEFINE INDEX idx_embedding ON document FIELDS embedding
    HNSW
    DIMENSION 1536
    DISTANCE COSINE
    TYPE F64
    EFC 200       -- 构建时精度
    M 16           -- 每层最大连接数
    LM 200;        -- 层级数

2. 批量操作

-- 批量插入（比逐条插入快 10 倍以上）
INSERT INTO user [
    { name: 'Alice', age: 30 },
    { name: 'Bob', age: 25 },
    { name: 'Charlie', age: 35 }
];

3. 查询优化

-- 使用 ONLY 关键字跳过结果包装
SELECT * FROM ONLY user:john;  -- 直接返回对象，而非数组

-- 使用 FETCH 预加载关联数据
SELECT *, ->authored->document.* AS docs FROM user:john FETCH docs;

-- 限制遍历深度
SELECT ->purchased->product FROM user:john TIMEOUT 5s;

九、企业级案例

9.1 Samsung Ads

Samsung Ads 使用 SurrealDB 构建广告分析知识图谱，将原本分散在多个数据库中的广告主、广告位、受众画像等数据统一管理，实现了：

• 查询延迟降低 60%：单一数据库消除了跨库 JOIN
• 开发效率提升 3 倍：统一的 SurrealQL 减少了学习成本
• 运维成本降低 50%：从 4 个数据库减少到 1 个

9.2 Tencent

腾讯使用 SurrealDB 进行基础设施监控，将原本 9 个独立的监控工具整合为一个平台：

• 统一了指标、日志、链路追踪的数据模型
• 实现实时告警和智能根因分析
• 降低了 70% 的存储成本

9.3 Verizon

Verizon 的现场技术助手使用 SurrealDB 管理 RAG（检索增强生成）的上下文：

• 向量存储和检索设备手册
• 图关系记录设备之间的依赖关系
• 实时订阅确保助手获取最新的设备状态

十、SurrealDB 的局限性

10.1 生态成熟度

相比 PostgreSQL、MongoDB 等老牌数据库，SurrealDB 的生态系统仍在成长中：

• ORM 支持有限
• 第三方工具集成较少
• 社区规模较小

10.2 分布式事务

虽然 SurrealDB 支持 ACID 事务，但在分布式部署中，跨节点事务的性能仍有优化空间。

10.3 大规模数据

对于超大规模数据（PB 级），SurrealDB 尚未经过充分的生产验证。TiKV 后端理论上可以扩展到 PB 级，但实际案例有限。

10.4 许可证限制

BSL 许可证限制了直接竞争性产品的商业化使用。对于大多数企业内部使用场景没有影响，但构建 SaaS 服务时需要仔细评估。

十一、总结与展望

SurrealDB 代表了数据库发展的一个重要方向：多模型统一。在 AI Agent 时代，数据不再是单一形态的——文档、图、向量、时序、关系型数据共存是常态。用一个数据库、一种查询语言、一个事务来管理所有这些数据，是 SurrealDB 给出的答案。

核心价值：

1. 简化架构：一个数据库替代六个，运维成本直线下降
2. 保证一致性：原生 ACID 事务，告别分布式事务噩梦
3. 提升开发体验：SurrealQL 统一语法，学习成本归一
4. AI 原生：向量搜索 + 图遍历 + 实时订阅，为 Agent 而生
5. 部署灵活：从浏览器 WASM 到分布式集群，一个引擎覆盖全场景

适用场景：

• AI Agent 的记忆和知识管理系统
• 需要多种数据模型的复杂应用
• 实时协作和事件驱动系统
• 边缘计算和嵌入式应用
• 快速原型开发

不适用场景：

• 超大规模 OLAP 分析
• 对成熟度要求极高的金融核心系统
• 已有稳定多数据库架构且运行良好的系统

SurrealDB 不是要取代所有数据库，而是在「多模型统一」这个特定赛道上，提供了一个极具吸引力的选择。随着 AI Agent 的爆发式增长，这类「上下文层」数据库的需求只会越来越大。

参考资源：

• SurrealDB 官方文档：https://surrealdb.com/docs
• SurrealDB GitHub：https://github.com/surrealdb/surrealdb
• crud-bench 基准测试：https://github.com/surrealdb/crud-bench
• SurrealDB 企业案例：https://surrealdb.com/casestudies