exonware-xwnode 0.0.1.12__py3-none-any.whl

exonware/xwnode/strategies/queries/base.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""
+Query Strategy Base Classes
+
+This module defines the abstract base classes for all query strategy implementations:
+- AQueryStrategy: Base strategy for all query implementations
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.12
+Generation Date: January 2, 2025
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional, List, Dict, Union, Type
+from datetime import datetime
+
+from ...contracts import iQuery, iQueryResult, IQueryStrategy, QueryMode, QueryTrait
+from ...errors import XWNodeTypeError, XWNodeValueError
+from ...base import XWNodeBase
+
+
+class AQueryStrategy(IQueryStrategy):
+    """Base strategy for all query implementations with XWQuery Script support."""
+    
+    def __init__(self, **options):
+        """Initialize query strategy."""
+        self._options = options
+        self._mode = options.get('mode', QueryMode.AUTO)
+        self._traits = options.get('traits', QueryTrait.NONE)
+    
+    @abstractmethod
+    def execute(self, query: str, **kwargs) -> Any:
+        """Execute query."""
+        pass
+    
+    @abstractmethod
+    def validate_query(self, query: str) -> bool:
+        """Validate query syntax."""
+        pass
+    
+    @abstractmethod
+    def get_query_plan(self, query: str) -> Dict[str, Any]:
+        """Get query execution plan."""
+        pass
+    
+    def get_mode(self) -> QueryMode:
+        """Get strategy mode."""
+        return self._mode
+    
+    def get_traits(self) -> QueryTrait:
+        """Get strategy traits."""
+        return self._traits
+    
+    def to_native(self) -> 'XWQueryScriptStrategy':
+        """Convert this strategy to XWQueryScriptStrategy using actions."""
+        from .xwquery_strategy import XWQueryScriptStrategy
+        return XWQueryScriptStrategy()
+    
+    def to_actions_tree(self, query: str) -> XWNodeBase:
+        """Convert query to actions tree - default implementation."""
+        script_strategy = self.to_native().from_format(query, self.get_query_type())
+        return script_strategy.get_actions_tree()
+    
+    def from_actions_tree(self, actions_tree: XWNodeBase) -> str:
+        """Convert actions tree to query - default implementation."""
+        script_strategy = self.to_native()
+        script_strategy._actions_tree = actions_tree
+        return script_strategy.to_format(self.get_query_type())
+    
+    def get_query_type(self) -> str:
+        """Get the query type for this strategy."""
+        return self.__class__.__name__.replace('Strategy', '').upper()
+
+
+class AQueryActionExecutor(AQueryStrategy):
+    """Abstract base for query action executors with XWQuery Script support."""
+    
+    @abstractmethod
+    def execute_query(self, query: str, query_type: str, **kwargs) -> Any:
+        """Execute a query on this backend."""
+        pass
+    
+    @abstractmethod
+    def validate_query(self, query: str, query_type: str) -> bool:
+        """Validate if this backend can handle the query."""
+        pass
+    
+    @abstractmethod
+    def get_supported_query_types(self) -> List[str]:
+        """Get list of query types this backend supports."""
+        pass
+    
+    def to_native(self) -> 'XWQueryScriptStrategy':
+        """Convert this executor to XWQueryScriptStrategy using actions."""
+        from .xwquery_strategy import XWQueryScriptStrategy
+        return XWQueryScriptStrategy()
+    
+    def to_actions_tree(self, query: str) -> XWNodeBase:
+        """Convert query to actions tree - default implementation."""
+        script_strategy = self.to_native().from_format(query, self.get_query_type())
+        return script_strategy.get_actions_tree()
+    
+    def from_actions_tree(self, actions_tree: XWNodeBase) -> str:
+        """Convert actions tree to query - default implementation."""
+        script_strategy = self.to_native()
+        script_strategy._actions_tree = actions_tree
+        return script_strategy.to_format(self.get_query_type())
+
+
+class ALinearQueryStrategy(AQueryStrategy):
+    """Linear query capabilities."""
+    
+    def find_by_index(self, index: int) -> Any:
+        """Find element by index."""
+        raise NotImplementedError("Subclasses must implement find_by_index")
+    
+    def find_by_value(self, value: Any) -> List[int]:
+        """Find indices by value."""
+        raise NotImplementedError("Subclasses must implement find_by_value")
+    
+    def range_query(self, start_index: int, end_index: int) -> List[Any]:
+        """Query range of indices."""
+        raise NotImplementedError("Subclasses must implement range_query")
+    
+    def count_occurrences(self, value: Any) -> int:
+        """Count occurrences of value."""
+        raise NotImplementedError("Subclasses must implement count_occurrences")
+
+
+class ATreeQueryStrategy(AQueryStrategy):
+    """Tree query capabilities."""
+    
+    def find_by_key(self, key: Any) -> Any:
+        """Find by key."""
+        raise NotImplementedError("Subclasses must implement find_by_key")
+    
+    def range_query(self, start_key: Any, end_key: Any) -> List[Any]:
+        """Range query."""
+        raise NotImplementedError("Subclasses must implement range_query")
+    
+    def prefix_query(self, prefix: str) -> List[Any]:
+        """Find all keys with prefix."""
+        raise NotImplementedError("Subclasses must implement prefix_query")
+    
+    def suffix_query(self, suffix: str) -> List[Any]:
+        """Find all keys with suffix."""
+        raise NotImplementedError("Subclasses must implement suffix_query")
+
+
+class AGraphQueryStrategy(AQueryStrategy):
+    """Graph query capabilities."""
+    
+    def path_query(self, start: Any, end: Any) -> List[Any]:
+        """Path query."""
+        raise NotImplementedError("Subclasses must implement path_query")
+    
+    def neighbor_query(self, node: Any) -> List[Any]:
+        """Neighbor query."""
+        raise NotImplementedError("Subclasses must implement neighbor_query")
+    
+    def shortest_path_query(self, start: Any, end: Any) -> List[Any]:
+        """Shortest path query."""
+        raise NotImplementedError("Subclasses must implement shortest_path_query")
+    
+    def connected_components_query(self) -> List[List[Any]]:
+        """Connected components query."""
+        raise NotImplementedError("Subclasses must implement connected_components_query")
+    
+    def cycle_detection_query(self) -> List[List[Any]]:
+        """Cycle detection query."""
+        raise NotImplementedError("Subclasses must implement cycle_detection_query")
+
+
+class AStructuredQueryStrategy(AQueryStrategy):
+    """Structured query capabilities for SQL-like languages."""
+    
+    @abstractmethod
+    def select_query(self, table: str, columns: List[str], where_clause: str = None) -> Any:
+        """Execute SELECT query."""
+        pass
+    
+    @abstractmethod
+    def insert_query(self, table: str, data: Dict[str, Any]) -> Any:
+        """Execute INSERT query."""
+        pass
+    
+    @abstractmethod
+    def update_query(self, table: str, data: Dict[str, Any], where_clause: str = None) -> Any:
+        """Execute UPDATE query."""
+        pass
+    
+    @abstractmethod
+    def delete_query(self, table: str, where_clause: str = None) -> Any:
+        """Execute DELETE query."""
+        pass
+    
+    @abstractmethod
+    def join_query(self, tables: List[str], join_conditions: List[str]) -> Any:
+        """Execute JOIN query."""
+        pass
+    
+    @abstractmethod
+    def aggregate_query(self, table: str, functions: List[str], group_by: List[str] = None) -> Any:
+        """Execute aggregate query."""
+        pass
+
+
+class ADocumentQueryStrategy(AQueryStrategy):
+    """Document query capabilities for JSON/XML-like languages."""
+    
+    @abstractmethod
+    def path_query(self, path: str) -> Any:
+        """Execute path-based query."""
+        pass
+    
+    @abstractmethod
+    def filter_query(self, filter_expression: str) -> Any:
+        """Execute filter query."""
+        pass
+    
+    @abstractmethod
+    def projection_query(self, fields: List[str]) -> Any:
+        """Execute projection query."""
+        pass
+    
+    @abstractmethod
+    def sort_query(self, sort_fields: List[str], order: str = "asc") -> Any:
+        """Execute sort query."""
+        pass
+    
+    @abstractmethod
+    def limit_query(self, limit: int, offset: int = 0) -> Any:
+        """Execute limit query."""
+        pass

