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

exonware/xwnode/queries/strategies/xpath.py

@@ -1,223 +0,0 @@
-#!/usr/bin/env python3
-"""
-XPath Query Strategy
-
-This module implements the XPath query strategy for XML data queries.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: January 2, 2025
-"""
-
-import re
-from typing import Any, Dict, List, Optional, Union
-from .base import ADocumentQueryStrategy
-from ...errors import XWNodeTypeError, XWNodeValueError
-from ...contracts import QueryMode, QueryTrait
-
-
-class XPathStrategy(ADocumentQueryStrategy):
-    """
-    XPath query strategy for XML data queries.
-    
-    Supports:
-    - XPath 1.0 and 2.0 features
-    - Location paths and expressions
-    - Predicates and functions
-    - Axes and node tests
-    - Namespace support
-    """
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.XPATH
-        self._traits = QueryTrait.DOCUMENT | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute XPath query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid XPath query: {query}")
-        
-        query_type = self._get_query_type(query)
-        
-        if query_type == "location_path":
-            return self._execute_location_path(query, **kwargs)
-        elif query_type == "expression":
-            return self._execute_expression(query, **kwargs)
-        elif query_type == "function":
-            return self._execute_function(query, **kwargs)
-        else:
-            raise XWNodeValueError(f"Unsupported query type: {query_type}")
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate XPath query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        
-        # Basic XPath validation
-        query = query.strip()
-        
-        # Check for XPath syntax
-        if query.startswith("/") or query.startswith("//") or query.startswith("@") or query.startswith("."):
-            return True
-        
-        # Check for XPath functions
-        xpath_functions = ["text", "name", "local-name", "namespace-uri", "count", "position", "last", "string", "number", "boolean", "not", "true", "false", "contains", "starts-with", "ends-with", "substring", "substring-before", "substring-after", "normalize-space", "translate", "concat", "string-length", "sum", "floor", "ceiling", "round", "id", "key", "document", "format-number", "unparsed-entity-uri", "unparsed-entity-public-id", "generate-id", "system-property", "element-available", "function-available", "current", "lang", "local-name", "namespace-uri", "name", "string", "number", "boolean", "not", "true", "false", "contains", "starts-with", "ends-with", "substring", "substring-before", "substring-after", "normalize-space", "translate", "concat", "string-length", "sum", "floor", "ceiling", "round", "id", "key", "document", "format-number", "unparsed-entity-uri", "unparsed-entity-public-id", "generate-id", "system-property", "element-available", "function-available", "current", "lang"]
-        
-        for func in xpath_functions:
-            if func in query:
-                return True
-        
-        # Check for axes
-        axes = ["ancestor", "ancestor-or-self", "attribute", "child", "descendant", "descendant-or-self", "following", "following-sibling", "namespace", "parent", "preceding", "preceding-sibling", "self"]
-        
-        for axis in axes:
-            if f"{axis}::" in query:
-                return True
-        
-        return False
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get XPath 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),
-            "expressions": self._extract_expressions(query),
-            "optimization_hints": self._get_optimization_hints(query)
-        }
-    
-    def path_query(self, path: str) -> Any:
-        """Execute path-based query."""
-        # XPath path queries
-        query = f"/{path}"
-        return self.execute(query)
-    
-    def filter_query(self, filter_expression: str) -> Any:
-        """Execute filter query."""
-        query = f"//*[{filter_expression}]"
-        return self.execute(query)
-    
-    def projection_query(self, fields: List[str]) -> Any:
-        """Execute projection query."""
-        if len(fields) == 1:
-            query = f"//{fields[0]}"
-        else:
-            field_list = " | ".join([f"//{field}" for field in fields])
-            query = f"({field_list})"
-        
-        return self.execute(query)
-    
-    def sort_query(self, sort_fields: List[str], order: str = "asc") -> Any:
-        """Execute sort query."""
-        # XPath doesn't have built-in sorting, use position
-        if order.lower() == "desc":
-            query = f"//*[position() = last() - position() + 1]"
-        else:
-            query = f"//*[position()]"
-        
-        return self.execute(query)
-    
-    def limit_query(self, limit: int, offset: int = 0) -> Any:
-        """Execute limit query."""
-        if offset > 0:
-            query = f"//*[position() > {offset} and position() <= {offset + limit}]"
-        else:
-            query = f"//*[position() <= {limit}]"
-        
-        return self.execute(query)
-    
-    def _get_query_type(self, query: str) -> str:
-        """Extract query type from XPath query."""
-        query = query.strip()
-        
-        if "/" in query or "//" in query:
-            return "location_path"
-        elif "(" in query and ")" in query:
-            return "function"
-        else:
-            return "expression"
-    
-    def _execute_location_path(self, query: str, **kwargs) -> Any:
-        """Execute location path."""
-        return {"result": "XPath location path executed", "query": query}
-    
-    def _execute_expression(self, query: str, **kwargs) -> Any:
-        """Execute expression."""
-        return {"result": "XPath expression executed", "query": query}
-    
-    def _execute_function(self, query: str, **kwargs) -> Any:
-        """Execute function call."""
-        return {"result": "XPath function executed", "query": query}
-    
-    def _estimate_complexity(self, query: str) -> str:
-        """Estimate query complexity."""
-        expressions = self._extract_expressions(query)
-        
-        if len(expressions) > 5:
-            return "HIGH"
-        elif len(expressions) > 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 100
-        elif complexity == "MEDIUM":
-            return 50
-        else:
-            return 25
-    
-    def _extract_expressions(self, query: str) -> List[str]:
-        """Extract XPath expressions from query."""
-        expressions = []
-        
-        # Location paths
-        if "/" in query:
-            expressions.append("path")
-        if "//" in query:
-            expressions.append("descendant")
-        if "@" in query:
-            expressions.append("attribute")
-        if "[" in query and "]" in query:
-            expressions.append("predicate")
-        
-        # Axes
-        axes = ["ancestor", "ancestor-or-self", "attribute", "child", "descendant", "descendant-or-self", "following", "following-sibling", "namespace", "parent", "preceding", "preceding-sibling", "self"]
-        for axis in axes:
-            if f"{axis}::" in query:
-                expressions.append(axis)
-        
-        # Functions
-        xpath_functions = ["text", "name", "local-name", "namespace-uri", "count", "position", "last", "string", "number", "boolean", "not", "true", "false", "contains", "starts-with", "ends-with", "substring", "substring-before", "substring-after", "normalize-space", "translate", "concat", "string-length", "sum", "floor", "ceiling", "round", "id", "key", "document", "format-number", "unparsed-entity-uri", "unparsed-entity-public-id", "generate-id", "system-property", "element-available", "function-available", "current", "lang"]
-        for func in xpath_functions:
-            if func in query:
-                expressions.append(func)
-        
-        return expressions
-    
-    def _get_optimization_hints(self, query: str) -> List[str]:
-        """Get query optimization hints."""
-        hints = []
-        
-        if "//" in query:
-            hints.append("Consider using specific paths instead of descendant navigation")
-        
-        if "[" in query and "]" in query:
-            hints.append("Consider using indexes for predicate operations")
-        
-        if "position()" in query:
-            hints.append("Consider using last() for better performance")
-        
-        if "text()" in query:
-            hints.append("Consider using normalize-space() for text processing")
-        
-        return hints

