exonware-xwnode 0.0.1.13__py3-none-any.whl → 0.0.1.15__py3-none-any.whl

exonware/xwnode/queries/executors/base.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/base.py
+
+Operation Executor Base Classes
+
+This module provides base classes for operation executors with capability checking.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
+"""
+
+import time
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+from .contracts import (
+    IOperationExecutor,
+    Action,
+    ExecutionContext,
+    ExecutionResult,
+    NodeType
+)
+from .types import OperationCapability
+from .errors import UnsupportedOperationError  # Reuse from root via errors.py
+from ...errors import XWNodeValueError
+
+
+class AOperationExecutor(IOperationExecutor):
+    """
+    Abstract base class for operation executors.
+    
+    Provides common functionality including:
+    - Capability checking
+    - Performance monitoring
+    - Error handling
+    - Validation
+    """
+    
+    # Operation name (must be set by subclasses)
+    OPERATION_NAME: str = "UNKNOWN"
+    
+    # Supported node types (empty = all types)
+    SUPPORTED_NODE_TYPES: List[NodeType] = []
+    
+    # Required capabilities
+    REQUIRED_CAPABILITIES: OperationCapability = OperationCapability.NONE
+    
+    def __init__(self):
+        """Initialize operation executor."""
+        self._execution_count = 0
+        self._total_time = 0.0
+        self._error_count = 0
+    
+    def execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """
+        Execute operation with monitoring and error handling.
+        
+        This method implements the Template Method pattern:
+        1. Validate
+        2. Check capability
+        3. Execute (delegated to subclass)
+        4. Monitor performance
+        """
+        start_time = time.time()
+        
+        try:
+            # Validate action
+            if not self.validate(action, context):
+                raise XWNodeValueError(f"Invalid action: {action.type}")
+            
+            # Check capability
+            self.validate_capability_or_raise(context)
+            
+            # Execute (delegated to subclass)
+            result = self._do_execute(action, context)
+            
+            # Update metrics
+            execution_time = time.time() - start_time
+            self._execution_count += 1
+            self._total_time += execution_time
+            result.execution_time = execution_time
+            
+            return result
+            
+        except Exception as e:
+            self._error_count += 1
+            execution_time = time.time() - start_time
+            
+            return ExecutionResult(
+                data=None,
+                success=False,
+                error=str(e),
+                execution_time=execution_time
+            )
+    
+    @abstractmethod
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """
+        Execute the actual operation (implemented by subclasses).
+        
+        Args:
+            action: The action to execute
+            context: Execution context
+            
+        Returns:
+            ExecutionResult with data
+        """
+        pass
+    
+    def validate(self, action: Action, context: ExecutionContext) -> bool:
+        """
+        Validate action before execution.
+        
+        Default implementation checks basic requirements.
+        Subclasses can override for specific validation.
+        """
+        if not action or not action.type:
+            return False
+        if not context or not context.node:
+            return False
+        return True
+    
+    def can_execute_on(self, node_type: NodeType) -> bool:
+        """
+        Check if this executor can operate on the given node type.
+        
+        Args:
+            node_type: The node type to check
+            
+        Returns:
+            True if this executor supports the node type
+        """
+        # Empty list means supports all types (universal operation)
+        if not self.SUPPORTED_NODE_TYPES:
+            return True
+        return node_type in self.SUPPORTED_NODE_TYPES
+    
+    def validate_capability_or_raise(self, context: ExecutionContext) -> None:
+        """
+        Validate operation can execute on node, raise if not.
+        
+        Args:
+            context: Execution context
+            
+        Raises:
+            UnsupportedOperationError: If operation cannot execute on node type
+        """
+        # Get node's strategy type
+        if hasattr(context.node, '_strategy') and hasattr(context.node._strategy, 'STRATEGY_TYPE'):
+            node_type = context.node._strategy.STRATEGY_TYPE
+        elif hasattr(context.node, 'STRATEGY_TYPE'):
+            node_type = context.node.STRATEGY_TYPE
+        else:
+            # Default to TREE for backward compatibility
+            node_type = NodeType.TREE
+        
+        # Check if operation can execute on this node type
+        if not self.can_execute_on(node_type):
+            supported = [nt.name for nt in self.SUPPORTED_NODE_TYPES]
+            raise UnsupportedOperationError(
+                self.OPERATION_NAME,
+                node_type,
+                f"Requires one of: {supported}"
+            )
+    
+    def estimate_cost(self, action: Action, context: ExecutionContext) -> int:
+        """
+        Estimate execution cost.
+        
+        Default implementation returns fixed cost.
+        Subclasses can override for more accurate estimates.
+        """
+        return 100
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get execution statistics for this executor."""
+        avg_time = self._total_time / self._execution_count if self._execution_count > 0 else 0
+        
+        return {
+            'operation': self.OPERATION_NAME,
+            'execution_count': self._execution_count,
+            'total_time': self._total_time,
+            'average_time': avg_time,
+            'error_count': self._error_count,
+            'success_rate': (self._execution_count - self._error_count) / self._execution_count if self._execution_count > 0 else 1.0
+        }
+
+
+class AUniversalOperationExecutor(AOperationExecutor):
+    """
+    Base class for universal operations that work on all node types.
+    
+    Universal operations:
+    - SELECT, INSERT, UPDATE, DELETE
+    - WHERE, FILTER
+    - GROUP BY, COUNT, SUM, AVG
+    - PROJECT, EXTEND
+    """
+    
+    # Universal operations support all node types (empty list)
+    SUPPORTED_NODE_TYPES: List[NodeType] = []
+
+
+class ATreeOperationExecutor(AOperationExecutor):
+    """
+    Base class for tree-specific operations.
+    
+    Tree operations:
+    - BETWEEN, RANGE
+    - ORDER BY
+    - MIN, MAX (optimal on trees)
+    """
+    
+    # Only works on tree nodes
+    SUPPORTED_NODE_TYPES: List[NodeType] = [NodeType.TREE]
+    REQUIRED_CAPABILITIES: OperationCapability = OperationCapability.REQUIRES_ORDERED
+
+
+class AGraphOperationExecutor(AOperationExecutor):
+    """
+    Base class for graph-specific operations.
+    
+    Graph operations:
+    - MATCH, PATH
+    - OUT, IN_TRAVERSE
+    - Graph traversal
+    """
+    
+    # Only works on graph nodes
+    SUPPORTED_NODE_TYPES: List[NodeType] = [NodeType.GRAPH, NodeType.TREE]  # Trees can act as graphs
+
+
+class ALinearOperationExecutor(AOperationExecutor):
+    """
+    Base class for linear-specific operations.
+    
+    Linear operations:
+    - SLICING, INDEXING
+    - Sequential operations
+    """
+    
+    # Only works on linear and matrix nodes
+    SUPPORTED_NODE_TYPES: List[NodeType] = [NodeType.LINEAR, NodeType.MATRIX]
+
+
+__all__ = [
+    'AOperationExecutor',
+    'AUniversalOperationExecutor',
+    'ATreeOperationExecutor',
+    'AGraphOperationExecutor',
+    'ALinearOperationExecutor',
+    'UnsupportedOperationError',
+]

