exonware-xwnode 0.0.1.22__py3-none-any.whl → 0.0.1.23__py3-none-any.whl

exonware/xwnode/queries/strategies/sparql.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python3
-"""
-SPARQL Query Strategy
-
-This module implements the SPARQL query strategy for RDF data queries.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-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 SPARQLStrategy(AGraphQueryStrategy):
-    """
-    SPARQL query strategy for RDF data queries.
-    
-    Supports:
-    - SELECT, CONSTRUCT, ASK, DESCRIBE queries
-    - SPARQL 1.1 features
-    - Property paths
-    - Federated queries
-    - Update operations
-    """
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.SPARQL
-        self._traits = QueryTrait.GRAPH | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute SPARQL query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid SPARQL query: {query}")
-        
-        query_type = self._get_query_type(query)
-        
-        if query_type == "SELECT":
-            return self._execute_select(query, **kwargs)
-        elif query_type == "CONSTRUCT":
-            return self._execute_construct(query, **kwargs)
-        elif query_type == "ASK":
-            return self._execute_ask(query, **kwargs)
-        elif query_type == "DESCRIBE":
-            return self._execute_describe(query, **kwargs)
-        else:
-            raise XWNodeValueError(f"Unsupported query type: {query_type}")
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate SPARQL query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        
-        # Basic SPARQL validation
-        query = query.strip().upper()
-        valid_operations = ["SELECT", "CONSTRUCT", "ASK", "DESCRIBE", "INSERT", "DELETE", "LOAD", "CLEAR"]
-        
-        for operation in valid_operations:
-            if query.startswith(operation):
-                return True
-        
-        return False
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get SPARQL 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),
-            "triple_patterns": self._count_triple_patterns(query),
-            "optimization_hints": self._get_optimization_hints(query)
-        }
-    
-    def path_query(self, start: Any, end: Any) -> List[Any]:
-        """Execute path query using SPARQL property paths."""
-        query = f"""
-        SELECT ?path ?length
-        WHERE {{
-            <{start}> (<>|!<>)* ?path .
-            ?path (<>|!<>)* <{end}> .
-            BIND(LENGTH(?path) AS ?length)
-        }}
-        """
-        return self.execute(query)
-    
-    def neighbor_query(self, node: Any) -> List[Any]:
-        """Execute neighbor query."""
-        query = f"""
-        SELECT ?neighbor ?predicate
-        WHERE {{
-            <{node}> ?predicate ?neighbor .
-        }}
-        """
-        return self.execute(query)
-    
-    def shortest_path_query(self, start: Any, end: Any) -> List[Any]:
-        """Execute shortest path query."""
-        query = f"""
-        SELECT ?path (COUNT(?step) AS ?length)
-        WHERE {{
-            <{start}> (<>|!<>)* ?path .
-            ?path (<>|!<>)* <{end}> .
-        }}
-        GROUP BY ?path
-        ORDER BY ?length
-        LIMIT 1
-        """
-        return self.execute(query)
-    
-    def connected_components_query(self) -> List[List[Any]]:
-        """Execute connected components query."""
-        query = """
-        SELECT ?component (COUNT(?node) AS ?size)
-        WHERE {
-            ?node ?p ?o .
-            ?o ?p2 ?node .
-        }
-        GROUP BY ?component
-        """
-        return self.execute(query)
-    
-    def cycle_detection_query(self) -> List[List[Any]]:
-        """Execute cycle detection query."""
-        query = """
-        SELECT ?cycle
-        WHERE {
-            ?node ?p ?node .
-            BIND(?node AS ?cycle)
-        }
-        """
-        return self.execute(query)
-    
-    def _get_query_type(self, query: str) -> str:
-        """Extract query type from SPARQL query."""
-        query = query.strip().upper()
-        for operation in ["SELECT", "CONSTRUCT", "ASK", "DESCRIBE", "INSERT", "DELETE", "LOAD", "CLEAR"]:
-            if query.startswith(operation):
-                return operation
-        return "UNKNOWN"
-    
-    def _execute_select(self, query: str, **kwargs) -> Any:
-        """Execute SELECT query."""
-        return {"result": "SPARQL SELECT executed", "query": query}
-    
-    def _execute_construct(self, query: str, **kwargs) -> Any:
-        """Execute CONSTRUCT query."""
-        return {"result": "SPARQL CONSTRUCT executed", "query": query}
-    
-    def _execute_ask(self, query: str, **kwargs) -> Any:
-        """Execute ASK query."""
-        return {"result": "SPARQL ASK executed", "query": query}
-    
-    def _execute_describe(self, query: str, **kwargs) -> Any:
-        """Execute DESCRIBE query."""
-        return {"result": "SPARQL DESCRIBE executed", "query": query}
-    
-    def _estimate_complexity(self, query: str) -> str:
-        """Estimate query complexity."""
-        triple_count = self._count_triple_patterns(query)
-        
-        if triple_count > 10:
-            return "HIGH"
-        elif triple_count > 5:
-            return "MEDIUM"
-        else:
-            return "LOW"
-    
-    def _estimate_cost(self, query: str) -> int:
-        """Estimate query cost."""
-        complexity = self._estimate_complexity(query)
-        if complexity == "HIGH":
-            return 200
-        elif complexity == "MEDIUM":
-            return 100
-        else:
-            return 50
-    
-    def _count_triple_patterns(self, query: str) -> int:
-        """Count triple patterns in SPARQL query."""
-        # Count occurrences of triple patterns
-        pattern_count = 0
-        
-        # Look for triple patterns in WHERE clause
-        where_match = re.search(r'WHERE\s*\{([^}]+)\}', query, re.IGNORECASE | re.DOTALL)
-        if where_match:
-            where_clause = where_match.group(1)
-            # Count lines that look like triple patterns
-            lines = where_clause.split('\n')
-            for line in lines:
-                line = line.strip()
-                if line and not line.startswith('#') and not line.startswith('FILTER'):
-                    if '?' in line or '<' in line or '"' in line:
-                        pattern_count += 1
-        
-        return pattern_count
-    
-    def _get_optimization_hints(self, query: str) -> List[str]:
-        """Get query optimization hints."""
-        hints = []
-        
-        if self._count_triple_patterns(query) > 8:
-            hints.append("Consider breaking down complex queries into smaller ones")
-        
-        if "OPTIONAL" in query.upper():
-            hints.append("Consider using FILTER instead of OPTIONAL for better performance")
-        
-        if "UNION" in query.upper():
-            hints.append("Consider using property paths instead of UNION when possible")
-        
-        return hints

exonware/xwnode/queries/strategies/sql.py

@@ -1,275 +0,0 @@
-#!/usr/bin/env python3
-"""
-SQL Query Strategy
-
-This module implements the SQL query strategy for structured data queries.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-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
-from ...base import XWNodeBase
-
-
-class SQLStrategy(AStructuredQueryStrategy):
-    """
-    SQL query strategy for standard SQL operations.
-    
-    Supports:
-    - SELECT, INSERT, UPDATE, DELETE operations
-    - JOIN operations
-    - Aggregate functions
-    - WHERE clauses
-    - ORDER BY, GROUP BY, HAVING
-    """
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.SQL
-        self._traits = QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL | QueryTrait.BATCH
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute SQL query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid SQL 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 SQL query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        
-        # Basic SQL validation
-        query = query.strip().upper()
-        valid_operations = ["SELECT", "INSERT", "UPDATE", "DELETE", "CREATE", "DROP", "ALTER"]
-        
-        for operation in valid_operations:
-            if query.startswith(operation):
-                return True
-        
-        return False
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get SQL 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),
-            "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."""
-        if len(tables) < 2:
-            raise XWNodeValueError("JOIN requires at least 2 tables")
-        
-        query = f"SELECT * FROM {tables[0]}"
-        for i, table in enumerate(tables[1:], 1):
-            if i <= len(join_conditions):
-                query += f" JOIN {table} ON {join_conditions[i-1]}"
-            else:
-                query += f" CROSS JOIN {table}"
-        
-        return self.execute(query)
-    
-    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 SQL query."""
-        query = query.strip().upper()
-        for operation in ["SELECT", "INSERT", "UPDATE", "DELETE", "CREATE", "DROP", "ALTER"]:
-            if query.startswith(operation):
-                return operation
-        return "UNKNOWN"
-    
-    def _execute_select(self, query: str, **kwargs) -> Any:
-        """Execute SELECT query."""
-        # Placeholder implementation
-        return {"result": "SELECT executed", "query": query}
-    
-    def _execute_insert(self, query: str, **kwargs) -> Any:
-        """Execute INSERT query."""
-        # Placeholder implementation
-        return {"result": "INSERT executed", "query": query}
-    
-    def _execute_update(self, query: str, **kwargs) -> Any:
-        """Execute UPDATE query."""
-        # Placeholder implementation
-        return {"result": "UPDATE executed", "query": query}
-    
-    def _execute_delete(self, query: str, **kwargs) -> Any:
-        """Execute DELETE query."""
-        # Placeholder implementation
-        return {"result": "DELETE executed", "query": query}
-    
-    def _estimate_complexity(self, query: str) -> str:
-        """Estimate query complexity."""
-        query = query.upper()
-        if "JOIN" in query:
-            return "HIGH"
-        elif "GROUP BY" in query or "ORDER BY" in query:
-            return "MEDIUM"
-        else:
-            return "LOW"
-    
-    def _estimate_cost(self, query: str) -> int:
-        """Estimate query cost."""
-        complexity = self._estimate_complexity(query)
-        if complexity == "HIGH":
-            return 100
-        elif complexity == "MEDIUM":
-            return 50
-        else:
-            return 10
-    
-    def _get_optimization_hints(self, query: str) -> List[str]:
-        """Get query optimization hints."""
-        hints = []
-        query = query.upper()
-        
-        if "SELECT *" in query:
-            hints.append("Consider specifying columns instead of using *")
-        if "WHERE" not in query and "SELECT" in query:
-            hints.append("Consider adding WHERE clause to limit results")
-        if "ORDER BY" in query:
-            hints.append("Consider adding index on ORDER BY columns")
-        
-        return hints
-    
-    def to_actions_tree(self, sql_query: str) -> XWNodeBase:
-        """Convert SQL query to XWQuery Script actions tree."""
-        from .xwquery_strategy import XWQueryScriptStrategy
-        
-        # Parse SQL into XWQuery Script actions
-        script_strategy = XWQueryScriptStrategy()
-        
-        # Map SQL constructs to XWQuery actions:
-        # SELECT -> SELECT action
-        # FROM -> FROM action  
-        # WHERE -> WHERE action
-        # JOIN -> JOIN action (with nested conditions)
-        # Subqueries -> nested SELECT actions
-        # etc.
-        
-        # For now, create a basic actions tree
-        actions = {
-            "root": {
-                "type": "PROGRAM",
-                "statements": [
-                    {
-                        "type": "SELECT",
-                        "id": "sql_action_1",
-                        "content": sql_query,
-                        "line_number": 1,
-                        "timestamp": "2025-01-02T00:00:00",
-                        "children": []
-                    }
-                ],
-                "comments": [],
-                "metadata": {
-                    "version": "1.0",
-                    "created": "2025-01-02T00:00:00",
-                    "source_format": "SQL"
-                }
-            }
-        }
-        
-        return XWNodeBase.from_native(actions)
-    
-    def from_actions_tree(self, actions_tree: XWNodeBase) -> str:
-        """Convert XWQuery Script actions tree to SQL query."""
-        from .xwquery_strategy import XWQueryScriptStrategy
-        
-        script_strategy = XWQueryScriptStrategy(actions_tree)
-        return script_strategy.to_format("SQL")
-    
-    def can_handle(self, query_string: str) -> bool:
-        """Check if this strategy can handle the given query string."""
-        return self.validate_query(query_string)
-    
-    def get_supported_operations(self) -> List[str]:
-        """Get list of supported query operations."""
-        return [
-            "SELECT", "INSERT", "UPDATE", "DELETE", "CREATE", "DROP", "ALTER",
-            "JOIN", "UNION", "GROUP BY", "ORDER BY", "HAVING", "WHERE",
-            "WITH", "CASE", "WINDOW", "PARTITION BY", "OVER"
-        ]
-    
-    def estimate_complexity(self, query_string: str) -> Dict[str, Any]:
-        """Estimate query complexity and resource requirements."""
-        complexity = self._estimate_complexity(query_string)
-        cost = self._estimate_cost(query_string)
-        
-        return {
-            "complexity_level": complexity,
-            "estimated_cost": cost,
-            "has_joins": "JOIN" in query_string.upper(),
-            "has_subqueries": "SELECT" in query_string.upper().replace("SELECT", "", 1),
-            "has_aggregates": any(func in query_string.upper() for func in ["SUM", "COUNT", "AVG", "MIN", "MAX"]),
-            "has_window_functions": "OVER" in query_string.upper(),
-            "query_length": len(query_string),
-            "estimated_memory": "high" if complexity == "HIGH" else "medium" if complexity == "MEDIUM" else "low"
-        }

exonware/xwnode/queries/strategies/xml_query.py

@@ -1,66 +0,0 @@
-#!/usr/bin/env python3
-"""
-XML Query Strategy
-
-This module implements the XML Query strategy for generic XML operations.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-Generation Date: January 2, 2025
-"""
-
-from typing import Any, Dict, List, Optional
-from .base import ADocumentQueryStrategy
-from ...errors import XWNodeValueError
-from ...contracts import QueryMode, QueryTrait
-
-
-class XMLQueryStrategy(ADocumentQueryStrategy):
-    """XML Query strategy for generic XML operations."""
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.XML_QUERY
-        self._traits = QueryTrait.DOCUMENT | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute XML query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid XML query: {query}")
-        return {"result": "XML query executed", "query": query}
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate XML query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        return any(op in query for op in ["<", ">", "/", "//", "@", "[", "]"])
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get XML query execution plan."""
-        return {
-            "query_type": "XML_QUERY",
-            "complexity": "MEDIUM",
-            "estimated_cost": 60
-        }
-    
-    def path_query(self, path: str) -> Any:
-        """Execute path-based query."""
-        return self.execute(f"//{path}")
-    
-    def filter_query(self, filter_expression: str) -> Any:
-        """Execute filter query."""
-        return self.execute(f"//*[{filter_expression}]")
-    
-    def projection_query(self, fields: List[str]) -> Any:
-        """Execute projection query."""
-        return self.execute(f"//*[{' or '.join(fields)}]")
-    
-    def sort_query(self, sort_fields: List[str], order: str = "asc") -> Any:
-        """Execute sort query."""
-        return self.execute(f"//*[sort by {sort_fields[0]}]")
-    
-    def limit_query(self, limit: int, offset: int = 0) -> Any:
-        """Execute limit query."""
-        return self.execute(f"//*[position() > {offset} and position() <= {offset + limit}]")