exonware/xwnode/queries/strategies/xquery.py

@@ -1,258 +0,0 @@
-#!/usr/bin/env python3
-"""
-XQuery Query Strategy
-
-This module implements the XQuery query strategy for XML data queries.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: January 2, 2025
-"""
-
-import re
-from typing import Any, Dict, List, Optional, Union
-from .base import ADocumentQueryStrategy
-from ...errors import XWNodeTypeError, XWNodeValueError
-from ...contracts import QueryMode, QueryTrait
-
-
-class XQueryStrategy(ADocumentQueryStrategy):
-    """
-    XQuery query strategy for XML data queries.
-    
-    Supports:
-    - XQuery 1.0 and 3.0 features
-    - FLWOR expressions
-    - XPath expressions
-    - XML construction
-    - Functions and modules
-    """
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.XQUERY
-        self._traits = QueryTrait.DOCUMENT | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute XQuery query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid XQuery query: {query}")
-        
-        query_type = self._get_query_type(query)
-        
-        if query_type == "flwor":
-            return self._execute_flwor(query, **kwargs)
-        elif query_type == "xpath":
-            return self._execute_xpath(query, **kwargs)
-        elif query_type == "construction":
-            return self._execute_construction(query, **kwargs)
-        else:
-            raise XWNodeValueError(f"Unsupported query type: {query_type}")
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate XQuery query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        
-        # Basic XQuery validation
-        query = query.strip()
-        
-        # Check for XQuery keywords
-        xquery_keywords = ["for", "let", "where", "order by", "group by", "return", "declare", "namespace", "import", "module", "function", "variable", "element", "attribute", "text", "comment", "processing-instruction", "document", "collection"]
-        
-        query_lower = query.lower()
-        for keyword in xquery_keywords:
-            if keyword in query_lower:
-                return True
-        
-        # Check for XPath expressions
-        if "/" in query or "//" in query or "@" in query or "[" in query:
-            return True
-        
-        return False
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get XQuery 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),
-            "expressions": self._extract_expressions(query),
-            "optimization_hints": self._get_optimization_hints(query)
-        }
-    
-    def path_query(self, path: str) -> Any:
-        """Execute path-based query."""
-        # XQuery path queries
-        query = f"doc()/{path}"
-        return self.execute(query)
-    
-    def filter_query(self, filter_expression: str) -> Any:
-        """Execute filter query."""
-        query = f"""
-        for $item in doc()//*
-        where {filter_expression}
-        return $item
-        """
-        return self.execute(query)
-    
-    def projection_query(self, fields: List[str]) -> Any:
-        """Execute projection query."""
-        if len(fields) == 1:
-            query = f"""
-            for $item in doc()//*
-            return $item/{fields[0]}
-            """
-        else:
-            field_list = ", ".join([f"$item/{field}" for field in fields])
-            query = f"""
-            for $item in doc()//*
-            return <result>{{ {field_list} }}</result>
-            """
-        
-        return self.execute(query)
-    
-    def sort_query(self, sort_fields: List[str], order: str = "asc") -> Any:
-        """Execute sort query."""
-        if order.lower() == "desc":
-            query = f"""
-            for $item in doc()//*
-            order by $item/{sort_fields[0]} descending
-            return $item
-            """
-        else:
-            query = f"""
-            for $item in doc()//*
-            order by $item/{sort_fields[0]}
-            return $item
-            """
-        
-        return self.execute(query)
-    
-    def limit_query(self, limit: int, offset: int = 0) -> Any:
-        """Execute limit query."""
-        if offset > 0:
-            query = f"""
-            for $item at $pos in doc()//*
-            where $pos > {offset}
-            return $item
-            """
-            # Use subsequence for limit
-            return self._execute_function(f"subsequence(doc()//*, {offset + 1}, {limit})")
-        else:
-            query = f"""
-            for $item in doc()//*
-            return $item
-            """
-            return self._execute_function(f"subsequence(doc()//*, 1, {limit})")
-    
-    def _get_query_type(self, query: str) -> str:
-        """Extract query type from XQuery query."""
-        query = query.strip()
-        
-        if "for" in query.lower() or "let" in query.lower():
-            return "flwor"
-        elif "<" in query and ">" in query:
-            return "construction"
-        elif "/" in query or "//" in query:
-            return "xpath"
-        else:
-            return "unknown"
-    
-    def _execute_flwor(self, query: str, **kwargs) -> Any:
-        """Execute FLWOR expression."""
-        return {"result": "XQuery FLWOR executed", "query": query}
-    
-    def _execute_xpath(self, query: str, **kwargs) -> Any:
-        """Execute XPath expression."""
-        return {"result": "XQuery XPath executed", "query": query}
-    
-    def _execute_construction(self, query: str, **kwargs) -> Any:
-        """Execute XML construction."""
-        return {"result": "XQuery construction executed", "query": query}
-    
-    def _execute_function(self, query: str, **kwargs) -> Any:
-        """Execute function call."""
-        return {"result": "XQuery function executed", "query": query}
-    
-    def _estimate_complexity(self, query: str) -> str:
-        """Estimate query complexity."""
-        expressions = self._extract_expressions(query)
-        
-        if len(expressions) > 5:
-            return "HIGH"
-        elif len(expressions) > 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 150
-        elif complexity == "MEDIUM":
-            return 75
-        else:
-            return 35
-    
-    def _extract_expressions(self, query: str) -> List[str]:
-        """Extract XQuery expressions from query."""
-        expressions = []
-        
-        # FLWOR expressions
-        if "for" in query.lower():
-            expressions.append("for")
-        if "let" in query.lower():
-            expressions.append("let")
-        if "where" in query.lower():
-            expressions.append("where")
-        if "order by" in query.lower():
-            expressions.append("order by")
-        if "group by" in query.lower():
-            expressions.append("group by")
-        if "return" in query.lower():
-            expressions.append("return")
-        
-        # XPath expressions
-        if "/" in query:
-            expressions.append("path")
-        if "//" in query:
-            expressions.append("descendant")
-        if "@" in query:
-            expressions.append("attribute")
-        if "[" in query and "]" in query:
-            expressions.append("predicate")
-        
-        # XML construction
-        if "<" in query and ">" in query:
-            expressions.append("construction")
-        
-        # Functions
-        if "(" in query and ")" in query:
-            expressions.append("function")
-        
-        return expressions
-    
-    def _get_optimization_hints(self, query: str) -> List[str]:
-        """Get query optimization hints."""
-        hints = []
-        
-        if "//" in query:
-            hints.append("Consider using specific paths instead of descendant navigation")
-        
-        if "for" in query.lower() and "let" in query.lower():
-            hints.append("Consider using let for computed values")
-        
-        if "[" in query and "]" in query:
-            hints.append("Consider using indexes for predicate operations")
-        
-        if "order by" in query.lower():
-            hints.append("Consider using indexes for ordered queries")
-        
-        return hints