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

exonware/xwnode/queries/executors/capability_checker.py

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

@@ -1,166 +0,0 @@
-#!/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.22
-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 .defs 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

@@ -1,17 +0,0 @@
-"""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',
-]

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

@@ -1,96 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/core/create_executor.py
-
-CREATE Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-Generation Date: 08-Oct-2025
-"""
-
-from typing import Any, Dict, List
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-from ...nodes.strategies.contracts import NodeType
-
-
-class CreateExecutor(AUniversalOperationExecutor):
-    """
-    CREATE operation executor - Universal operation.
-    
-    Creates new structures (collections, indices, schemas) in nodes.
-    Works on all node types (LINEAR, TREE, GRAPH, MATRIX, HYBRID).
-    
-    Capability: Universal
-    Operation Type: CORE
-    """
-    
-    OPERATION_NAME = "CREATE"
-    OPERATION_TYPE = OperationType.CORE
-    SUPPORTED_NODE_TYPES = []  # Empty = Universal (all types)
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute CREATE operation."""
-        # 1. Extract parameters
-        params = action.params
-        structure_type = params.get('type', 'collection')  # collection, index, schema
-        name = params.get('name', 'new_structure')
-        schema = params.get('schema', {})
-        options = params.get('options', {})
-        
-        # 2. Get node strategy
-        node = context.node
-        
-        # 3. Execute create
-        result_data = self._execute_create(node, structure_type, name, schema, options, context)
-        
-        # 4. Return result
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={
-                'structure_type': structure_type,
-                'name': name,
-                'created': result_data.get('created', False)
-            }
-        )
-    
-    def _execute_create(self, node: Any, structure_type: str, name: str, 
-                       schema: Dict, options: Dict, context: ExecutionContext) -> Dict:
-        """Actual CREATE logic."""
-        try:
-            # Create structure based on type
-            if structure_type == 'collection':
-                # Create a new collection/path
-                node.set(name, {})
-                created = True
-            elif structure_type == 'index':
-                # Create an index (simplified)
-                index_path = f"_indices.{name}"
-                node.set(index_path, {'type': 'index', 'fields': schema})
-                created = True
-            elif structure_type == 'schema':
-                # Create a schema definition
-                schema_path = f"_schemas.{name}"
-                node.set(schema_path, schema)
-                created = True
-            else:
-                created = False
-            
-            return {
-                'created': created,
-                'type': structure_type,
-                'name': name,
-                'path': name
-            }
-        except Exception as e:
-            return {
-                'created': False,
-                'error': str(e)
-            }
-

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

@@ -1,99 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/core/delete_executor.py
-
-DELETE Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-Generation Date: 08-Oct-2025
-"""
-
-from typing import Any, Dict, List
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-from ...nodes.strategies.contracts import NodeType
-
-
-class DeleteExecutor(AUniversalOperationExecutor):
-    """
-    DELETE operation executor - Universal operation.
-    
-    Deletes data from nodes based on specified conditions.
-    Works on all node types (LINEAR, TREE, GRAPH, MATRIX, HYBRID).
-    
-    Capability: Universal
-    Operation Type: CORE
-    """
-    
-    OPERATION_NAME = "DELETE"
-    OPERATION_TYPE = OperationType.CORE
-    SUPPORTED_NODE_TYPES = []  # Empty = Universal (all types)
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute DELETE operation."""
-        # 1. Extract parameters
-        params = action.params
-        target = params.get('target', None)  # What to delete (path/key)
-        condition = params.get('where', None)  # Delete condition
-        
-        # 2. Get node strategy
-        node = context.node
-        
-        # 3. Execute delete
-        result_data = self._execute_delete(node, target, condition, context)
-        
-        # 4. Return result
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={
-                'deleted_count': result_data.get('count', 0),
-                'target': target,
-                'condition': condition
-            }
-        )
-    
-    def _execute_delete(self, node: Any, target: str, condition: Any, 
-                       context: ExecutionContext) -> Dict:
-        """Actual DELETE logic."""
-        deleted_count = 0
-        deleted_items = []
-        
-        if target:
-            # Delete specific target
-            try:
-                current = node.get(target, default=None)
-                if current is not None and self._matches_condition(current, condition):
-                    node.delete(target)
-                    deleted_count = 1
-                    deleted_items.append(target)
-            except Exception as e:
-                return {
-                    'count': 0,
-                    'items': [],
-                    'error': str(e)
-                }
-        else:
-            # Delete all matching items
-            # This is a simplified implementation
-            deleted_count = 0
-            deleted_items = []
-        
-        return {
-            'count': deleted_count,
-            'items': deleted_items
-        }
-    
-    def _matches_condition(self, item: Any, condition: Any) -> bool:
-        """Check if item matches condition."""
-        if condition is None:
-            return True
-        
-        # Simplified condition checking
-        return True
-

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

@@ -1,100 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/core/drop_executor.py
-
-DROP Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-Generation Date: 08-Oct-2025
-"""
-
-from typing import Any, Dict, List
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-from ...nodes.strategies.contracts import NodeType
-
-
-class DropExecutor(AUniversalOperationExecutor):
-    """
-    DROP operation executor - Universal operation.
-    
-    Drops/removes structures (collections, indices, schemas) from nodes.
-    Works on all node types (LINEAR, TREE, GRAPH, MATRIX, HYBRID).
-    
-    Capability: Universal
-    Operation Type: CORE
-    """
-    
-    OPERATION_NAME = "DROP"
-    OPERATION_TYPE = OperationType.CORE
-    SUPPORTED_NODE_TYPES = []  # Empty = Universal (all types)
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute DROP operation."""
-        # 1. Extract parameters
-        params = action.params
-        structure_type = params.get('type', 'collection')
-        name = params.get('name')
-        if_exists = params.get('if_exists', False)
-        
-        # 2. Get node strategy
-        node = context.node
-        
-        # 3. Execute drop
-        result_data = self._execute_drop(node, structure_type, name, if_exists, context)
-        
-        # 4. Return result
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={
-                'structure_type': structure_type,
-                'name': name,
-                'dropped': result_data.get('dropped', False)
-            }
-        )
-    
-    def _execute_drop(self, node: Any, structure_type: str, name: str, 
-                     if_exists: bool, context: ExecutionContext) -> Dict:
-        """Actual DROP logic."""
-        try:
-            # Determine path based on structure type
-            if structure_type == 'index':
-                path = f"_indices.{name}"
-            elif structure_type == 'schema':
-                path = f"_schemas.{name}"
-            else:
-                path = name
-            
-            # Check if exists
-            exists = node.get(path, default=None) is not None
-            
-            if not exists and not if_exists:
-                return {
-                    'dropped': False,
-                    'error': f"Structure '{name}' does not exist"
-                }
-            
-            if exists:
-                node.delete(path)
-                dropped = True
-            else:
-                dropped = False
-            
-            return {
-                'dropped': dropped,
-                'type': structure_type,
-                'name': name,
-                'path': path
-            }
-        except Exception as e:
-            return {
-                'dropped': False,
-                'error': str(e)
-            }
-