exonware/xwnode/strategies/queries/cql.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""
+CQL Query Strategy
+
+This module implements the CQL query strategy for Cassandra Query Language operations.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.12
+Generation Date: January 2, 2025
+"""
+
+import re
+from typing import Any, Dict, List, Optional, Union
+from .base import AStructuredQueryStrategy
+from ...errors import XWNodeTypeError, XWNodeValueError
+from ...contracts import QueryMode, QueryTrait
+
+
+class CQLStrategy(AStructuredQueryStrategy):
+    """
+    CQL query strategy for Cassandra Query Language operations.
+    
+    Supports:
+    - CQL 3.0+ features
+    - SELECT, INSERT, UPDATE, DELETE operations
+    - CREATE, DROP, ALTER operations
+    - Batch operations
+    - Time-to-live (TTL) operations
+    """
+    
+    def __init__(self, **options):
+        super().__init__(**options)
+        self._mode = QueryMode.CQL
+        self._traits = QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL | QueryTrait.BATCH
+    
+    def execute(self, query: str, **kwargs) -> Any:
+        """Execute CQL query."""
+        if not self.validate_query(query):
+            raise XWNodeValueError(f"Invalid CQL query: {query}")
+        
+        query_type = self._get_query_type(query)
+        
+        if query_type == "SELECT":
+            return self._execute_select(query, **kwargs)
+        elif query_type == "INSERT":
+            return self._execute_insert(query, **kwargs)
+        elif query_type == "UPDATE":
+            return self._execute_update(query, **kwargs)
+        elif query_type == "DELETE":
+            return self._execute_delete(query, **kwargs)
+        else:
+            raise XWNodeValueError(f"Unsupported query type: {query_type}")
+    
+    def validate_query(self, query: str) -> bool:
+        """Validate CQL query syntax."""
+        if not query or not isinstance(query, str):
+            return False
+        
+        # Basic CQL validation
+        query = query.strip().upper()
+        valid_operations = ["SELECT", "INSERT", "UPDATE", "DELETE", "CREATE", "DROP", "ALTER", "USE", "TRUNCATE", "BATCH", "GRANT", "REVOKE", "LIST", "DESCRIBE", "EXPLAIN"]
+        
+        for operation in valid_operations:
+            if query.startswith(operation):
+                return True
+        
+        return False
+    
+    def get_query_plan(self, query: str) -> Dict[str, Any]:
+        """Get CQL query execution plan."""
+        query_type = self._get_query_type(query)
+        
+        return {
+            "query_type": query_type,
+            "operation": query_type,
+            "complexity": self._estimate_complexity(query),
+            "estimated_cost": self._estimate_cost(query),
+            "operations": self._extract_operations(query),
+            "optimization_hints": self._get_optimization_hints(query)
+        }
+    
+    def select_query(self, table: str, columns: List[str], where_clause: str = None) -> Any:
+        """Execute SELECT query."""
+        query = f"SELECT {', '.join(columns)} FROM {table}"
+        if where_clause:
+            query += f" WHERE {where_clause}"
+        
+        return self.execute(query)
+    
+    def insert_query(self, table: str, data: Dict[str, Any]) -> Any:
+        """Execute INSERT query."""
+        columns = list(data.keys())
+        values = list(data.values())
+        
+        query = f"INSERT INTO {table} ({', '.join(columns)}) VALUES ({', '.join(['?' for _ in values])})"
+        return self.execute(query, values=values)
+    
+    def update_query(self, table: str, data: Dict[str, Any], where_clause: str = None) -> Any:
+        """Execute UPDATE query."""
+        set_clause = ', '.join([f"{k} = ?" for k in data.keys()])
+        query = f"UPDATE {table} SET {set_clause}"
+        
+        if where_clause:
+            query += f" WHERE {where_clause}"
+        
+        return self.execute(query, values=list(data.values()))
+    
+    def delete_query(self, table: str, where_clause: str = None) -> Any:
+        """Execute DELETE query."""
+        query = f"DELETE FROM {table}"
+        if where_clause:
+            query += f" WHERE {where_clause}"
+        
+        return self.execute(query)
+    
+    def join_query(self, tables: List[str], join_conditions: List[str]) -> Any:
+        """Execute JOIN query."""
+        # CQL doesn't support traditional JOINs, use denormalization
+        raise XWNodeValueError("CQL doesn't support JOIN operations. Use denormalization instead.")
+    
+    def aggregate_query(self, table: str, functions: List[str], group_by: List[str] = None) -> Any:
+        """Execute aggregate query."""
+        query = f"SELECT {', '.join(functions)} FROM {table}"
+        if group_by:
+            query += f" GROUP BY {', '.join(group_by)}"
+        
+        return self.execute(query)
+    
+    def _get_query_type(self, query: str) -> str:
+        """Extract query type from CQL query."""
+        query = query.strip().upper()
+        for operation in ["SELECT", "INSERT", "UPDATE", "DELETE", "CREATE", "DROP", "ALTER", "USE", "TRUNCATE", "BATCH", "GRANT", "REVOKE", "LIST", "DESCRIBE", "EXPLAIN"]:
+            if query.startswith(operation):
+                return operation
+        return "UNKNOWN"
+    
+    def _execute_select(self, query: str, **kwargs) -> Any:
+        """Execute SELECT query."""
+        return {"result": "CQL SELECT executed", "query": query}
+    
+    def _execute_insert(self, query: str, **kwargs) -> Any:
+        """Execute INSERT query."""
+        return {"result": "CQL INSERT executed", "query": query}
+    
+    def _execute_update(self, query: str, **kwargs) -> Any:
+        """Execute UPDATE query."""
+        return {"result": "CQL UPDATE executed", "query": query}
+    
+    def _execute_delete(self, query: str, **kwargs) -> Any:
+        """Execute DELETE query."""
+        return {"result": "CQL DELETE executed", "query": query}
+    
+    def _estimate_complexity(self, query: str) -> str:
+        """Estimate query complexity."""
+        operations = self._extract_operations(query)
+        
+        if len(operations) > 5:
+            return "HIGH"
+        elif len(operations) > 2:
+            return "MEDIUM"
+        else:
+            return "LOW"
+    
+    def _estimate_cost(self, query: str) -> int:
+        """Estimate query cost."""
+        complexity = self._estimate_complexity(query)
+        if complexity == "HIGH":
+            return 120
+        elif complexity == "MEDIUM":
+            return 60
+        else:
+            return 30
+    
+    def _extract_operations(self, query: str) -> List[str]:
+        """Extract CQL operations from query."""
+        operations = []
+        
+        cql_operations = ["SELECT", "INSERT", "UPDATE", "DELETE", "CREATE", "DROP", "ALTER", "USE", "TRUNCATE", "BATCH", "GRANT", "REVOKE", "LIST", "DESCRIBE", "EXPLAIN"]
+        
+        for operation in cql_operations:
+            if operation in query.upper():
+                operations.append(operation)
+        
+        return operations
+    
+    def _get_optimization_hints(self, query: str) -> List[str]:
+        """Get query optimization hints."""
+        hints = []
+        
+        if "SELECT *" in query.upper():
+            hints.append("Consider specifying columns instead of using *")
+        
+        if "WHERE" not in query.upper() and "SELECT" in query.upper():
+            hints.append("Consider adding WHERE clause to limit results")
+        
+        if "ORDER BY" in query.upper():
+            hints.append("Consider using clustering columns for ORDER BY operations")
+        
+        return hints

exonware/xwnode/strategies/queries/cypher.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""
+Cypher Query Strategy
+
+This module implements the Cypher query strategy for Neo4j graph queries.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.12
+Generation Date: January 2, 2025
+"""
+
+import re
+from typing import Any, Dict, List, Optional, Union
+from .base import AGraphQueryStrategy
+from ...errors import XWNodeTypeError, XWNodeValueError
+from ...contracts import QueryMode, QueryTrait
+
+
+class CypherStrategy(AGraphQueryStrategy):
+    """
+    Cypher query strategy for Neo4j graph queries.
+    
+    Supports:
+    - Cypher query language
+    - MATCH, CREATE, MERGE, DELETE operations
+    - WHERE clauses and conditions
+    - RETURN and WITH clauses
+    - Path expressions and patterns
+    """
+    
+    def __init__(self, **options):
+        super().__init__(**options)
+        self._mode = QueryMode.CYPHER
+        self._traits = QueryTrait.GRAPH | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
+    
+    def execute(self, query: str, **kwargs) -> Any:
+        """Execute Cypher query."""
+        if not self.validate_query(query):
+            raise XWNodeValueError(f"Invalid Cypher query: {query}")
+        
+        query_type = self._get_query_type(query)
+        
+        if query_type == "MATCH":
+            return self._execute_match(query, **kwargs)
+        elif query_type == "CREATE":
+            return self._execute_create(query, **kwargs)
+        elif query_type == "MERGE":
+            return self._execute_merge(query, **kwargs)
+        elif query_type == "DELETE":
+            return self._execute_delete(query, **kwargs)
+        else:
+            raise XWNodeValueError(f"Unsupported query type: {query_type}")
+    
+    def validate_query(self, query: str) -> bool:
+        """Validate Cypher query syntax."""
+        if not query or not isinstance(query, str):
+            return False
+        
+        # Basic Cypher validation
+        query = query.strip().upper()
+        valid_operations = ["MATCH", "CREATE", "MERGE", "DELETE", "SET", "REMOVE", "RETURN", "WITH", "UNWIND", "CALL", "LOAD", "USING"]
+        
+        for operation in valid_operations:
+            if query.startswith(operation):
+                return True
+        
+        return False
+    
+    def get_query_plan(self, query: str) -> Dict[str, Any]:
+        """Get Cypher query execution plan."""
+        query_type = self._get_query_type(query)
+        
+        return {
+            "query_type": query_type,
+            "operation": query_type,
+            "complexity": self._estimate_complexity(query),
+            "estimated_cost": self._estimate_cost(query),
+            "patterns": self._extract_patterns(query),
+            "optimization_hints": self._get_optimization_hints(query)
+        }
+    
+    def path_query(self, start: Any, end: Any) -> List[Any]:
+        """Execute path query."""
+        query = f"MATCH p = (start {{id: '{start}'}})-[*]->(end {{id: '{end}'}}) RETURN p"
+        return self.execute(query)
+    
+    def neighbor_query(self, node: Any) -> List[Any]:
+        """Execute neighbor query."""
+        query = f"MATCH (n {{id: '{node}'}})-[r]-(neighbor) RETURN neighbor"
+        return self.execute(query)
+    
+    def shortest_path_query(self, start: Any, end: Any) -> List[Any]:
+        """Execute shortest path query."""
+        query = f"MATCH p = shortestPath((start {{id: '{start}'}})-[*]->(end {{id: '{end}'}})) RETURN p"
+        return self.execute(query)
+    
+    def connected_components_query(self) -> List[List[Any]]:
+        """Execute connected components query."""
+        query = "MATCH (n) RETURN n, size((n)-[*]-()) as component_size"
+        return self.execute(query)
+    
+    def cycle_detection_query(self) -> List[List[Any]]:
+        """Execute cycle detection query."""
+        query = "MATCH p = (n)-[r*]->(n) RETURN p"
+        return self.execute(query)
+    
+    def _get_query_type(self, query: str) -> str:
+        """Extract query type from Cypher query."""
+        query = query.strip().upper()
+        for operation in ["MATCH", "CREATE", "MERGE", "DELETE", "SET", "REMOVE", "RETURN", "WITH", "UNWIND", "CALL", "LOAD", "USING"]:
+            if query.startswith(operation):
+                return operation
+        return "UNKNOWN"
+    
+    def _execute_match(self, query: str, **kwargs) -> Any:
+        """Execute MATCH query."""
+        return {"result": "Cypher MATCH executed", "query": query}
+    
+    def _execute_create(self, query: str, **kwargs) -> Any:
+        """Execute CREATE query."""
+        return {"result": "Cypher CREATE executed", "query": query}
+    
+    def _execute_merge(self, query: str, **kwargs) -> Any:
+        """Execute MERGE query."""
+        return {"result": "Cypher MERGE executed", "query": query}
+    
+    def _execute_delete(self, query: str, **kwargs) -> Any:
+        """Execute DELETE query."""
+        return {"result": "Cypher DELETE executed", "query": query}
+    
+    def _estimate_complexity(self, query: str) -> str:
+        """Estimate query complexity."""
+        patterns = self._extract_patterns(query)
+        
+        if len(patterns) > 5:
+            return "HIGH"
+        elif len(patterns) > 2:
+            return "MEDIUM"
+        else:
+            return "LOW"
+    
+    def _estimate_cost(self, query: str) -> int:
+        """Estimate query cost."""
+        complexity = self._estimate_complexity(query)
+        if complexity == "HIGH":
+            return 160
+        elif complexity == "MEDIUM":
+            return 80
+        else:
+            return 40
+    
+    def _extract_patterns(self, query: str) -> List[str]:
+        """Extract Cypher patterns from query."""
+        patterns = []
+        
+        # Look for node patterns
+        node_patterns = re.findall(r'\([^)]+\)', query)
+        patterns.extend(node_patterns)
+        
+        # Look for relationship patterns
+        rel_patterns = re.findall(r'\[[^\]]+\]', query)
+        patterns.extend(rel_patterns)
+        
+        return patterns
+    
+    def _get_optimization_hints(self, query: str) -> List[str]:
+        """Get query optimization hints."""
+        hints = []
+        
+        if "MATCH" in query.upper() and "WHERE" not in query.upper():
+            hints.append("Consider adding WHERE clause to limit results")
+        
+        if "shortestPath" in query:
+            hints.append("Consider using indexes for shortestPath operations")
+        
+        if "RETURN *" in query.upper():
+            hints.append("Consider specifying specific properties instead of using *")
+        
+        return hints

