Add advanced exercises

Author: MDUYN

benchmark/advanced/multi_class_database_system/.docs/detailed_instructions.md

@@ -0,0 +1,183 @@
+# Multi-Class Database System Challenge
+
+## Problem Description
+
+Implement a complete C++ database abstraction layer that internally uses multiple private classes to manage connections, optimize queries, and handle transactions. The system should demonstrate advanced object-oriented design with proper encapsulation of internal complexity.
+
+## Core Functionality Requirements
+
+Your implementation must handle:
+
+### Connection Management
+- Database connection pooling with automatic scaling
+- Connection health monitoring and recovery
+- Load balancing across multiple database connections
+- Connection timeout and retry mechanisms
+- Resource cleanup and connection lifecycle management
+
+### Query Processing
+- SQL query parsing and validation
+- Query optimization and execution planning
+- Parameter binding and sanitization
+- Result set processing and formatting
+- Query caching and performance monitoring
+
+### Transaction Management
+- Transaction lifecycle (begin, commit, rollback)
+- Isolation level management
+- Deadlock detection and resolution
+- Transaction logging and recovery
+- Nested transaction support
+
+### Data Operations
+- CRUD operations (Create, Read, Update, Delete)
+- Batch processing capabilities
+- Data type conversion and validation
+- Error handling and recovery
+- Performance metrics and statistics
+
+## Main Function Requirements
+
+Implement the following function:
+
+```cpp
+std::string execute_database_operation(const std::string& operation_type,
+                                     const std::string& query,
+                                     const std::map<std::string, std::string>& parameters);
+```
+
+### Function Behavior
+- **Input**: Operation type, SQL query/command, and optional parameters
+- **Output**: Formatted result as JSON string or status message
+- **Process Flow**: Connection pooling → Query optimization → Transaction management → Result formatting
+
+### Supported Operation Types
+
+#### `"SELECT"` - Data Query Operations
+- Execute SELECT queries with parameter binding
+- Return results as formatted JSON with column names and data
+- **Expected Output**: `{"status": "success", "rows": [{"col1": "val1", "col2": "val2"}], "count": N}`
+
+#### `"INSERT"` - Data Insertion Operations
+- Execute INSERT statements with parameter validation
+- Handle single and batch insertions
+- **Expected Output**: `{"status": "success", "affected_rows": N, "last_insert_id": ID}`
+
+#### `"UPDATE"` - Data Modification Operations
+- Execute UPDATE statements with WHERE clause validation
+- Prevent accidental mass updates without conditions
+- **Expected Output**: `{"status": "success", "affected_rows": N}`
+
+#### `"DELETE"` - Data Removal Operations
+- Execute DELETE statements with safety checks
+- Require explicit confirmation for mass deletions
+- **Expected Output**: `{"status": "success", "affected_rows": N}`
+
+#### `"TRANSACTION"` - Transaction Control
+- Begin, commit, or rollback transactions
+- Handle nested transactions and savepoints
+- **Expected Output**: `{"status": "success", "transaction_id": "TXN123", "action": "begin/commit/rollback"}`
+
+#### `"ANALYZE"` - Performance Analysis
+- Analyze query performance and execution plans
+- Return statistics about connection pool and cache usage
+- **Expected Output**: `{"status": "success", "execution_time_ms": N, "rows_examined": N, "cache_hit": true/false}`
+
+## Error Handling Requirements
+
+Your implementation must handle:
+- **Invalid operation types**: Return `{"status": "error", "message": "Invalid operation type"}`
+- **Database connection failures**: Return `{"status": "error", "message": "Database connection failed"}`
+- **SQL syntax errors**: Return `{"status": "error", "message": "SQL syntax error"}`
+- **Transaction errors**: Return `{"status": "error", "message": "Transaction failed"}`
+- **Parameter validation errors**: Handle gracefully with appropriate error messages
+
+## Internal Architecture Requirements
+
+Your solution must demonstrate sophisticated internal design using private classes:
+
+### Connection Pool Manager (Internal)
+- Maintain pool of database connections
+- Handle connection allocation and release
+- Implement connection health checking
+- Manage connection lifecycle and cleanup
+
+### Query Optimizer (Internal)
+- Parse and analyze SQL queries
+- Generate execution plans
+- Cache optimized queries
+- Handle parameter binding and validation
+
+### Transaction Manager (Internal)
+- Coordinate transaction state across connections
+- Handle isolation levels and locking
+- Implement rollback and recovery mechanisms
+- Manage transaction logging
+
+### Result Processor (Internal)
+- Convert database results to JSON format
+- Handle data type conversions
+- Implement pagination and streaming
+- Manage memory efficient result processing
+
+### Cache Manager (Internal)
+- Implement query result caching
+- Handle cache invalidation strategies
+- Manage memory usage and cache eviction
+- Provide cache statistics and monitoring
+
+## Example Usage
+
+```cpp
+// Simple SELECT query
+auto result1 = execute_database_operation("SELECT", 
+    "SELECT id, name, email FROM users WHERE active = ?", 
+    {{"param1", "true"}});
+// Returns: {"status": "success", "rows": [...], "count": 10}
+
+// INSERT with parameters
+auto result2 = execute_database_operation("INSERT",
+    "INSERT INTO users (name, email) VALUES (?, ?)",
+    {{"param1", "John Doe"}, {"param2", "john@example.com"}});
+// Returns: {"status": "success", "affected_rows": 1, "last_insert_id": "123"}
+
+// Transaction management
+auto result3 = execute_database_operation("TRANSACTION", "BEGIN", {});
+// Returns: {"status": "success", "transaction_id": "TXN456", "action": "begin"}
+
+// Performance analysis
+auto result4 = execute_database_operation("ANALYZE", 
+    "SELECT * FROM large_table WHERE indexed_column = ?",
+    {{"param1", "search_value"}});
+// Returns: {"status": "success", "execution_time_ms": 45, "cache_hit": true}
+```
+
+## Design Considerations
+
+Your solution should demonstrate:
+
+### Encapsulation Excellence
+- **Public interface simplicity**: Only the main function should be publicly accessible
+- **Private class hierarchy**: Multiple internal classes handling different concerns  
+- **Information hiding**: Internal implementation details completely hidden from users
+- **Interface stability**: Public API remains constant regardless of internal changes
+
+### Resource Management
+- **RAII principles**: Proper resource acquisition and cleanup
+- **Connection pooling**: Efficient reuse of expensive database connections
+- **Memory management**: Efficient handling of large result sets
+- **Exception safety**: Strong exception guarantees throughout the system
+
+### Performance Optimization
+- **Connection reuse**: Minimize expensive connection establishment overhead
+- **Query caching**: Cache frequently used queries and results  
+- **Batch operations**: Optimize multiple operations into single database calls
+- **Lazy loading**: Load data only when needed to minimize memory usage
+
+### Scalability Design
+- **Thread safety**: Safe concurrent access to shared resources
+- **Load balancing**: Distribute load across multiple database connections
+- **Horizontal scaling**: Design that supports multiple database instances
+- **Performance monitoring**: Built-in metrics for system optimization
+
+This exercise tests the LLM's ability to design and implement sophisticated internal architecture while maintaining a clean, simple public interface - a hallmark of professional enterprise software design.

