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

exonware/xwnode/queries/strategies/jsoniq.py

@@ -1,248 +0,0 @@
-#!/usr/bin/env python3
-"""
-JSONiq Query Strategy
-
-This module implements the JSONiq query strategy for JSON 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 ADocumentQueryStrategy
-from ...errors import XWNodeTypeError, XWNodeValueError
-from ...contracts import QueryMode, QueryTrait
-
-
-class JSONiqStrategy(ADocumentQueryStrategy):
-    """
-    JSONiq query strategy for JSON data queries.
-    
-    Supports:
-    - JSONiq 1.0 and 1.1 features
-    - FLWOR expressions
-    - JSON navigation
-    - Type system
-    - Functions and modules
-    """
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.JSONIQ
-        self._traits = QueryTrait.DOCUMENT | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute JSONiq query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid JSONiq query: {query}")
-        
-        query_type = self._get_query_type(query)
-        
-        if query_type == "flwor":
-            return self._execute_flwor(query, **kwargs)
-        elif query_type == "path":
-            return self._execute_path(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 JSONiq query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        
-        # Basic JSONiq validation
-        query = query.strip()
-        
-        # Check for JSONiq keywords
-        jsoniq_keywords = ["for", "let", "where", "order by", "group by", "return", "collection", "json", "object", "array"]
-        
-        query_lower = query.lower()
-        for keyword in jsoniq_keywords:
-            if keyword in query_lower:
-                return True
-        
-        # Check for JSON path expressions
-        if "$" in query or ".." in query or "[]" in query:
-            return True
-        
-        return False
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get JSONiq 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."""
-        # JSONiq path queries
-        query = f"$${path}"
-        return self.execute(query)
-    
-    def filter_query(self, filter_expression: str) -> Any:
-        """Execute filter query."""
-        query = f"""
-        for $$item in collection()
-        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 collection()
-            return $$item.{fields[0]}
-            """
-        else:
-            field_list = ", ".join([f"$$item.{field}" for field in fields])
-            query = f"""
-            for $$item in collection()
-            return {{ {field_list} }}
-            """
-        
-        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 collection()
-            order by $$item.{sort_fields[0]} descending
-            return $$item
-            """
-        else:
-            query = f"""
-            for $$item in collection()
-            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 in collection()
-            where count($$item) > {offset}
-            return $$item
-            """
-            # Use subsequence for limit
-            return self._execute_function(f"subsequence(collection(), {offset + 1}, {limit})")
-        else:
-            query = f"""
-            for $$item in collection()
-            return $$item
-            """
-            return self._execute_function(f"subsequence(collection(), 1, {limit})")
-    
-    def _get_query_type(self, query: str) -> str:
-        """Extract query type from JSONiq query."""
-        query = query.strip()
-        
-        if "for" in query.lower() or "let" in query.lower():
-            return "flwor"
-        elif "$" in query or ".." in query:
-            return "path"
-        elif "(" in query and ")" in query:
-            return "function"
-        else:
-            return "unknown"
-    
-    def _execute_flwor(self, query: str, **kwargs) -> Any:
-        """Execute FLWOR expression."""
-        return {"result": "JSONiq FLWOR executed", "query": query}
-    
-    def _execute_path(self, query: str, **kwargs) -> Any:
-        """Execute path expression."""
-        return {"result": "JSONiq path executed", "query": query}
-    
-    def _execute_function(self, query: str, **kwargs) -> Any:
-        """Execute function call."""
-        return {"result": "JSONiq 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 120
-        elif complexity == "MEDIUM":
-            return 60
-        else:
-            return 30
-    
-    def _extract_expressions(self, query: str) -> List[str]:
-        """Extract JSONiq 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")
-        
-        # Path expressions
-        if "$" in query:
-            expressions.append("path")
-        if ".." in query:
-            expressions.append("descendant")
-        if "[]" in query:
-            expressions.append("array")
-        
-        # Function calls
-        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 "for" in query.lower() and "let" in query.lower():
-            hints.append("Consider using let for computed values")
-        
-        if ".." in query:
-            hints.append("Consider using specific paths instead of descendant navigation")
-        
-        if "[]" in query:
-            hints.append("Consider using array indexing for better performance")
-        
-        if "order by" in query.lower():
-            hints.append("Consider using indexes for ordered queries")
-        
-        return hints

