exonware-xwnode 0.0.1.12__py3-none-any.whl

exonware/xwnode/strategies/queries/gremlin.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""
+Gremlin Query Strategy
+
+This module implements the Gremlin query strategy for Apache TinkerPop 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 GremlinStrategy(AGraphQueryStrategy):
+    """
+    Gremlin query strategy for Apache TinkerPop graph queries.
+    
+    Supports:
+    - Gremlin traversal language
+    - Graph traversal operations
+    - Vertex and edge operations
+    - Property and label operations
+    - Path and cycle detection
+    """
+    
+    def __init__(self, **options):
+        super().__init__(**options)
+        self._mode = QueryMode.GREMLIN
+        self._traits = QueryTrait.GRAPH | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
+    
+    def execute(self, query: str, **kwargs) -> Any:
+        """Execute Gremlin query."""
+        if not self.validate_query(query):
+            raise XWNodeValueError(f"Invalid Gremlin query: {query}")
+        
+        query_type = self._get_query_type(query)
+        
+        if query_type == "traversal":
+            return self._execute_traversal(query, **kwargs)
+        elif query_type == "vertex":
+            return self._execute_vertex(query, **kwargs)
+        elif query_type == "edge":
+            return self._execute_edge(query, **kwargs)
+        else:
+            raise XWNodeValueError(f"Unsupported query type: {query_type}")
+    
+    def validate_query(self, query: str) -> bool:
+        """Validate Gremlin query syntax."""
+        if not query or not isinstance(query, str):
+            return False
+        
+        # Basic Gremlin validation
+        query = query.strip()
+        
+        # Check for Gremlin keywords
+        gremlin_keywords = ["g.", "V", "E", "addV", "addE", "drop", "has", "hasLabel", "hasId", "out", "in", "both", "outE", "inE", "bothE", "outV", "inV", "bothV", "values", "key", "label", "id", "count", "limit", "range", "order", "by", "select", "where", "and", "or", "not", "is", "within", "without", "between", "inside", "outside", "within", "without", "between", "inside", "outside", "within", "without", "between", "inside", "outside"]
+        
+        for keyword in gremlin_keywords:
+            if keyword in query:
+                return True
+        
+        return False
+    
+    def get_query_plan(self, query: str) -> Dict[str, Any]:
+        """Get Gremlin 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),
+            "steps": self._extract_steps(query),
+            "optimization_hints": self._get_optimization_hints(query)
+        }
+    
+    def path_query(self, start: Any, end: Any) -> List[Any]:
+        """Execute path query."""
+        query = f"g.V('{start}').repeat(out()).until(hasId('{end}')).path()"
+        return self.execute(query)
+    
+    def neighbor_query(self, node: Any) -> List[Any]:
+        """Execute neighbor query."""
+        query = f"g.V('{node}').both()"
+        return self.execute(query)
+    
+    def shortest_path_query(self, start: Any, end: Any) -> List[Any]:
+        """Execute shortest path query."""
+        query = f"g.V('{start}').repeat(out()).until(hasId('{end}')).path().limit(1)"
+        return self.execute(query)
+    
+    def connected_components_query(self) -> List[List[Any]]:
+        """Execute connected components query."""
+        query = "g.V().repeat(both()).until(cyclicPath()).dedup()"
+        return self.execute(query)
+    
+    def cycle_detection_query(self) -> List[List[Any]]:
+        """Execute cycle detection query."""
+        query = "g.V().repeat(out()).until(cyclicPath()).path()"
+        return self.execute(query)
+    
+    def _get_query_type(self, query: str) -> str:
+        """Extract query type from Gremlin query."""
+        query = query.strip()
+        
+        if "V(" in query or "E(" in query:
+            return "traversal"
+        elif "addV" in query or "V(" in query:
+            return "vertex"
+        elif "addE" in query or "E(" in query:
+            return "edge"
+        else:
+            return "unknown"
+    
+    def _execute_traversal(self, query: str, **kwargs) -> Any:
+        """Execute traversal query."""
+        return {"result": "Gremlin traversal executed", "query": query}
+    
+    def _execute_vertex(self, query: str, **kwargs) -> Any:
+        """Execute vertex query."""
+        return {"result": "Gremlin vertex executed", "query": query}
+    
+    def _execute_edge(self, query: str, **kwargs) -> Any:
+        """Execute edge query."""
+        return {"result": "Gremlin edge executed", "query": query}
+    
+    def _estimate_complexity(self, query: str) -> str:
+        """Estimate query complexity."""
+        steps = self._extract_steps(query)
+        
+        if len(steps) > 10:
+            return "HIGH"
+        elif len(steps) > 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 180
+        elif complexity == "MEDIUM":
+            return 90
+        else:
+            return 45
+    
+    def _extract_steps(self, query: str) -> List[str]:
+        """Extract Gremlin steps from query."""
+        steps = []
+        
+        # Common Gremlin steps
+        gremlin_steps = ["V", "E", "addV", "addE", "drop", "has", "hasLabel", "hasId", "out", "in", "both", "outE", "inE", "bothE", "outV", "inV", "bothV", "values", "key", "label", "id", "count", "limit", "range", "order", "by", "select", "where", "and", "or", "not", "is", "within", "without", "between", "inside", "outside", "repeat", "until", "emit", "times", "path", "dedup", "cyclicPath"]
+        
+        for step in gremlin_steps:
+            if step in query:
+                steps.append(step)
+        
+        return steps
+    
+    def _get_optimization_hints(self, query: str) -> List[str]:
+        """Get query optimization hints."""
+        hints = []
+        
+        if "repeat" in query:
+            hints.append("Consider using limit() with repeat() to prevent infinite loops")
+        
+        if "path" in query:
+            hints.append("Consider using dedup() with path() to avoid duplicate paths")
+        
+        if "count" in query:
+            hints.append("Consider using count() early in the traversal for better performance")
+        
+        return hints

exonware/xwnode/strategies/queries/hiveql.py

@@ -0,0 +1,214 @@
+#!/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.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 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/strategies/queries/hql.py

@@ -0,0 +1,70 @@
+#!/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.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 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/strategies/queries/jmespath.py

@@ -0,0 +1,219 @@
+#!/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.12
+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