benchmark/advanced/multi_class_database_system/.docs/instructions.md

@@ -0,0 +1,34 @@
+# Database System with Existing Classes
+
+You have several C++ classes already implemented for database operations:
+- `ConnectionPoolManager` (connection_pool.h/cpp) - manages database connections
+- `QueryOptimizer` (query_optimizer.h/cpp) - optimizes and processes SQL queries  
+- `TransactionManager` (transaction_manager.h/cpp) - handles transactions
+- `ResultProcessor` (result_processor.h/cpp) - formats query results
+- `CacheManager` (cache_manager.h/cpp) - manages query caching
+
+**Your task:** Write an `execute_database_operation` function that coordinates these classes to handle database operations.
+
+## Function to implement:
+```cpp
+std::string execute_database_operation(const std::string& operation_type,
+                                     const std::string& query,
+                                     const std::map<std::string, std::string>& parameters);
+```
+
+## Key points:
+- Initialize all manager classes and coordinate their interactions
+- Use ConnectionPoolManager to get database connections
+- Use QueryOptimizer to process and validate SQL queries
+- Use TransactionManager for transaction control
+- Use ResultProcessor to format results as JSON
+- Use CacheManager to cache frequently used queries
+- Include proper headers for all classes you use
+- Return JSON-formatted results for all operations
+
+## Examples:
+- `execute_database_operation("SELECT", "SELECT * FROM users", {})` should return JSON with query results
+- `execute_database_operation("INSERT", "INSERT INTO users VALUES (?)", {{"param1", "John"}})` should return success status
+- `execute_database_operation("TRANSACTION", "BEGIN", {})` should start a transaction
+
+**Hint:** Create instances of all manager classes, then coordinate them based on operation type.

benchmark/advanced/multi_class_database_system/CMakeLists.txt

@@ -0,0 +1,65 @@
+cmake_minimum_required(VERSION 3.10)
+
+project(multi_class_database_system)
+
+# Set C++17 standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Add compiler flags for better debugging and warnings
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -O2")
+
+# Include directories
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/test)
+
+# Create a static library with the core functionality
+add_library(multi_class_database_system_lib STATIC
+    multi_class_database_system.cpp
+    connection_pool.cpp
+    query_optimizer.cpp
+    transaction_manager.cpp
+    result_processor.cpp
+    cache_manager.cpp
+)
+
+# Define test executable - this is the main target for this project
+if(EXERCISM_RUN_ALL_TESTS)
+    add_executable(test_multi_class_database_system
+        multi_class_database_system_test.cpp
+    )
+
+    # Link the library to the test executable
+    target_link_libraries(test_multi_class_database_system multi_class_database_system_lib)
+
+    # Custom target to run tests automatically with clean output
+    add_custom_target(run_tests ALL
+        COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test_multi_class_database_system
+        DEPENDS test_multi_class_database_system
+        COMMENT ""
+        VERBATIM
+    )
+
+    # Add post-build messages for clean output
+    add_custom_command(TARGET test_multi_class_database_system POST_BUILD
+        COMMAND echo ""
+        COMMENT ""
+    )
+else()
+    # If not running tests, create a simple demo executable
+    add_executable(multi_class_database_system_demo
+        multi_class_database_system.cpp
+        connection_pool.cpp
+        query_optimizer.cpp
+        transaction_manager.cpp
+        result_processor.cpp
+        cache_manager.cpp
+    )
+endif()
+
+# Set output directories
+if(EXERCISM_RUN_ALL_TESTS)
+    set_target_properties(test_multi_class_database_system PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}
+    )
+endif()