exonware/xwnode/queries/strategies/kql.py

@@ -1,70 +0,0 @@
-#!/usr/bin/env python3
-"""
-KQL Query Strategy
-
-This module implements the KQL query strategy for Kusto Query Language 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 AStructuredQueryStrategy
-from ...errors import XWNodeValueError
-from ...contracts import QueryMode, QueryTrait
-
-
-class KQLStrategy(AStructuredQueryStrategy):
-    """KQL query strategy for Kusto Query Language operations."""
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.KQL
-        self._traits = QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL | QueryTrait.BATCH
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute KQL query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid KQL query: {query}")
-        return {"result": "KQL query executed", "query": query}
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate KQL query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        return any(op in query.upper() for op in ["TABLE", "WHERE", "PROJECT", "SUMMARIZE", "JOIN"])
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get KQL query execution plan."""
-        return {
-            "query_type": "KQL",
-            "complexity": "MEDIUM",
-            "estimated_cost": 90
-        }
-    
-    def select_query(self, table: str, columns: List[str], where_clause: str = None) -> Any:
-        """Execute SELECT query."""
-        return self.execute(f"{table} | project {', '.join(columns)}")
-    
-    def insert_query(self, table: str, data: Dict[str, Any]) -> Any:
-        """Execute INSERT query."""
-        return self.execute(f"INSERT INTO {table} VALUES {data}")
-    
-    def update_query(self, table: str, data: Dict[str, Any], where_clause: str = None) -> Any:
-        """Execute UPDATE query."""
-        return self.execute(f"UPDATE {table} SET {data}")
-    
-    def delete_query(self, table: str, where_clause: str = None) -> Any:
-        """Execute DELETE query."""
-        return self.execute(f"DELETE FROM {table}")
-    
-    def join_query(self, tables: List[str], join_conditions: List[str]) -> Any:
-        """Execute JOIN query."""
-        return self.execute(f"{tables[0]} | join {tables[1]}")
-    
-    def aggregate_query(self, table: str, functions: List[str], group_by: List[str] = None) -> Any:
-        """Execute aggregate query."""
-        return self.execute(f"{table} | summarize {', '.join(functions)}")

exonware/xwnode/queries/strategies/linq.py

