Skip to content

Instantly share code, notes, and snippets.

@abhayarawal

abhayarawal/dgraph.rs

Last active March 29, 2020 14:05
Show Gist options
  • Save abhayarawal/9c15b2d19bd31571da87ce871c3e7da3 to your computer and use it in GitHub Desktop.
Save abhayarawal/9c15b2d19bd31571da87ce871c3e7da3 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
dgraph.rs
#![allow(dead_code, unused)]
use dgraph::{make_dgraph, Dgraph, Request};
use serde_derive::{Deserialize, Serialize};
fn user_type() -> String { "User".to_string() }
#[derive(Debug, Default, Serialize, Deserialize)]
struct User {
uid: Option<String>,
name: String,
age: Option<u8>,
friends: Option<Vec<User>>,
#[serde(rename="dgraph.type")]
#[serde(default="user_type")]
dgraph_type: String
}
#[derive(Debug, Default, Serialize, Deserialize)]
struct Root {
users: Vec<User>,
}
fn drop_all(dg: &Dgraph) {
let op_clean = dgraph::Operation {
drop_all: true,
..Default::default()
};
dg.alter(&op_clean).expect("drop schema");
}
fn set_schema(dg: &Dgraph) {
let op_schema = dgraph::Operation {
schema: r#"
type User {
name
age
friend
}
name: string @index(exact, term) .
age: int .
friend: [uid] .
"#.to_string(),
..Default::default()
};
dg.alter(&op_schema).expect("set schema");
}
fn insert(dg: &Dgraph, user: User) -> String {
let mut mutation = dgraph::Mutation::default();
mutation.set_set_json(serde_json::to_vec(&user).expect("invalid json"));
let mut txn = dg.new_txn();
let assigned = txn.mutate(mutation).expect("failed to create data");
txn.commit().expect("failed to commit mutation");
let mut uid: String = "".to_string();
for (_, v) in assigned.uids.iter() {
uid = v.to_string();
}
uid
}
fn main() {
let dg = make_dgraph!(dgraph::new_dgraph_client("localhost:9080"));
drop_all(&dg);
set_schema(&dg);
let aave = User {
name: "Aave".to_string(),
age: Some(19),
..Default::default()
};
let marcella = User {
name: "Marcella".to_string(),
age: Some(27),
..Default::default()
};
let sheldon = User {
name: "Sheldon".to_string(),
age: Some(22),
..Default::default()
};
let leo = User {
name: "Leonard".to_string(),
age: Some(34),
..Default::default()
};
let zoe = User {
name: "Zoe".to_string(),
age: Some(29),
..Default::default()
};
let uid1 = insert(&dg, aave);
let uid2 = insert(&dg, marcella);
let uid3 = insert(&dg, leo);
let uid4 = insert(&dg, sheldon);
let uid5 = insert(&dg, zoe);
let mut txn = dg.new_txn();
let aave = format!(r#"
{{
u as var(func: uid({})) {{
uid
}}
u2 as var(func: uid({})) {{
uid
}}
u3 as var(func: uid({})) {{
uid
}}
u4 as var(func: uid({})) {{
uid
}}
u5 as var(func: uid({})) {{
uid
}}
}}
"#, uid1, uid2, uid3, uid4, uid5).to_string();
let mut mutation = dgraph::Mutation::default();
let mut_query = br#"
uid(u) <age> "29" .
uid(u) <friends> uid(u2) .
uid(u) <friends> uid(u3) .
uid(u) <friends> uid(u4) .
uid(u2) <friends> uid(u4) .
uid(u2) <friends> uid(u5) .
"#.to_vec();
mutation.set_set_nquads(mut_query);
let mut request = Request {
query: aave,
mutations: vec![mutation].into(),
..Default::default()
};
txn.do_request(&mut request);
txn.commit();
let query = format!(r#"{{
var(func: eq(name, {})) {{
u as uid,
f as count(friends)
}}
users(func: uid(u)) {{
uid,
name,
age,
val(f),
friends @filter(le(age, "30")) {{
name,
age,
friends {{
name,
age
}}
}}
}}
}}"#, "Aave".to_string())
.to_string();
let resp = dg.new_readonly_txn().query(query).expect("query");
let root: Root = serde_json::from_slice(&resp.json).expect("parsing");
println!("{:?}", resp);
println!("{:?}", root);
}
#![allow(dead_code, unused)]
use dgraph::make_dgraph;
use dgraph::Dgraph;
use juniper::{EmptyMutation, FieldResult, GraphQLInputObject, GraphQLObject, RootNode, Variables};
use serde_derive::{Deserialize, Serialize};
use serde_json::Value;
use std::sync::Arc;
use warp::{filters::BoxedFilter, Filter};
macro_rules! jin {
[ $j:expr; $( $e:expr ),+ ] => (
(|| {
let res = $j$(.get($e)?)+;
Some(res)
})();
);
}
#[derive(GraphQLObject, Debug, Default, Serialize, Deserialize)]
struct User {
uid: Option<String>,
name: Option<String>,
age: Option<i32>,
friends: Option<Vec<User>>,
}
#[derive(Debug, Serialize, Deserialize)]
struct Users {
users: Vec<User>,
}
struct QueryRoot;
#[juniper::object(
Context = Context
)]
impl QueryRoot {
fn api_version() -> &str {
"1.0"
}
fn users(context: &Context) -> Vec<User> {
let query = r#"
{
users(func: eq(name, "Marcella")) {
uid,
name,
age,
friends {
uid,
name,
age
}
}
}
"#
.to_string();
let resp = context.dg.new_readonly_txn().query(query).expect("query");
let j: Users = serde_json::from_slice(&resp.json).expect("parsing");
j.users
}
fn user(context: &Context, name: String) -> User {
let query = format!(
r#"
{{
users(func: eq(name, {})) {{
uid,
name,
age,
friends {{
uid,
name,
age
}}
}}
}}"#,
name
)
.to_string();
let resp = context.dg.new_readonly_txn().query(query).expect("query");
let mut j: Users = serde_json::from_slice(&resp.json).expect("parsing");
j.users.remove(0)
}
}
struct Context {
dg: Dgraph,
}
impl juniper::Context for Context {}
type Schema = RootNode<'static, QueryRoot, EmptyMutation<Context>>;
fn schema() -> Schema {
Schema::new(QueryRoot {}, EmptyMutation::<Context>::new())
}
struct AppState(Context, Schema);
#[tokio::main]
async fn main() {
let schema = schema();
let context = Context {
dg: make_dgraph!(dgraph::new_dgraph_client("localhost:9080")),
};
let app_state = Arc::new(AppState(context, schema));
let app_state = warp::any().map(move || app_state.clone());
let routes = warp::path("users")
.and(warp::path::param())
.and(app_state)
.map(|name: String, app_state: Arc<AppState>| {
let query = format!(
r#"
query {{
user(name: "{}") {{
uid,
name,
friends {{
uid,
name,
age
}}
}}
}}"#,
name
);
let (res, _) = juniper::execute(
query.as_str(),
None,
&app_state.1,
&Variables::new(),
&app_state.0,
)
.expect("Could not parse query");
warp::reply::json(&res)
});
warp::serve(routes).run(([127, 0, 0, 1], 3000)).await;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment