kdb-connection 0.1.0

#![allow(unused)] // API is not finalize

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

use crate::value;

#[derive(Serialize, Debug, Clone, Copy, PartialEq, Eq)]
#[allow(clippy::upper_case_acronyms)]
pub(crate) enum QueryType
{
    /// krQL query
    KRQL,
    /// kdQL query
    KDQL,
    /// SPARQL query
    SPARQL,
    /// SQL Query
    SQL,
}

#[derive(Serialize, Clone)]
pub struct Query
{
    pub(crate) query: String,
    pub(crate) bindings: HashMap<String, value::Value>,
    pub(crate) query_type: QueryType,
}

impl Query
{
    pub(crate) fn new(
        query: String,
        bindings: HashMap<String, value::Value>,
        query_type: QueryType,
    ) -> Query
    {
        Query {
            query,
            bindings,
            query_type,
        }
    }
}

#[derive(Debug, Deserialize, Clone)]
pub struct ResultMetadata
{
    pub(crate) error: String,
    pub(crate) query: String,
    pub(crate) success: bool,
}

#[derive(Debug, Deserialize, Clone)]
pub struct ResultHead
{
    pub(crate) vars: Vec<String>,
}

#[derive(Debug, Deserialize, Clone)]
pub struct ResultResults
{
    pub(crate) bindings: Vec<value::ValueHash>,
}

#[derive(Debug, Deserialize, Clone)]
pub struct Result
{
    #[serde(rename = "__knowL")]
    pub(crate) metadata: ResultMetadata,
    pub(crate) head: ResultHead,
    pub(crate) results: ResultResults,
}

#[cfg(test)]
mod tests
{
    use crate::queries::krql;
    #[test]
    fn it_can_parse_failed_result()
    {
        let json_failed = r#"{
  "__knowL":
  {
    "error": "Invalid result.",
    "query": "",
    "success": false
  },
  "head": { "vars": [] },
  "results":
  {
    "bindings": []
  }
}"#;
        let r: super::Result = serde_json::from_str(json_failed).unwrap();
        assert_eq!(r.metadata.error, "Invalid result.");
        assert_eq!(r.metadata.query, "");
        assert!(!r.metadata.success);
        assert_eq!(r.head.vars.len(), 0);
        assert_eq!(r.results.bindings.len(), 0);
    }

    #[test]
    fn it_can_parse_succesful_result()
    {
        let json_success = r#"{
   "__knowL":{
      "error":"",
      "query":"{\"test\":{\"return\":{\"datatype\":\"http://www.w3.org/2001/XMLSchema#long\",\"value\":12}}}",
      "success":true
   },
   "head":{
      "vars":[
         "data"
      ]
   },
   "results":{
      "bindings":[
         {
           "data":{
              "type":"literal",
              "datatype":"http://www.w3.org/2001/XMLSchema#long",
              "value":12
            }
         }
      ]
   }
}"#;
        let r: super::Result = serde_json::from_str(json_success).unwrap();
        assert_eq!(r.metadata.error, "");
        assert_eq!(
            r.metadata.query,
            "{\"test\":{\"return\":{\"datatype\":\"http://www.w3.org/2001/XMLSchema#long\",\"value\":12}}}"
        );
        assert!(r.metadata.success);
        assert_eq!(r.head.vars, ["data"]);
        assert_eq!(r.results.bindings.len(), 1);
        let v0 = r.results.bindings.first().unwrap();
        assert_eq!(v0.len(), 1);
        let v0data = v0.get("data").unwrap();
        assert_eq!(*v0data, 12.into());
    }
}