@@ -1,238 +0,0 @@
-#!/usr/bin/env python3
-"""
-LINQ Query Strategy
-
-This module implements the LINQ query strategy for Language Integrated Query operations.
-
-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 ADocumentQueryStrategy
-from ...errors import XWNodeTypeError, XWNodeValueError
-from ...contracts import QueryMode, QueryTrait
-
-
-class LINQStrategy(ADocumentQueryStrategy):
-    """
-    LINQ query strategy for Language Integrated Query operations.
-    
-    Supports:
-    - Query syntax and method syntax
-    - LINQ to Objects, LINQ to XML, LINQ to SQL
-    - Lambda expressions
-    - Deferred execution
-    - Query composition
-    """
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.LINQ
-        self._traits = QueryTrait.DOCUMENT | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute LINQ query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid LINQ query: {query}")
-        
-        query_type = self._get_query_type(query)
-        
-        if query_type == "query_syntax":
-            return self._execute_query_syntax(query, **kwargs)
-        elif query_type == "method_syntax":
-            return self._execute_method_syntax(query, **kwargs)
-        else:
-            raise XWNodeValueError(f"Unsupported query type: {query_type}")
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate LINQ query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        
-        # Basic LINQ validation
-        query = query.strip()
-        
-        # Check for LINQ keywords
-        linq_keywords = ["from", "where", "select", "group", "orderby", "join", "let", "into"]
-        method_keywords = ["Where", "Select", "GroupBy", "OrderBy", "Join", "Take", "Skip", "First", "Last"]
-        
-        query_lower = query.lower()
-        for keyword in linq_keywords:
-            if keyword in query_lower:
-                return True
-        
-        for keyword in method_keywords:
-            if keyword in query:
-                return True
-        
-        return False
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get LINQ 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 path_query(self, path: str) -> Any:
-        """Execute path-based query."""
-        # LINQ path queries are typically for XML
-        query = f"""
-        from element in document.Descendants()
-        where element.Name == "{path}"
-        select element
-        """
-        return self.execute(query)
-    
-    def filter_query(self, filter_expression: str) -> Any:
-        """Execute filter query."""
-        query = f"""
-        from item in source
-        where {filter_expression}
-        select item
-        """
-        return self.execute(query)
-    
-    def projection_query(self, fields: List[str]) -> Any:
-        """Execute projection query."""
-        if len(fields) == 1:
-            query = f"""
-            from item in source
-            select item.{fields[0]}
-            """
-        else:
-            field_list = ", ".join([f"item.{field}" for field in fields])
-            query = f"""
-            from item in source
-            select new {{ {field_list} }}
-            """
-        
-        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"""
-            from item in source
-            orderby {sort_fields[0]} descending
-            select item
-            """
-        else:
-            query = f"""
-            from item in source
-            orderby {sort_fields[0]}
-            select item
-            """
-        
-        return self.execute(query)
-    
-    def limit_query(self, limit: int, offset: int = 0) -> Any:
-        """Execute limit query."""
-        if offset > 0:
-            query = f"""
-            from item in source
-            select item
-            """
-            # Use Skip and Take methods
-            return self._execute_method_syntax(f"source.Skip({offset}).Take({limit})")
-        else:
-            query = f"""
-            from item in source
-            select item
-            """
-            return self._execute_method_syntax(f"source.Take({limit})")
-    
-    def _get_query_type(self, query: str) -> str:
-        """Extract query type from LINQ query."""
-        query = query.strip()
-        
-        if query.startswith("from ") or " from " in query:
-            return "query_syntax"
-        elif any(method in query for method in ["Where", "Select", "GroupBy", "OrderBy", "Join"]):
-            return "method_syntax"
-        else:
-            return "unknown"
-    
-    def _execute_query_syntax(self, query: str, **kwargs) -> Any:
-        """Execute LINQ query syntax."""
-        return {"result": "LINQ query syntax executed", "query": query}
-    
-    def _execute_method_syntax(self, query: str, **kwargs) -> Any:
-        """Execute LINQ method syntax."""
-        return {"result": "LINQ method syntax 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 100
-        elif complexity == "MEDIUM":
-            return 50
-        else:
-            return 25
-    
-    def _extract_operations(self, query: str) -> List[str]:
-        """Extract LINQ operations from query."""
-        operations = []
-        
-        # Query syntax operations
-        if "from" in query.lower():
-            operations.append("from")
-        if "where" in query.lower():
-            operations.append("where")
-        if "select" in query.lower():
-            operations.append("select")
-        if "group" in query.lower():
-            operations.append("group")
-        if "orderby" in query.lower():
-            operations.append("orderby")
-        if "join" in query.lower():
-            operations.append("join")
-        
-        # Method syntax operations
-        method_operations = ["Where", "Select", "GroupBy", "OrderBy", "Join", "Take", "Skip", "First", "Last", "Count", "Sum", "Average", "Min", "Max"]
-        for operation in method_operations:
-            if operation in query:
-                operations.append(operation)
-        
-        return operations
-    
-    def _get_optimization_hints(self, query: str) -> List[str]:
-        """Get query optimization hints."""
-        hints = []
-        
-        if "Count()" in query:
-            hints.append("Consider using Count() with predicate for better performance")
-        
-        if "First()" in query:
-            hints.append("Consider using FirstOrDefault() to avoid exceptions")
-        
-        if "ToList()" in query:
-            hints.append("Consider using deferred execution when possible")
-        
-        if "Select" in query and "Where" in query:
-            hints.append("Consider combining Select and Where operations")
-        
-        return hints

exonware/xwnode/queries/strategies/logql.py

@@ -1,70 +0,0 @@
-#!/usr/bin/env python3
-"""
-LogQL Query Strategy
-
-This module implements the LogQL query strategy for Grafana Loki Log Query Language 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 AStructuredQueryStrategy
-from ...errors import XWNodeValueError
-from ...contracts import QueryMode, QueryTrait
-
-
-class LogQLStrategy(AStructuredQueryStrategy):
-    """LogQL query strategy for Grafana Loki Log Query Language operations."""
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.LOGQL
-        self._traits = QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL | QueryTrait.TEMPORAL | QueryTrait.STREAMING
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute LogQL query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid LogQL query: {query}")
-        return {"result": "LogQL query executed", "query": query}
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate LogQL query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        return any(op in query for op in ["{", "}", "|", "rate", "sum", "count", "avg", "max", "min"])
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get LogQL query execution plan."""
-        return {
-            "query_type": "LogQL",
-            "complexity": "MEDIUM",
-            "estimated_cost": 90
-        }
-    
-    def select_query(self, table: str, columns: List[str], where_clause: str = None) -> Any:
-        """Execute SELECT query."""
-        return self.execute(f"{{job=\"{table}\"}}")
-    
-    def insert_query(self, table: str, data: Dict[str, Any]) -> Any:
-        """Execute INSERT query."""
-        return self.execute(f"INSERT INTO {table} VALUES {data}")
-    
-    def update_query(self, table: str, data: Dict[str, Any], where_clause: str = None) -> Any:
-        """Execute UPDATE query."""
-        return self.execute(f"UPDATE {table} SET {data}")
-    
-    def delete_query(self, table: str, where_clause: str = None) -> Any:
-        """Execute DELETE query."""
-        return self.execute(f"DELETE FROM {table}")
-    
-    def join_query(self, tables: List[str], join_conditions: List[str]) -> Any:
-        """Execute JOIN query."""
-        return self.execute(f"{{job=\"{tables[0]}\"}} | join {{job=\"{tables[1]}\"}}")
-    
-    def aggregate_query(self, table: str, functions: List[str], group_by: List[str] = None) -> Any:
-        """Execute aggregate query."""
-        return self.execute(f"{{job=\"{table}\"}} | {functions[0]}()")

exonware/xwnode/queries/strategies/mql.py

@@ -1,68 +0,0 @@
-#!/usr/bin/env python3
-"""
-MQL Query Strategy
-
-This module implements the MQL query strategy for MongoDB Query Language 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 MQLStrategy(ADocumentQueryStrategy):
-    """MQL query strategy for MongoDB Query Language operations."""
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.MQL
-        self._traits = QueryTrait.DOCUMENT | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute MQL query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid MQL query: {query}")
-        return {"result": "MQL query executed", "query": query}
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate MQL query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        return any(op in query for op in ["find", "aggregate", "insert", "update", "delete", "createIndex"])
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get MQL query execution plan."""
-        return {
-            "query_type": "MQL",
-            "complexity": "MEDIUM",
-            "estimated_cost": 80
-        }
-    
-    def path_query(self, path: str) -> Any:
-        """Execute path-based query."""
-        return self.execute(f"db.collection.find({{{path}: {{$exists: true}}}})")
-    
-    def filter_query(self, filter_expression: str) -> Any:
-        """Execute filter query."""
-        return self.execute(f"db.collection.find({filter_expression})")
-    
-    def projection_query(self, fields: List[str]) -> Any:
-        """Execute projection query."""
-        projection = {field: 1 for field in fields}
-        return self.execute(f"db.collection.find({{}}, {projection})")
-    
-    def sort_query(self, sort_fields: List[str], order: str = "asc") -> Any:
-        """Execute sort query."""
-        sort_order = 1 if order == "asc" else -1
-        return self.execute(f"db.collection.find().sort({{{sort_fields[0]}: {sort_order}}})")
-    
-    def limit_query(self, limit: int, offset: int = 0) -> Any:
-        """Execute limit query."""
-        return self.execute(f"db.collection.find().skip({offset}).limit({limit})")