implement get_query_granularities & get_pivot_query

Author: KSDaemon

rust/cubeorchestrator/src/cubestore_result_transform.rs

@@ -6,7 +6,7 @@ use crate::types::{
 };
 use anyhow::{bail, Context, Result};
 use chrono::SecondsFormat;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 /// Transform specified `value` with specified `type` to the network protocol type.
 pub fn transform_value(value: DBResponseValue, type_: &str) -> DBResponsePrimitive {
@@ -335,3 +335,72 @@ pub fn transform_data(
         }
     }
 }
+
+/// Helper to get a list if unique granularities from normalized queries
+pub fn get_query_granularities(queries: &[NormalizedQuery]) -> Vec<String> {
+    queries
+        .iter()
+        .filter_map(|query| {
+            query
+                .time_dimensions
+                .as_ref()
+                .and_then(|tds| tds.get(0))
+                .and_then(|td| td.granularity.clone())
+        })
+        .collect::<HashSet<_>>()
+        .into_iter()
+        .collect()
+}
+
+/// Get Pivot Query for a list of queries
+pub fn get_pivot_query(query_type: QueryType, queries: &[NormalizedQuery]) -> Result<NormalizedQuery> {
+    let mut pivot_query = queries
+        .first()
+        .cloned()
+        .ok_or_else(|| anyhow::anyhow!("Queries list cannot be empty"))?;
+
+    match query_type {
+        QueryType::BlendingQuery => {
+            // Merge and deduplicate measures and dimensions across all queries
+            let mut merged_measures = HashSet::new();
+            let mut merged_dimensions = HashSet::new();
+
+            for query in queries {
+                merged_measures.extend(query.measures.iter().cloned());
+                if let Some(dimensions) = &query.dimensions {
+                    merged_dimensions.extend(dimensions.iter().cloned());
+                }
+            }
+
+            pivot_query.measures = merged_measures.into_iter().collect();
+            pivot_query.dimensions = if !merged_dimensions.is_empty() {
+                Some(merged_dimensions.into_iter().collect())
+            } else {
+                None
+            };
+
+            // Add time dimensions
+            let granularities = get_query_granularities(queries);
+            if !granularities.is_empty() {
+                pivot_query.time_dimensions = Some(vec![QueryTimeDimension {
+                    dimension: "time".to_string(),
+                    date_range: None,
+                    compare_date_range: None,
+                    granularity: granularities.get(0).cloned(),
+                }]);
+            }
+        }
+        QueryType::CompareDateRangeQuery => {
+            let mut dimensions = vec![MemberOrMemberExpression::Member("compareDateRange".to_string())];
+            if let Some(dims) = pivot_query.dimensions {
+                dimensions.extend(dims.clone());
+            }
+            pivot_query.dimensions = Option::from(dimensions);
+        }
+        _ => {}
+    }
+
+    pivot_query.query_type = query_type;
+
+    Ok(pivot_query)
+}

rust/cubeorchestrator/src/types.rs

@@ -25,15 +25,15 @@ pub enum DBResponseValue {
     Object { value: DBResponsePrimitive },
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum ResultType {
     #[serde(rename = "default")]
     Default,
     #[serde(rename = "compact")]
     Compact,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum QueryType {
     #[serde(rename = "regularQuery")]
     RegularQuery,
@@ -64,7 +64,7 @@ pub enum MemberType {
     Segments,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum FilterOperator {
     #[serde(rename = "equals")]
     Equals,
@@ -115,14 +115,14 @@ pub struct QueryFilter {
     pub values: Option<Vec<String>>,
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, Hash, Eq, PartialEq)]
 pub struct GroupingSet {
     pub group_type: String,
     pub id: u32,
     pub sub_id: Option<u32>,
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, Hash, Eq, PartialEq)]
 pub struct ParsedMemberExpression {
     pub expression: Vec<String>,
     #[serde(rename = "cubeName")]
@@ -176,13 +176,13 @@ pub struct ConfigItem {
     pub granularities: Option<Vec<GranularityMeta>>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Order {
     pub id: String,
     pub desc: bool,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct NormalizedQueryFilter {
     pub member: String,
     pub operator: FilterOperator,
@@ -191,7 +191,7 @@ pub struct NormalizedQueryFilter {
 }
 
 // XXX: Omitted function variant
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, Hash, Eq, PartialEq)]
 pub enum MemberOrMemberExpression {
     Member(String),
     MemberExpression(ParsedMemberExpression),
@@ -244,7 +244,7 @@ pub struct Query {
     pub response_format: Option<ResultType>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct NormalizedQuery {
     pub measures: Vec<MemberOrMemberExpression>,
     pub dimensions: Option<Vec<MemberOrMemberExpression>>,
@@ -266,6 +266,8 @@ pub struct NormalizedQuery {
     #[serde(rename = "rowLimit")]
     pub row_limit: Option<u32>,
     pub order: Option<Vec<Order>>,
+    #[serde(rename = "queryType")]
+    pub query_type: QueryType,
 }
 
 #[derive(Debug, Serialize, Deserialize)]