exonware/xwnode/queries/executors/capability_checker.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/capability_checker.py
+
+Operation Capability Checker
+
+This module provides capability checking for operations on different node types.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
+"""
+
+from typing import Dict, List, Set
+
+# Import NodeType from nodes module per DEV_GUIDELINES
+from ...nodes.strategies.contracts import NodeType
+
+
+# Operation-to-NodeType Compatibility Matrix
+OPERATION_COMPATIBILITY = {
+    # Core CRUD Operations (Universal)
+    'SELECT': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'INSERT': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'UPDATE': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'DELETE': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'CREATE': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'DROP': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    
+    # Filtering Operations (Universal)
+    'WHERE': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'FILTER': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'LIKE': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'IN': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'HAS': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    
+    # Range Operations (Tree/Matrix)
+    'BETWEEN': {NodeType.TREE, NodeType.MATRIX},
+    'RANGE': {NodeType.TREE, NodeType.MATRIX},
+    
+    # Aggregation Operations (Universal)
+    'GROUP': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'BY': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'HAVING': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'SUMMARIZE': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'SUM': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'COUNT': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'AVG': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'MIN': {NodeType.LINEAR, NodeType.TREE, NodeType.MATRIX},  # Optimal on trees
+    'MAX': {NodeType.LINEAR, NodeType.TREE, NodeType.MATRIX},  # Optimal on trees
+    'DISTINCT': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    
+    # Ordering Operations (Tree/Linear)
+    'ORDER': {NodeType.TREE, NodeType.LINEAR},
+    
+    # Join Operations (Universal conceptually)
+    'JOIN': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'UNION': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'WITH': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'OPTIONAL': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    
+    # Graph Operations
+    'MATCH': {NodeType.GRAPH, NodeType.TREE, NodeType.HYBRID},
+    'PATH': {NodeType.GRAPH, NodeType.TREE, NodeType.HYBRID},
+    'OUT': {NodeType.GRAPH, NodeType.TREE, NodeType.HYBRID},
+    'IN_TRAVERSE': {NodeType.GRAPH, NodeType.TREE, NodeType.HYBRID},
+    'RETURN': {NodeType.GRAPH, NodeType.TREE, NodeType.HYBRID},
+    
+    # Projection Operations (Universal)
+    'PROJECT': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'EXTEND': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    
+    # Array Operations (Linear/Matrix)
+    'SLICING': {NodeType.LINEAR, NodeType.MATRIX},
+    'INDEXING': {NodeType.LINEAR, NodeType.MATRIX, NodeType.TREE},
+    
+    # Search Operations (Universal)
+    'TERM': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    
+    # Data Operations (Universal)
+    'LOAD': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'STORE': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'MERGE': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'ALTER': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    
+    # Control Flow Operations (Universal)
+    'FOREACH': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'LET': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'FOR': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    
+    # Window Operations (Time-series, works on linear/tree)
+    'WINDOW': {NodeType.LINEAR, NodeType.TREE},
+    'AGGREGATE': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    
+    # Metadata Operations (Universal)
+    'DESCRIBE': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'CONSTRUCT': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'ASK': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    
+    # Advanced Operations (Universal)
+    'SUBSCRIBE': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'SUBSCRIPTION': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'MUTATION': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'PIPE': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'OPTIONS': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+    'VALUES': {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID},
+}
+
+
+def check_operation_compatibility(operation: str, node_type: NodeType) -> bool:
+    """
+    Check if an operation is compatible with a node type.
+    
+    Args:
+        operation: Operation name (e.g., "SELECT")
+        node_type: Node type to check
+        
+    Returns:
+        True if operation is compatible with node type
+    """
+    operation = operation.upper()
+    
+    # Check compatibility matrix
+    if operation in OPERATION_COMPATIBILITY:
+        return node_type in OPERATION_COMPATIBILITY[operation]
+    
+    # Unknown operation - assume universal (backward compatibility)
+    return True
+
+
+def get_supported_operations(node_type: NodeType) -> List[str]:
+    """
+    Get list of operations supported by a node type.
+    
+    Args:
+        node_type: Node type to check
+        
+    Returns:
+        List of supported operation names
+    """
+    supported = []
+    
+    for operation, compatible_types in OPERATION_COMPATIBILITY.items():
+        if node_type in compatible_types:
+            supported.append(operation)
+    
+    return supported
+
+
+def get_universal_operations() -> List[str]:
+    """
+    Get list of universal operations (work on all node types).
+    
+    Returns:
+        List of universal operation names
+    """
+    universal = []
+    all_types = {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID}
+    
+    for operation, compatible_types in OPERATION_COMPATIBILITY.items():
+        if compatible_types == all_types:
+            universal.append(operation)
+    
+    return universal
+
+
+def get_type_specific_operations(node_type: NodeType) -> List[str]:
+    """
+    Get operations that are specific to (or optimal for) a node type.
+    
+    Args:
+        node_type: Node type to check
+        
+    Returns:
+        List of type-specific operation names
+    """
+    specific = []
+    all_types = {NodeType.LINEAR, NodeType.TREE, NodeType.GRAPH, NodeType.MATRIX, NodeType.HYBRID}
+    
+    for operation, compatible_types in OPERATION_COMPATIBILITY.items():
+        # If node type supports it but not all types support it
+        if node_type in compatible_types and compatible_types != all_types:
+            specific.append(operation)
+    
+    return specific
+
+
+# Global registry accessor
+def get_global_registry() -> OperationRegistry:
+    """Get the global operation registry instance."""
+    return OperationRegistry()
+
+
+__all__ = [
+    'OperationRegistry',
+    'get_operation_registry',
+    'check_operation_compatibility',
+    'get_supported_operations',
+    'get_universal_operations',
+    'get_type_specific_operations',
+    'OPERATION_COMPATIBILITY',
+]

exonware/xwnode/queries/executors/contracts.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/contracts.py
+
+Operation Executor Contracts
+
+This module defines the interfaces and data structures for query operation execution.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, field
+
+# Import shared types per DEV_GUIDELINES.md
+from ...nodes.strategies.contracts import NodeType
+from .types import OperationCapability
+
+
+@dataclass
+class Action:
+    """
+    Represents a single query action to be executed.
+    
+    Actions are parsed from XWQuery Script and contain all information
+    needed to execute a specific operation.
+    """
+    type: str                        # e.g., "SELECT", "INSERT", "WHERE"
+    params: Dict[str, Any]           # Operation parameters
+    id: str = ""                     # Unique action ID
+    line_number: int = 0             # Source line number
+    children: List['Action'] = field(default_factory=list)  # Nested actions
+    metadata: Dict[str, Any] = field(default_factory=dict)  # Additional metadata
+
+
+@dataclass
+class ExecutionContext:
+    """
+    Execution context for operation execution.
+    
+    Contains all state needed during execution including the target node,
+    variables, transaction state, and configuration.
+    """
+    node: Any                        # Target XWNode to execute on
+    variables: Dict[str, Any] = field(default_factory=dict)  # Query variables
+    transaction: Optional[Any] = None  # Transaction object (if in transaction)
+    cache: Optional[Dict[str, Any]] = None  # Result cache
+    parent_results: Dict[str, Any] = field(default_factory=dict)  # Results from parent actions
+    options: Dict[str, Any] = field(default_factory=dict)  # Execution options
+    
+    def set_result(self, action_id: str, result: Any) -> None:
+        """Store result for later use by other actions."""
+        self.parent_results[action_id] = result
+    
+    def get_result(self, action_id: str) -> Optional[Any]:
+        """Get result from previous action."""
+        return self.parent_results.get(action_id)
+
+
+@dataclass
+class ExecutionResult:
+    """
+    Result of operation execution.
+    
+    Contains the data returned by the operation along with metadata
+    about the execution.
+    """
+    data: Any                        # Result data
+    affected_count: int = 0          # Number of items affected
+    execution_time: float = 0.0      # Execution time in seconds
+    metadata: Dict[str, Any] = field(default_factory=dict)  # Additional metadata
+    success: bool = True             # Whether execution succeeded
+    error: Optional[str] = None      # Error message if failed
+
+
+class IOperationExecutor(ABC):
+    """
+    Interface for operation executors.
+    
+    All operation executors must implement this interface to be compatible
+    with the execution engine.
+    """
+    
+    # Operation name (e.g., "SELECT", "INSERT")
+    OPERATION_NAME: str = ""
+    
+    # Supported node types (empty = all types)
+    SUPPORTED_NODE_TYPES: List[NodeType] = []
+    
+    # Required capabilities
+    REQUIRED_CAPABILITIES: OperationCapability = OperationCapability.NONE
+    
+    @abstractmethod
+    def execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """
+        Execute the operation.
+        
+        Args:
+            action: The action to execute
+            context: Execution context with node and state
+            
+        Returns:
+            ExecutionResult with data and metadata
+            
+        Raises:
+            UnsupportedOperationError: If operation cannot execute on node type
+            ExecutionError: If execution fails
+        """
+        pass
+    
+    @abstractmethod
+    def validate(self, action: Action, context: ExecutionContext) -> bool:
+        """
+        Validate that the action can be executed.
+        
+        Args:
+            action: The action to validate
+            context: Execution context
+            
+        Returns:
+            True if action is valid and can be executed
+        """
+        pass
+    
+    def can_execute_on(self, node_type: NodeType) -> bool:
+        """
+        Check if this executor can operate on the given node type.
+        
+        Args:
+            node_type: The node type to check
+            
+        Returns:
+            True if this executor supports the node type
+        """
+        # Empty list means supports all types
+        if not self.SUPPORTED_NODE_TYPES:
+            return True
+        return node_type in self.SUPPORTED_NODE_TYPES
+    
+    def estimate_cost(self, action: Action, context: ExecutionContext) -> int:
+        """
+        Estimate execution cost (optional).
+        
+        Args:
+            action: The action to estimate
+            context: Execution context
+            
+        Returns:
+            Estimated cost (arbitrary units)
+        """
+        return 100  # Default cost
+
+
+__all__ = [
+    'IOperationExecutor',
+    'Action',
+    'ExecutionContext',
+    'ExecutionResult',
+    'OperationCapability',
+    'NodeType',
+]

exonware/xwnode/queries/executors/core/__init__.py

@@ -0,0 +1,17 @@
+"""Core CRUD operation executors."""
+
+from .select_executor import SelectExecutor
+from .insert_executor import InsertExecutor
+from .update_executor import UpdateExecutor
+from .delete_executor import DeleteExecutor
+from .create_executor import CreateExecutor
+from .drop_executor import DropExecutor
+
+__all__ = [
+    'SelectExecutor',
+    'InsertExecutor',
+    'UpdateExecutor',
+    'DeleteExecutor',
+    'CreateExecutor',
+    'DropExecutor',
+]