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

exonware/xwnode/queries/strategies/hiveql.py

@@ -1,214 +0,0 @@
-#!/usr/bin/env python3
-"""
-HiveQL Query Strategy
-
-This module implements the HiveQL query strategy for Apache Hive SQL operations.
-
-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 AStructuredQueryStrategy
-from ...errors import XWNodeTypeError, XWNodeValueError
-from ...contracts import QueryMode, QueryTrait
-
-
-class HiveQLStrategy(AStructuredQueryStrategy):
-    """
-    HiveQL query strategy for Apache Hive SQL operations.
-    
-    Supports:
-    - Hive-specific SQL extensions
-    - Partitioned tables
-    - Bucketed tables
-    - UDFs and UDAFs
-    - MapReduce operations
-    """
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.HIVEQL
-        self._traits = QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL | QueryTrait.BATCH
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute HiveQL query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid HiveQL 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 == "CREATE":
-            return self._execute_create(query, **kwargs)
-        elif query_type == "LOAD":
-            return self._execute_load(query, **kwargs)
-        else:
-            raise XWNodeValueError(f"Unsupported query type: {query_type}")
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate HiveQL query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        
-        # HiveQL validation
-        query = query.strip().upper()
-        valid_operations = ["SELECT", "INSERT", "CREATE", "DROP", "ALTER", "LOAD", "EXPORT", "IMPORT"]
-        
-        for operation in valid_operations:
-            if query.startswith(operation):
-                return True
-        
-        return False
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get HiveQL 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),
-            "mapreduce_jobs": self._estimate_mapreduce_jobs(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."""
-        # HiveQL doesn't support UPDATE, use INSERT OVERWRITE instead
-        set_clause = ', '.join([f"{k} = ?" for k in data.keys()])
-        query = f"INSERT OVERWRITE TABLE {table} SELECT {set_clause} FROM {table}"
-        
-        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."""
-        # HiveQL doesn't support DELETE, use INSERT OVERWRITE instead
-        query = f"INSERT OVERWRITE TABLE {table} SELECT * FROM {table}"
-        if where_clause:
-            query += f" WHERE NOT ({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 HiveQL query."""
-        query = query.strip().upper()
-        for operation in ["SELECT", "INSERT", "CREATE", "DROP", "ALTER", "LOAD", "EXPORT", "IMPORT"]:
-            if query.startswith(operation):
-                return operation
-        return "UNKNOWN"
-    
-    def _execute_select(self, query: str, **kwargs) -> Any:
-        """Execute SELECT query."""
-        return {"result": "HiveQL SELECT executed", "query": query}
-    
-    def _execute_insert(self, query: str, **kwargs) -> Any:
-        """Execute INSERT query."""
-        return {"result": "HiveQL INSERT executed", "query": query}
-    
-    def _execute_create(self, query: str, **kwargs) -> Any:
-        """Execute CREATE query."""
-        return {"result": "HiveQL CREATE executed", "query": query}
-    
-    def _execute_load(self, query: str, **kwargs) -> Any:
-        """Execute LOAD query."""
-        return {"result": "HiveQL LOAD executed", "query": query}
-    
-    def _estimate_complexity(self, query: str) -> str:
-        """Estimate query complexity."""
-        query = query.upper()
-        if "JOIN" in query or "UNION" 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 200  # Higher cost due to MapReduce
-        elif complexity == "MEDIUM":
-            return 100
-        else:
-            return 50
-    
-    def _estimate_mapreduce_jobs(self, query: str) -> int:
-        """Estimate number of MapReduce jobs."""
-        query = query.upper()
-        jobs = 1  # Base job
-        
-        if "JOIN" in query:
-            jobs += 1
-        if "GROUP BY" in query:
-            jobs += 1
-        if "ORDER BY" in query:
-            jobs += 1
-        
-        return jobs
-    
-    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 "JOIN" in query:
-            hints.append("Consider using partitioned tables for JOINs")
-        if "GROUP BY" in query:
-            hints.append("Consider using bucketed tables for GROUP BY")
-        
-        return hints

exonware/xwnode/queries/strategies/hql.py

