compiler tests in work

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs

@@ -161,3 +161,172 @@ impl Compiler {
         Ok(node)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_fixtures::cube_bridge::{MockCubeEvaluator, MockSecurityContext, MockSqlUtils};
+    use crate::test_fixtures::schemas::create_visitors_schema;
+    use chrono_tz::Tz;
+
+    #[test]
+    fn test_add_dimension_evaluator_number_dimension() {
+        let schema = create_visitors_schema();
+        let evaluator = Rc::new(MockCubeEvaluator::new(schema));
+        let sql_utils = Rc::new(MockSqlUtils);
+        let security_context = Rc::new(MockSecurityContext);
+        let timezone = Tz::UTC;
+
+        let mut compiler = Compiler::new(evaluator, sql_utils, security_context, timezone);
+
+        let symbol = compiler
+            .add_dimension_evaluator("visitors.id".to_string())
+            .unwrap();
+
+        // Check symbol type
+        assert!(symbol.is_dimension());
+        assert!(!symbol.is_measure());
+
+        // Check full name
+        assert_eq!(symbol.full_name(), "visitors.id");
+
+        // Check cube name and member name
+        assert_eq!(symbol.cube_name(), "visitors");
+        assert_eq!(symbol.name(), "id");
+
+        // Check no dependencies for simple dimension
+        let dependencies = symbol.get_dependencies();
+        assert_eq!(
+            dependencies.len(),
+            0,
+            "Simple dimension should have no dependencies"
+        );
+
+        // Check dimension type
+        let dimension = symbol.as_dimension().unwrap();
+        assert_eq!(dimension.dimension_type(), "number");
+    }
+
+    #[test]
+    fn test_add_dimension_evaluator_string_dimension() {
+        let schema = create_visitors_schema();
+        let evaluator = Rc::new(MockCubeEvaluator::new(schema));
+        let sql_utils = Rc::new(MockSqlUtils);
+        let security_context = Rc::new(MockSecurityContext);
+        let timezone = Tz::UTC;
+
+        let mut compiler = Compiler::new(evaluator, sql_utils, security_context, timezone);
+
+        let symbol = compiler
+            .add_dimension_evaluator("visitors.source".to_string())
+            .unwrap();
+
+        // Check symbol type
+        assert!(symbol.is_dimension());
+        assert!(!symbol.is_measure());
+
+        // Check full name
+        assert_eq!(symbol.full_name(), "visitors.source");
+
+        // Check cube name and member name
+        assert_eq!(symbol.cube_name(), "visitors");
+        assert_eq!(symbol.name(), "source");
+
+        // Check no dependencies for simple dimension
+        let dependencies = symbol.get_dependencies();
+        assert_eq!(
+            dependencies.len(),
+            0,
+            "Simple dimension should have no dependencies"
+        );
+
+        // Check dimension type
+        let dimension = symbol.as_dimension().unwrap();
+        assert_eq!(dimension.dimension_type(), "string");
+    }
+
+    #[test]
+    fn test_add_dimension_evaluator_caching() {
+        let schema = create_visitors_schema();
+        let evaluator = Rc::new(MockCubeEvaluator::new(schema));
+        let sql_utils = Rc::new(MockSqlUtils);
+        let security_context = Rc::new(MockSecurityContext);
+        let timezone = Tz::UTC;
+
+        let mut compiler = Compiler::new(evaluator, sql_utils, security_context, timezone);
+
+        // Add dimension twice
+        let symbol1 = compiler
+            .add_dimension_evaluator("visitors.id".to_string())
+            .unwrap();
+        let symbol2 = compiler
+            .add_dimension_evaluator("visitors.id".to_string())
+            .unwrap();
+
+        // Should return the same cached instance
+        assert_eq!(
+            symbol1.full_name(),
+            symbol2.full_name(),
+            "Cached symbols should have the same full name"
+        );
+    }
+
+    #[test]
+    fn test_add_dimension_evaluator_invalid_path() {
+        let schema = create_visitors_schema();
+        let evaluator = Rc::new(MockCubeEvaluator::new(schema));
+        let sql_utils = Rc::new(MockSqlUtils);
+        let security_context = Rc::new(MockSecurityContext);
+        let timezone = Tz::UTC;
+
+        let mut compiler = Compiler::new(evaluator, sql_utils, security_context, timezone);
+
+        // Try to add non-existent dimension
+        let result = compiler.add_dimension_evaluator("nonexistent.dimension".to_string());
+
+        assert!(result.is_err(), "Should fail for non-existent dimension");
+    }
+
+    #[test]
+    fn test_add_dimension_evaluator_multiple_dimensions() {
+        let schema = create_visitors_schema();
+        let evaluator = Rc::new(MockCubeEvaluator::new(schema));
+        let sql_utils = Rc::new(MockSqlUtils);
+        let security_context = Rc::new(MockSecurityContext);
+        let timezone = Tz::UTC;
+
+        let mut compiler = Compiler::new(evaluator, sql_utils, security_context, timezone);
+
+        // Add multiple different dimensions
+        let id_symbol = compiler
+            .add_dimension_evaluator("visitors.id".to_string())
+            .unwrap();
+        let source_symbol = compiler
+            .add_dimension_evaluator("visitors.source".to_string())
+            .unwrap();
+        let created_at_symbol = compiler
+            .add_dimension_evaluator("visitors.created_at".to_string())
+            .unwrap();
+
+        // Verify each dimension
+        assert_eq!(id_symbol.full_name(), "visitors.id");
+        assert_eq!(id_symbol.as_dimension().unwrap().dimension_type(), "number");
+
+        assert_eq!(source_symbol.full_name(), "visitors.source");
+        assert_eq!(
+            source_symbol.as_dimension().unwrap().dimension_type(),
+            "string"
+        );
+
+        assert_eq!(created_at_symbol.full_name(), "visitors.created_at");
+        assert_eq!(
+            created_at_symbol.as_dimension().unwrap().dimension_type(),
+            "time"
+        );
+
+        // All should have no dependencies
+        assert_eq!(id_symbol.get_dependencies().len(), 0);
+        assert_eq!(source_symbol.get_dependencies().len(), 0);
+        assert_eq!(created_at_symbol.get_dependencies().len(), 0);
+    }
+}

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/geo_dimension.rs

@@ -1,33 +1,21 @@
-mod calendar_dimension;
-mod case_dimension;
 mod common;
 mod cube_symbol;
 mod dimension_symbol;
-mod geo_dimension;
 mod measure_symbol;
 mod member_expression_symbol;
 mod member_symbol;
-mod primitive_type;
-mod simple_dimension;
-mod switch_dimension;
 mod symbol_factory;
 mod time_dimension_symbol;
 
-pub use calendar_dimension::CalendarDimension;
-pub use case_dimension::CaseDimension;
 pub use common::*;
 pub use cube_symbol::{
     CubeNameSymbol, CubeNameSymbolFactory, CubeTableSymbol, CubeTableSymbolFactory,
 };
 pub use dimension_symbol::*;
-pub use geo_dimension::GeoDimension;
 pub use measure_symbol::{
     DimensionTimeShift, MeasureSymbol, MeasureSymbolFactory, MeasureTimeShifts,
 };
 pub use member_expression_symbol::{MemberExpressionExpression, MemberExpressionSymbol};
 pub use member_symbol::MemberSymbol;
-pub use primitive_type::*;
-pub use simple_dimension::SimpleDimension;
-pub use switch_dimension::SwitchDimension;
 pub use symbol_factory::SymbolFactory;
 pub use time_dimension_symbol::TimeDimensionSymbol;