exonware/xwnode/strategies/queries/datalog.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+Datalog Query Strategy
+
+This module implements the Datalog query strategy for Datalog operations.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.12
+Generation Date: January 2, 2025
+"""
+
+from typing import Any, Dict, List, Optional
+from .base import AStructuredQueryStrategy
+from ...errors import XWNodeValueError
+from ...contracts import QueryMode, QueryTrait
+
+
+class DatalogStrategy(AStructuredQueryStrategy):
+    """Datalog query strategy for Datalog operations."""
+    
+    def __init__(self, **options):
+        super().__init__(**options)
+        self._mode = QueryMode.DATALOG
+        self._traits = QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL | QueryTrait.BATCH
+    
+    def execute(self, query: str, **kwargs) -> Any:
+        """Execute Datalog query."""
+        if not self.validate_query(query):
+            raise XWNodeValueError(f"Invalid Datalog query: {query}")
+        return {"result": "Datalog query executed", "query": query}
+    
+    def validate_query(self, query: str) -> bool:
+        """Validate Datalog query syntax."""
+        if not query or not isinstance(query, str):
+            return False
+        return any(op in query for op in [":-", "?", "!", "assert", "retract"])
+    
+    def get_query_plan(self, query: str) -> Dict[str, Any]:
+        """Get Datalog query execution plan."""
+        return {
+            "query_type": "Datalog",
+            "complexity": "HIGH",
+            "estimated_cost": 200
+        }
+    
+    def select_query(self, table: str, columns: List[str], where_clause: str = None) -> Any:
+        """Execute SELECT query."""
+        return self.execute(f"?- {table}({', '.join(columns)})")
+    
+    def insert_query(self, table: str, data: Dict[str, Any]) -> Any:
+        """Execute INSERT query."""
+        return self.execute(f"assert({table}({', '.join(data.values())}))")
+    
+    def update_query(self, table: str, data: Dict[str, Any], where_clause: str = None) -> Any:
+        """Execute UPDATE query."""
+        return self.execute(f"retract({table}({where_clause})), assert({table}({', '.join(data.values())}))")
+    
+    def delete_query(self, table: str, where_clause: str = None) -> Any:
+        """Execute DELETE query."""
+        return self.execute(f"retract({table}({where_clause}))")
+    
+    def join_query(self, tables: List[str], join_conditions: List[str]) -> Any:
+        """Execute JOIN query."""
+        return self.execute(f"?- {tables[0]}(X), {tables[1]}(X)")
+    
+    def aggregate_query(self, table: str, functions: List[str], group_by: List[str] = None) -> Any:
+        """Execute aggregate query."""
+        return self.execute(f"?- {table}(X), aggregate({functions[0]}, X)")