move claims to claims table

src/main.rs

@@ -1,15 +1,13 @@
-use anyhow::{Error, Result};
+use anyhow::{Error, Ok, Result};
 use dotenv_codegen::dotenv;
 use serde_json::{from_str, Value};
 use std::fs::File;
 use std::io::{BufRead, BufReader};
-use surrealdb::engine::remote::ws::Ws;
+use surrealdb::{engine::remote::ws::Ws, opt::auth::Root, Surreal};
-use surrealdb::opt::auth::Root;
+use wikidata::Entity;
-use surrealdb::Surreal;
 
 mod utils;
 use utils::*;
-use wikidata::Entity;
 
 #[tokio::main]
 async fn main() -> Result<(), Error> {
@@ -23,7 +21,7 @@ async fn main() -> Result<(), Error> {
 
     db.use_ns("wikidata").use_db("wikidata").await?;
 
-    let file = File::open("data/w.json")?;
+    let file = File::open("data/ex2.json")?;
     let reader = BufReader::new(file);
 
     for line in reader.lines() {
@@ -35,10 +33,13 @@ async fn main() -> Result<(), Error> {
         let json: Value = from_str(&line)?;
         let data = Entity::from_json(json).expect("Failed to parse JSON");
 
-        let (id, data) = EntityMini::from_entity(data);
+        let (id, claims, data) = EntityMini::from_entity(data);
 
         let _: Option<EntityMini> = db.delete(&id).await?;
         let _: Option<EntityMini> = db.create(&id).content(data.clone()).await?;
+
+        let _: Option<Claims> = db.delete(&claims.0).await?;
+        let _: Option<Claims> = db.create(&claims.0).content(claims.1).await?;
     }
 
     Ok(())

src/utils.rs

@@ -1,54 +1,69 @@
+use dotenv_codegen::dotenv;
 use serde::{Deserialize, Serialize};
 use surrealdb::sql::Thing;
-use wikidata::ClaimValueData;
+use wikidata::{ClaimValue, ClaimValueData, Entity, Lang, Pid, WikiId};
-use wikidata::{ClaimValue, Entity, Lang, Pid, WikiId};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Claims {
+    pub claims: Vec<(Thing, ClaimValueData)>,
+}
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct EntityMini {
-    // In English
     pub label: String,
-    pub claims: Vec<(Thing, ClaimValueData)>,
+    pub claims: Thing,
     pub description: String,
 }
 
 impl EntityMini {
-    pub fn from_entity(entity: Entity) -> (Thing, Self) {
+    pub fn from_entity(entity: Entity) -> (Thing, (Thing, Claims), Self) {
+        let thing_claim = Thing {
+            id: get_id(&entity).id,
+            tb: "Claims".to_string(),
+        };
+
         (
             get_id(&entity),
+            (
+                thing_claim.clone(),
+                Self::flatten_claims(entity.claims.clone()),
+            ),
             Self {
                 label: get_name(&entity),
-                claims: Self::flatten_claims(entity.claims.clone()),
+                claims: thing_claim,
                 description: get_description(&entity).unwrap_or("".to_string()),
             },
         )
     }
 
-    fn flatten_claims(claims: Vec<(Pid, ClaimValue)>) -> Vec<(Thing, ClaimValueData)> {
+    fn flatten_claims(claims: Vec<(Pid, ClaimValue)>) -> Claims {
-        claims
+        Claims {
-            .iter()
+            claims: claims
-            .flat_map(|(pid, claim_value)| {
+                .iter()
-                let mut flattened = vec![(
+                .flat_map(|(pid, claim_value)| {
-                    Thing {
+                    let mut flattened = vec![(
-                        id: pid.0.into(),
+                        Thing {
-                        tb: "Property".to_string(),
+                            id: pid.0.into(),
-                    },
+                            tb: "Property".to_string(),
-                    claim_value.data.clone(),
+                        },
-                )];
+                        claim_value.data.clone(),
+                    )];
 
-                flattened.extend(claim_value.qualifiers.iter().map(
+                    flattened.extend(claim_value.qualifiers.iter().map(
-                    |(qualifier_pid, qualifier_value)| {
+                        |(qualifier_pid, qualifier_value)| {
-                        (
+                            (
-                            Thing {
+                                Thing {
-                                id: qualifier_pid.0.into(),
+                                    id: qualifier_pid.0.into(),
-                                tb: "Property".to_string(),
+                                    tb: "Property".to_string(),
-                            },
+                                },
-                            qualifier_value.clone(),
+                                qualifier_value.clone(),
-                        )
+                            )
-                    },
+                        },
-                ));
+                    ));
-                flattened
+                    flattened
-            })
+                })
-            .collect()
+                .collect(),
+        }
     }
 }
 
@@ -66,11 +81,14 @@ fn get_id(entity: &Entity) -> Thing {
 fn get_name(entity: &Entity) -> String {
     entity
         .labels
-        .get(&Lang("en".to_string()))
+        .get(&Lang(dotenv!("WIKIDATA_LANG").to_string()))
         .expect("No label found")
         .to_string()
 }
 
 fn get_description(entity: &Entity) -> Option<String> {
-    entity.descriptions.get(&Lang("en".to_string())).cloned()
+    entity
+        .descriptions
+        .get(&Lang(dotenv!("WIKIDATA_LANG").to_string()))
+        .cloned()
 }