Support getting data and metadata from tables (#40)

Author: abbiemery

resources/metadata_table.json

@@ -0,0 +1,57 @@
+{
+  "data": {
+    "id": "internal",
+    "attributes": {
+      "ancestors": [
+        "4866611f-e6d9-4517-bedf-fc5526df57ad",
+        "primary"
+      ],
+      "structure_family": "table",
+      "specs": [],
+      "metadata": {
+        "stage-x": {
+          "dtype": "number",
+          "shape": [],
+          "dtype_numpy": "<f8",
+          "source": "ca://BL01T-MO-SIMC-01:M1.RBV",
+          "units": "degrees",
+          "precision": 5,
+          "limits": {
+            "control": {
+              "low": -20000,
+              "high": 20000
+            },
+            "display": {
+              "low": -20000,
+              "high": 20000
+            }
+          },
+          "object_name": "stage-x"
+        }
+      },
+      "structure": {
+        "arrow_schema": "data:application/vnd.apache.arrow.file;base64,/////xgBAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAQAAACsAAAAaAAAADgAAAAEAAAAdP///wAAAQMQAAAAHAAAAAQAAAAAAAAACgAAAHRzX3N0YWdlLXgAAKr///8AAAIApP///wAAAQMQAAAAGAAAAAQAAAAAAAAABwAAAHN0YWdlLXgA1v///wAAAgDQ////AAABAxAAAAAcAAAABAAAAAAAAAAEAAAAdGltZQAABgAIAAYABgAAAAAAAgAQABQACAAGAAcADAAAABAAEAAAAAAAAQIQAAAAIAAAAAQAAAAAAAAABwAAAHNlcV9udW0ACAAMAAgABwAIAAAAAAAAAUAAAAAAAAAA",
+        "npartitions": 1,
+        "columns": [
+          "seq_num",
+          "time",
+          "stage-x",
+          "ts_stage-x"
+        ],
+        "resizable": false
+      },
+      "access_blob": {},
+      "sorting": null,
+      "data_sources": null
+    },
+    "links": {
+      "self": "http://127.0.0.1:8000/api/v1/metadata/4866611f-e6d9-4517-bedf-fc5526df57ad/primary/internal",
+      "full": "http://127.0.0.1:8000/api/v1/table/full/4866611f-e6d9-4517-bedf-fc5526df57ad/primary/internal",
+      "partition": "http://127.0.0.1:8000/api/v1/table/partition/4866611f-e6d9-4517-bedf-fc5526df57ad/primary/internal?partition={index}"
+    },
+    "meta": null
+  },
+  "error": null,
+  "links": null,
+  "meta": {}
+}

resources/table_full.json

@@ -0,0 +1,30 @@
+{
+  "seq_num": [
+    1,
+    2,
+    3,
+    4,
+    5
+  ],
+  "time": [
+    1762787606.459906,
+    1762787609.4694269,
+    1762787612.4223065,
+    1762787615.400967,
+    1762787618.4348016
+  ],
+  "stage-x": [
+    0,
+    2.5,
+    5,
+    7.5,
+    10
+  ],
+  "ts_stage-x": [
+    631152000,
+    1762787609.198412,
+    1762787612.10868,
+    1762787615.118978,
+    1762787618.129375
+  ]
+}

src/clients.rs

@@ -6,7 +6,7 @@ use serde::de::DeserializeOwned;
 use tracing::{info, instrument};
 use uuid::Uuid;
 
-use crate::model::{app, event_stream, run};
+use crate::model::{app, event_stream, run, table};
 
 pub type ClientResult<T> = Result<T, ClientError>;
 
@@ -46,6 +46,30 @@ impl TiledClient {
         self.request(&format!("/api/v1/metadata/{id}/{stream}"), None)
             .await
     }
+    pub async fn table_metadata(
+        &self,
+        id: Uuid,
+        stream: String,
+        table: String,
+    ) -> ClientResult<table::TableMetadataRoot> {
+        self.request(&format!("/api/v1/metadata/{id}/{stream}/{table}"), None)
+            .await
+    }
+    pub async fn table_full(
+        &self,
+        id: Uuid,
+        stream: String,
+        table: String,
+    ) -> ClientResult<table::Table> {
+        let mut headers = HeaderMap::new();
+        headers.insert("accept", "application/json".parse().unwrap());
+
+        self.request(
+            &format!("/api/v1/table/full/{id}/{stream}/{table}"),
+            Some(headers),
+        )
+        .await
+    }
     pub async fn search_root(&self) -> ClientResult<run::RunRoot> {
         self.request("/api/v1/search/", None).await
     }

src/model.rs

@@ -3,6 +3,7 @@ pub(crate) mod container;
 pub(crate) mod event_stream;
 pub(crate) mod node;
 pub(crate) mod run;
+pub(crate) mod table;
 
 use async_graphql::Object;
 use tracing::instrument;
@@ -31,6 +32,24 @@ impl TiledQuery {
         self.0.event_stream_metadata(id, stream).await
     }
     #[instrument(skip(self))]
+    async fn table_metadata(
+        &self,
+        id: Uuid,
+        stream: String,
+        table: String,
+    ) -> Result<table::TableMetadataRoot, ClientError> {
+        self.0.table_metadata(id, stream, table).await
+    }
+    #[instrument(skip(self))]
+    async fn table_full(
+        &self,
+        id: Uuid,
+        stream: String,
+        table: String,
+    ) -> Result<table::Table, ClientError> {
+        self.0.table_full(id, stream, table).await
+    }
+    #[instrument(skip(self))]
     async fn search_root(&self) -> Result<run::RunRoot, ClientError> {
         self.0.search_root().await
     }
@@ -104,6 +123,31 @@ mod tests {
         mock.assert();
     }
     #[tokio::test]
+    async fn table_metadata() {
+        let id = Uuid::parse_str("4866611f-e6d9-4517-bedf-fc5526df57ad").unwrap();
+        let stream = "primary";
+        let table = "internal";
+        let server = MockServer::start();
+        let mock = server
+            .mock_async(|when, then| {
+                when.method("GET")
+                    .path(format!("/api/v1/metadata/{id}/{stream}/{table}"));
+                then.status(200)
+                    .body_from_file("resources/metadata_table.json");
+            })
+            .await;
+        let schema = build_schema(&server.base_url());
+        let query = r#"{ tableMetadata(id:"4866611f-e6d9-4517-bedf-fc5526df57ad", stream:"primary", table:"internal") {data {id}}}"#;
+        let response = schema.execute(query).await;
+        let exp = value! ({
+            "tableMetadata": { "data": {"id": "internal"}}
+        });
+
+        assert_eq!(response.data, exp);
+        assert_eq!(response.errors, &[]);
+        mock.assert();
+    }
+    #[tokio::test]
     async fn search_root() {
         let server = MockServer::start();
         let mock = server

src/model/table.rs

@@ -0,0 +1,69 @@
+use std::collections::HashMap;
+
+use async_graphql::SimpleObject;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use crate::model::node;
+
+pub type Table = HashMap<String, Vec<Value>>;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+pub struct TableMetadataRoot {
+    pub data: TableData,
+    pub error: Value,
+    pub links: Option<node::Links>,
+    pub meta: Value,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+pub struct TableData {
+    pub id: String,
+    pub attributes: TableAttributes,
+    pub links: TableLinks,
+    pub meta: Value,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+pub struct TableAttributes {
+    pub ancestors: Vec<Value>,
+    pub structure_family: String,
+    pub specs: Option<Vec<Value>>,
+    pub metadata: HashMap<String, Value>,
+    pub structure: TableStructure,
+    pub access_blob: Value,
+    pub sorting: Value,
+    pub data_sources: Value,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+pub struct TableStructure {
+    pub arrow_schema: String,
+    pub npartitions: i64,
+    pub columns: Vec<Value>,
+    pub resizable: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+pub struct TableLinks {
+    #[serde(rename = "self")]
+    #[graphql(name = "self")]
+    pub self_field: String,
+    pub full: Option<String>,
+    pub partition: Option<String>,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::model::table;
+    use crate::test_utils::assert_readable_as;
+
+    #[test]
+    fn table_metadata() {
+        assert_readable_as::<table::TableMetadataRoot>("resources/metadata_table.json");
+    }
+    #[test]
+    fn table_full() {
+        assert_readable_as::<table::Table>("resources/table_full.json");
+    }
+}