use transistor::client::Crux;
use transistor::http::Order;
use transistor::types::CruxId;

let person = Person {
    crux__db___id: CruxId::new("hello-history"),
    ...

let client = Crux::new("localhost", "3000").http_client();

let tx_body = client.entity_tx(person.crux__db___id).unwrap();

let entity_history = client.entity_history(tx_body.db___id.clone(), Order::Asc, true);
// EntityHistoryResponse { history: [
//     EntityHistoryElement { 
//         db___valid_time: 2020-08-05T03:00:06.476-00:00, 
//         tx___tx_id: 37, tx___tx_time: 2020-08-05T03:00:06.476-00:00, 
//         db___content_hash: "2da097a2dffbb9828cd4377f1461a59e8454674b", 
//         db__doc: Some(Map(Map(
//                 {":crux.db/id": Key(":hello-history"), 
//                 ":first-name": Str("Hello"), 
//                 ":last-name": Str("World")}
//                ))) 
//     }
// ]}

let entity_history_without_docs = client.entity_history(tx_body.db___id, Order::Asc, false);
// EntityHistoryResponse { 
//     history: [
//         EntityHistoryElement {
//              db___valid_time: 2020-08-05T03:00:06.476-00:00, 
//              tx___tx_id: 37, 
//              tx___tx_time: 2020-08-05T03:00:06.476-00:00, 
//              db___content_hash: "2da097a2dffbb9828cd4377f1461a59e8454674b", 
//              db__doc: None 
//             }
//         }
//     ]}

• entity_history_timed 与 entity_histoty 类似，因为它请求相同的端点，区别在于它可以发送作为查询参数的 start-transaction-time、end-transaction-time、start-valid-time 和 end-valid-time。这是通过添加一个包含一个 TimeHistory::TransactionTime 和/或一个 TimeHistory::ValidTime 的 Vec<TimeHistory> 来实现的，它们都接收两个 Option<DateTime<Utc>>。第一个 DateTime 是 start-<type>-time，第二个是 end-<type>-time。

• query 通过 POST 请求端点 /query。参数是类型为 Query 的 query。检索一个包含由函数 Query::find 定义的值的集合。可用函数包括 find、find_by_aggregates、where_clause、args、order_by、limit、offset，示例 complex_query 和 limit_offset_query 展示了如何使用它们。

简单查找

use transistor::client::Crux;
use transistor::types::{query::Query};

let client = Crux::new("localhost", "3000").http_client();

let query_is_sql = Query::find(vec!["?p1", "?n"])
    .where_clause(vec!["?p1 :name ?n", "?p1 :is-sql true"])
    .build();
// Query:
// {:query
//     {:find [?p1 ?n]
//      :where [[?p1 :name ?n]
//              [?p1 :is-sql true]]}}

let is_sql = client.query(query_is_sql.unwrap()).unwrap();
// {[":mysql", "MySQL"], [":postgres", "Postgres"]} BTreeSet

通过聚合查找

• 可在 Aggregate 找到可用聚合

use transistor::client::Crux;
use transistor::types::{query::Query};

let client = Crux::new("localhost", "3000").http_client();

let q = Query::find_by_aggregates(vec![
    Aggregate::Min("?e".to_string()), Aggregate::Max("?e".to_string()), Aggregate::Count("?e".to_string()),
    Aggregate::MinN(5, "?e".to_string()), Aggregate::CountDistinct("?e".to_string())
])?
.where_clause(vec!["?e :type :burger"])?
.build()?;
// Query:
// {:query
//   {:find [(min ?e) (max ?e) (count ?e) (min 5 ?e) (count-distinct ?e)]
//    :where [[?e :type :burger]]
// }}

let _ = client.query(q)?;

Transisitor 的结构和枚举类型

Actions 是一个构建器结构体，用于帮助您为 tx_log 创建一个 Vec<Action>。可用函数有

• new 静态方法用于实例化结构体 Actions。
• append_put<T: Serialize>(action: T) 将一个无 valid-time 的 Put 追加到 Actions。
• append_put_timed<T: Serialize>(action: T, date: DateTime<FixedOffset>) 将一个带 valid-time 的 Put 追加到 Actions。
• append_delete(id: CruxId) 将一个没有 有效时间 的 Delete 添加到 Actions 中。最后删除特定文档在最后一个 有效时间。
• append_delete_timed(id: CruxId, date: DateTime<FixedOffset>) 将一个具有 有效时间 的 Delete 添加到 Actions 中。在指定的 有效时间 删除特定文档。
• append_evict(id: CruxId) 将一个 Evict 添加到 Actions。完全驱逐文档，包括所有历史版本（只接收要驱逐的 ID）。
• append_match_doc<T: Serialize>(id: CruxId, action: T) 将一个没有 有效时间 的 Match 添加到 Actions。匹配实体的当前状态，如果状态与提供的文档不匹配，则事务将不会继续。
• append_match_doc_timed<T: Serialize>(id: CruxId, action: T, date: DateTime<FixedOffset>) 将一个具有 有效时间 的 Match 添加到 Actions。
• build 从 Actions 生成 Vec<Action>。

use transistor::client::Crux;
use transistor::types::Actions;

fn main() -> Result<(), CruxError> {
    let crux = Database {
        // ...
    };

    let psql = Database {
        // ...
    };

    let mysql = Database {
        // ...
    };

    let cassandra = Database {
        // ...
    };

    let sqlserver = Database {
        // ...
    };

    let client = Crux::new("localhost", "3000").http_client();
    let timed = "2014-11-28T21:00:09-09:00"
        .parse::<DateTime<FixedOffset>>()
        .unwrap();

    let actions: Vec<Action> = Actions::new()
        .append_put(crux)
        .append_put(psql)
        .append_put(mysql)
        .append_put_timed(cassandra, timed)
        .append_put(sqlserver)
        .build();

    let _ = client.tx_log(actions)?;
}

Query 是一个结构体，负责创建字段并将它们序列化到正确的 query 格式。它为每个字段提供了一个函数，并有一个 build 函数来帮助检查其格式是否正确。

• find 是一个静态构建函数，用于定义 :find 子句内的元素。
• where_clause 是一个构建函数，用于定义 :where [] 数组内的元素向量。
• order_by 是一个构建函数，用于定义 :order-by 子句内的元素。
• args 是一个构建函数，用于定义 :args 子句内的元素。
• limit 是一个构建函数，用于定义 :limit 子句内的元素。
• offset 是一个构建函数，用于定义 :offset 子句内的元素。
• with_full_results 是一个构建函数，用于将标志 full-results? 定义为 true。这允许您的 query 响应返回整个文档，而不是仅返回搜索到的键。查询 {:query {:find [?user ?a] :where [[?user :first-name ?a]] :full-results? true}} 的结果将是一个类似于 BTreeSet<Vec<String>> 的结构，如 ([{:crux.db/id :fafilda, :first-name "Jorge", :last-name "Klaus"} "Jorge"]) 的结构，因此文档需要进一步的 EDN 解析才能成为文档的结构。

错误定义在 CruxError 枚举中。

• EdnError 是 edn_rs::EdnError 的包装。
• RequestError 由 reqwest 包产生。无法执行 HTTP 请求。
• QueryFormatError 在提供的查询结构不匹配模式时产生。
• QueryError 负责封装 Crux 响应中的 Stacktrace 错误。

use transistor::client::Crux;
use transistor::types::{query::Query};

let _client = Crux::new("localhost", "3000").http_client();

// field `n` doesn't exist
let _query_error_response = Query::find(vec!["?p1", "?n"])
    .where_clause(vec!["?p1 :name ?g", "?p1 :is-sql true"])
    .build();

let error = client.query(query_error_response?)?;
println!("Stacktrace \n{:?}", error);

// Stacktrace
// QueryError("{:via
//      [{:type java.lang.IllegalArgumentException,
//        :message \"Find refers to unknown variable: n\",
//    :at [crux.query$q invokeStatic \"query.clj\" 1152]}],
//  :trace
//  [[crux.query$q invokeStatic \"query.clj\" 1152]
//   [crux.query$q invoke \"query.clj\" 1099]
//   [crux.query$q$fn__10850 invoke \"query.clj\" 1107]
//   [clojure.core$binding_conveyor_fn$fn__5754 invoke \"core.clj\" 2030]
//   [clojure.lang.AFn call \"AFn.java\" 18]
//   [java.util.concurrent.FutureTask run \"FutureTask.java\" 264]
//   [java.util.concurrent.ThreadPoolExecutor
//    runWorker
//    \"ThreadPoolExecutor.java\"
//    1128]
//   [java.util.concurrent.ThreadPoolExecutor$Worker
//    run
//    \"ThreadPoolExecutor.java\"
//    628]
//   [java.lang.Thread run \"Thread.java\" 834]],
//  :cause \"Find refers to unknown variable: n\"}
// ")

测试 Crux 客户端

为了测试目的，有一个名为 feature 的 mock，它启用了 http_mock 函数，这是 http_client 函数的替代品。要使用它，请使用标志 --features "mock" 运行您的命令，例如 cargo test --test lib --no-fail-fast --features "mock"。此模拟功能使用 crate mockito = "0.26" 作为 Cargo 依赖项。启用此功能的一个示例用法

use transistor::client::Crux;
use transistor::http::Action;
use edn_derive::Serialize;
use transistor::types::{CruxId};
use mockito::mock;

#[test]
#[cfg(feature = "mock")]
fn mock_client() {
    let _m = mock("POST", "/tx-log")
        .with_status(200)
        .match_body("[[:crux.tx/put { :crux.db/id :jorge-3, :first-name \"Michael\", :last-name \"Jorge\", }], [:crux.tx/put { :crux.db/id :manuel-1, :first-name \"Diego\", :last-name \"Manuel\", }]]")
        .with_header("content-type", "text/plain")
        .with_body("{:crux.tx/tx-id 8, :crux.tx/tx-time #inst \"2020-07-16T21:53:14.628-00:00\"}")
        .create();

    let person1 = Person {
        // ...
    };

    let person2 = Person {
        /// ...
    };

    let actions = vec![Action::put(person1), Action::put(person2)];
    
    let body = Crux::new("localhost", "3000")
        .http_mock()
        .tx_log(actions)
        .unwrap();

    assert_eq!(
        format!("{:?}", body),
        String::from("TxLogResponse { tx___tx_id: 8, tx___tx_time: 2020-07-16T21:53:14.628-00:00, tx__event___tx_events: None }")
    );
}

#[derive(Debug, Clone, Serialize)]
#[allow(non_snake_case)]
pub struct Person {
    crux__db___id: CruxId,
    // ...
}