@@ -1,70 +0,0 @@
-#!/usr/bin/env python3
-"""
-HQL Query Strategy
-
-This module implements the HQL query strategy for Hibernate Query Language operations.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-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 HQLStrategy(AStructuredQueryStrategy):
-    """HQL query strategy for Hibernate Query Language operations."""
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.HQL
-        self._traits = QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL | QueryTrait.BATCH
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute HQL query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid HQL query: {query}")
-        return {"result": "HQL query executed", "query": query}
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate HQL query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        return any(op in query.upper() for op in ["FROM", "SELECT", "WHERE", "UPDATE", "DELETE", "INSERT"])
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get HQL query execution plan."""
-        return {
-            "query_type": "HQL",
-            "complexity": "MEDIUM",
-            "estimated_cost": 100
-        }
-    
-    def select_query(self, table: str, columns: List[str], where_clause: str = None) -> Any:
-        """Execute SELECT query."""
-        return self.execute(f"SELECT {', '.join(columns)} FROM {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"FROM {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"SELECT {', '.join(functions)} FROM {table}")

exonware/xwnode/queries/strategies/jmespath.py

@@ -1,219 +0,0 @@
-#!/usr/bin/env python3
-"""
-JMESPath Query Strategy
-
-This module implements the JMESPath query strategy for JSON 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 JMESPathStrategy(ADocumentQueryStrategy):
-    """
-    JMESPath query strategy for JSON data queries.
-    
-    Supports:
-    - JMESPath expressions
-    - Projections and filters
-    - Functions and operators
-    - Multi-select and pipe expressions
-    - Flatten and sort operations
-    """
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.JMESPATH
-        self._traits = QueryTrait.DOCUMENT | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute JMESPath query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid JMESPath query: {query}")
-        
-        query_type = self._get_query_type(query)
-        
-        if query_type == "projection":
-            return self._execute_projection(query, **kwargs)
-        elif query_type == "filter":
-            return self._execute_filter(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 JMESPath query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        
-        # Basic JMESPath validation
-        query = query.strip()
-        
-        # Check for JMESPath syntax
-        if query.startswith(".") or query.startswith("[") or query.startswith("@"):
-            return True
-        
-        # Check for JMESPath functions
-        jmespath_functions = ["length", "keys", "values", "sort", "reverse", "flatten", "unique", "join", "split", "to_string", "to_number", "type", "starts_with", "ends_with", "contains", "abs", "ceil", "floor", "max", "min", "sum", "avg", "sort_by", "group_by", "map", "filter", "merge", "merge_left", "merge_right"]
-        
-        for func in jmespath_functions:
-            if func in query:
-                return True
-        
-        # Check for operators
-        if "||" in query or "&&" in query or "==" 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 JMESPath 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."""
-        # JMESPath 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}': @.{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."""
-        if order.lower() == "desc":
-            query = f"sort_by(@, &{sort_fields[0]}) | reverse(@)"
-        else:
-            query = f"sort_by(@, &{sort_fields[0]})"
-        
-        return self.execute(query)
-    
-    def limit_query(self, limit: int, offset: int = 0) -> Any:
-        """Execute limit query."""
-        if offset > 0:
-            query = f"[{offset}:{offset + limit}]"
-        else:
-            query = f"[:{limit}]"
-        
-        return self.execute(query)
-    
-    def _get_query_type(self, query: str) -> str:
-        """Extract query type from JMESPath query."""
-        query = query.strip()
-        
-        if "[" in query and "]" in query:
-            return "filter"
-        elif "{" in query and "}" in query:
-            return "projection"
-        elif "(" in query and ")" in query:
-            return "function"
-        else:
-            return "path"
-    
-    def _execute_projection(self, query: str, **kwargs) -> Any:
-        """Execute projection query."""
-        return {"result": "JMESPath projection executed", "query": query}
-    
-    def _execute_filter(self, query: str, **kwargs) -> Any:
-        """Execute filter query."""
-        return {"result": "JMESPath filter executed", "query": query}
-    
-    def _execute_function(self, query: str, **kwargs) -> Any:
-        """Execute function query."""
-        return {"result": "JMESPath 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 80
-        elif complexity == "MEDIUM":
-            return 40
-        else:
-            return 20
-    
-    def _extract_expressions(self, query: str) -> List[str]:
-        """Extract JMESPath expressions from query."""
-        expressions = []
-        
-        # Path expressions
-        if "." in query:
-            expressions.append("path")
-        if "[" in query and "]" in query:
-            expressions.append("filter")
-        if "{" in query and "}" in query:
-            expressions.append("projection")
-        if "|" in query:
-            expressions.append("pipe")
-        if "||" in query or "&&" in query:
-            expressions.append("logical")
-        if "==" in query or "!=" in query or ">" in query or "<" in query:
-            expressions.append("comparison")
-        
-        # Functions
-        jmespath_functions = ["length", "keys", "values", "sort", "reverse", "flatten", "unique", "join", "split", "to_string", "to_number", "type", "starts_with", "ends_with", "contains", "abs", "ceil", "floor", "max", "min", "sum", "avg", "sort_by", "group_by", "map", "filter", "merge", "merge_left", "merge_right"]
-        for func in jmespath_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 combining operations to reduce pipe operations")
-        
-        if "[" in query and "]" in query:
-            hints.append("Consider using specific paths instead of array operations when possible")
-        
-        if "{" in query and "}" in query:
-            hints.append("Consider using multi-select for better performance")
-        
-        if "sort" in query:
-            hints.append("Consider using sort_by for complex sorting operations")
-        
-        return hints

exonware/xwnode/queries/strategies/jq.py

@@ -1,66 +0,0 @@
-#!/usr/bin/env python3
-"""
-jq Query Strategy
-
-This module implements the jq query strategy for jq JSON processor operations.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-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 JQStrategy(ADocumentQueryStrategy):
-    """jq query strategy for jq JSON processor operations."""
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.JQ
-        self._traits = QueryTrait.DOCUMENT | QueryTrait.ANALYTICAL | QueryTrait.STREAMING
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute jq query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid jq query: {query}")
-        return {"result": "jq query executed", "query": query}
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate jq query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        return any(op in query for op in [".", "|", "select", "map", "filter", "group_by", "sort_by"])
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get jq query execution plan."""
-        return {
-            "query_type": "jq",
-            "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"select({filter_expression})")
-    
-    def projection_query(self, fields: List[str]) -> Any:
-        """Execute projection query."""
-        return self.execute(f"{{{', '.join(f'{field}: .{field}' for field in 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".[{offset}:{offset + limit}]")

exonware/xwnode/queries/strategies/json_query.py

@@ -1,66 +0,0 @@
-#!/usr/bin/env python3
-"""
-JSON Query Strategy
-
-This module implements the JSON Query strategy for generic JSON operations.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-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 JSONQueryStrategy(ADocumentQueryStrategy):
-    """JSON Query strategy for generic JSON operations."""
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.JSON_QUERY
-        self._traits = QueryTrait.DOCUMENT | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute JSON query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid JSON query: {query}")
-        return {"result": "JSON query executed", "query": query}
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate JSON 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 JSON query execution plan."""
-        return {
-            "query_type": "JSON_QUERY",
-            "complexity": "MEDIUM",
-            "estimated_cost": 50
-        }
-    
-    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"$[{', '.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"$[{offset}:{offset + limit}]")