以下是基于您提供的Trustfall核心库使用指南内容的完整示例demo：

// 1. 添加依赖到Cargo.toml
/*
[dependencies]
trustfall_core = "0.12.0"
*/

use trustfall_core::{
    schema::Schema, 
    Adapter, 
    AdapterContext, 
    EdgeParameters, 
    execute_query, 
    QueryContext,
    VertexIterator
};

// 2. 定义数据模型和顶点类型
#[derive(Debug)]
struct Person {
    name: String,
    age: Option<i64>,
    friends: Vec<Person>,
}

// 3. 实现适配器
struct PersonAdapter;

impl Adapter for PersonAdapter {
    type Vertex = Person;

    fn resolve_starting_vertices(
        &self,
        edge_name: &str,
        _parameters: &EdgeParameters,
        _ctx: &AdapterContext,
    ) -> VertexIterator<Self::Vertex> {
        // 模拟数据源
        let people = vec![
            Person {
                name: "Alice".to_string(),
                age: Some(25),
                friends: vec![
                    Person {
                        name: "Bob".to_string(),
                        age: Some(30),
                        friends: vec![],
                    },
                    Person {
                        name: "Charlie".to_string(),
                        age: Some(22),
                        friends: vec![],
                    },
                ],
            },
            Person {
                name: "John".to_string(),
                age: Some(35),
                friends: vec![
                    Person {
                        name: "Jane".to_string(),
                        age: Some(28),
                        friends: vec![],
                    },
                ],
            },
        ];
        
        // 只返回Person类型的顶点
        if edge_name == "Person" {
            Box::new(people.into_iter())
        } else {
            Box::new(std::iter::empty())
        }
    }
}

fn main() {
    // 定义Schema
    let schema = Schema::parse(
        r#"
        type Person {
            name: String!
            age: Int
            friends: [Person!]!
        }
        "#,
    ).expect("Valid schema");

    // 执行基础查询
    let query = r#"
    {
        Person {
            name @output
            age @output
            friends {
                name @output
            }
        }
    }
    "#;

    let results = execute_query::<PersonAdapter>(
        &schema,
        PersonAdapter,
        query,
        std::collections::HashMap::new(),
        QueryContext::default(),
    ).expect("Query failed");

    println!("基础查询结果: {:?}", results);

    // 执行参数化查询
    let param_query = r#"
    query FindPerson($name: String!) {
        Person {
            name @filter(op: "=", value: ["$name"])
            age @output
            friends {
                name @output
            }
        }
    }
    "#;

    let variables = std::collections::HashMap::from([
        ("name".to_string(), "Alice".into())
    ]);

    let param_results = execute_query::<PersonAdapter>(
        &schema,
        PersonAdapter,
        param_query,
        variables,
        QueryContext::default(),
    ).expect("Parameterized query failed");

    println!("参数化查询结果: {:?}", param_results);

    // 执行递归查询
    let recurse_query = r#"
    {
        Person {
            name @output
            friends @recurse(depth: 2) {
                name @output
            }
        }
    }
    "#;

    let recurse_results = execute_query::<PersonAdapter>(
        &schema,
        PersonAdapter,
        recurse_query,
        std::collections::HashMap::new(),
        QueryContext::default(),
    ).expect("Recursive query failed");

    println!("递归查询结果: {:?}", recurse_results);
}

这个完整示例展示了：

1. 定义Person数据模型和顶点类型
2. 实现PersonAdapter适配器连接模拟数据
3. 执行三种不同类型的查询：
   • 基础查询：获取所有人的姓名、年龄和朋友列表
   • 参数化查询：按姓名过滤查找特定人员
   • 递归查询：递归查找朋友关系（深度为2）

您可以根据实际需求修改Person数据结构和适配器实现来连接真实数据源。