Added delete support

Author: Peng Ren

pymongosql/executor.py

@@ -260,10 +260,90 @@ def execute(
         return self._execute_execution_plan(self._execution_plan, connection.database, parameters)
 
 
+class DeleteExecution(ExecutionStrategy):
+    """Strategy for executing DELETE statements."""
+
+    def __init__(self) -> None:
+        """Initialize DELETE execution strategy."""
+        self._execution_plan: Optional[Any] = None
+
+    @property
+    def execution_plan(self) -> Any:
+        return self._execution_plan
+
+    def supports(self, context: ExecutionContext) -> bool:
+        return context.query.lstrip().upper().startswith("DELETE")
+
+    def _parse_sql(self, sql: str) -> Any:
+        from .sql.delete_builder import DeleteExecutionPlan
+
+        try:
+            parser = SQLParser(sql)
+            plan = parser.get_execution_plan()
+
+            if not isinstance(plan, DeleteExecutionPlan):
+                raise SqlSyntaxError("Expected DELETE execution plan")
+
+            if not plan.validate():
+                raise SqlSyntaxError("Generated delete plan is invalid")
+
+            return plan
+        except SqlSyntaxError:
+            raise
+        except Exception as e:
+            _logger.error(f"SQL parsing failed: {e}")
+            raise SqlSyntaxError(f"Failed to parse SQL: {e}")
+
+    def _execute_execution_plan(
+        self,
+        execution_plan: Any,
+        db: Any,
+        parameters: Optional[Union[Sequence[Any], Dict[str, Any]]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        try:
+            if not execution_plan.collection:
+                raise ProgrammingError("No collection specified in delete")
+
+            filter_conditions = execution_plan.filter_conditions or {}
+
+            # Replace placeholders in filter if parameters provided
+            if parameters and filter_conditions:
+                filter_conditions = SQLHelper.replace_placeholders_generic(
+                    filter_conditions, parameters, execution_plan.parameter_style
+                )
+
+            command = {"delete": execution_plan.collection, "deletes": [{"q": filter_conditions, "limit": 0}]}
+
+            _logger.debug(f"Executing MongoDB delete command: {command}")
+
+            return db.command(command)
+        except PyMongoError as e:
+            _logger.error(f"MongoDB delete failed: {e}")
+            raise DatabaseError(f"Delete execution failed: {e}")
+        except (ProgrammingError, DatabaseError, OperationalError):
+            # Re-raise our own errors without wrapping
+            raise
+        except Exception as e:
+            _logger.error(f"Unexpected error during delete execution: {e}")
+            raise OperationalError(f"Delete execution error: {e}")
+
+    def execute(
+        self,
+        context: ExecutionContext,
+        connection: Any,
+        parameters: Optional[Union[Sequence[Any], Dict[str, Any]]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        _logger.debug(f"Using delete execution for query: {context.query[:100]}")
+
+        self._execution_plan = self._parse_sql(context.query)
+
+        return self._execute_execution_plan(self._execution_plan, connection.database, parameters)
+
+
 class ExecutionPlanFactory:
     """Factory for creating appropriate execution strategy based on query context"""
 
-    _strategies = [InsertExecution(), StandardQueryExecution()]
+    _strategies = [DeleteExecution(), InsertExecution(), StandardQueryExecution()]
 
     @classmethod
     def get_strategy(cls, context: ExecutionContext) -> ExecutionStrategy:

pymongosql/sql/ast.py

@@ -4,6 +4,8 @@
 
 from ..error import SqlSyntaxError
 from .builder import BuilderFactory
+from .delete_builder import DeleteExecutionPlan
+from .delete_handler import DeleteParseResult
 from .handler import BaseHandler, HandlerFactory
 from .insert_builder import InsertExecutionPlan
 from .insert_handler import InsertParseResult
@@ -34,7 +36,8 @@ class MongoSQLParserVisitor(PartiQLParserVisitor):
     def __init__(self) -> None:
         super().__init__()
         self._parse_result = QueryParseResult.for_visitor()
-        self._insert_parse_result = InsertParseResult.for_insert_visitor()
+        self._insert_parse_result = InsertParseResult.for_visitor()
+        self._delete_parse_result = DeleteParseResult.for_visitor()
         # Track current statement kind generically so UPDATE/DELETE can reuse this
         self._current_operation: str = "select"  # expected values: select | insert | update | delete
         self._handlers = self._initialize_handlers()
@@ -47,17 +50,20 @@ def _initialize_handlers(self) -> Dict[str, BaseHandler]:
             "from": HandlerFactory.get_visitor_handler("from"),
             "where": HandlerFactory.get_visitor_handler("where"),
             "insert": HandlerFactory.get_visitor_handler("insert"),
+            "delete": HandlerFactory.get_visitor_handler("delete"),
         }
 
     @property
     def parse_result(self) -> QueryParseResult:
         """Get the current parse result"""
         return self._parse_result
 
-    def parse_to_execution_plan(self) -> Union[QueryExecutionPlan, InsertExecutionPlan]:
+    def parse_to_execution_plan(self) -> Union[QueryExecutionPlan, InsertExecutionPlan, DeleteExecutionPlan]:
         """Convert the parse result to an execution plan using BuilderFactory."""
         if self._current_operation == "insert":
             return self._build_insert_plan()
+        elif self._current_operation == "delete":
+            return self._build_delete_plan()
 
         return self._build_query_plan()
 
@@ -91,6 +97,19 @@ def _build_insert_plan(self) -> InsertExecutionPlan:
 
         return builder.build()
 
+    def _build_delete_plan(self) -> DeleteExecutionPlan:
+        """Build a DELETE execution plan from DELETE parsing."""
+        _logger.debug(
+            f"Building DELETE plan with collection: {self._delete_parse_result.collection}, "
+            f"filters: {self._delete_parse_result.filter_conditions}"
+        )
+        builder = BuilderFactory.create_delete_builder().collection(self._delete_parse_result.collection)
+
+        if self._delete_parse_result.filter_conditions:
+            builder.filter_conditions(self._delete_parse_result.filter_conditions)
+
+        return builder.build()
+
     def visitRoot(self, ctx: PartiQLParser.RootContext) -> Any:
         """Visit root node and process child nodes"""
         _logger.debug("Starting to parse SQL query")
@@ -167,6 +186,57 @@ def visitInsertStatementLegacy(self, ctx: PartiQLParser.InsertStatementLegacyCon
             return handler.handle_visitor(ctx, self._insert_parse_result)
         return self.visitChildren(ctx)
 
+    def visitFromClauseSimpleExplicit(self, ctx: PartiQLParser.FromClauseSimpleExplicitContext) -> Any:
+        """Handle FROM clause (explicit form) in DELETE statements."""
+        if self._current_operation == "delete":
+            handler = self._handlers.get("delete")
+            if handler:
+                return handler.handle_from_clause_explicit(ctx, self._delete_parse_result)
+        return self.visitChildren(ctx)
+
+    def visitFromClauseSimpleImplicit(self, ctx: PartiQLParser.FromClauseSimpleImplicitContext) -> Any:
+        """Handle FROM clause (implicit form) in DELETE statements."""
+        if self._current_operation == "delete":
+            handler = self._handlers.get("delete")
+            if handler:
+                return handler.handle_from_clause_implicit(ctx, self._delete_parse_result)
+        return self.visitChildren(ctx)
+
+    def visitWhereClause(self, ctx: PartiQLParser.WhereClauseContext) -> Any:
+        """Handle WHERE clause (generic form used in DELETE, UPDATE)."""
+        _logger.debug("Processing WHERE clause (generic)")
+        try:
+            # For DELETE, use the delete handler
+            if self._current_operation == "delete":
+                handler = self._handlers.get("delete")
+                if handler:
+                    return handler.handle_where_clause(ctx, self._delete_parse_result)
+                return {}
+            else:
+                # For other operations, use the where handler
+                handler = self._handlers["where"]
+                if handler:
+                    result = handler.handle_visitor(ctx, self._parse_result)
+                    _logger.debug(f"Extracted filter conditions: {result}")
+                    return result
+            return {}
+        except Exception as e:
+            _logger.warning(f"Error processing WHERE clause: {e}")
+            return {}
+
+    def visitDeleteCommand(self, ctx: PartiQLParser.DeleteCommandContext) -> Any:
+        """Handle DELETE statements."""
+        _logger.debug("Processing DELETE statement")
+        self._current_operation = "delete"
+        # Reset delete parse result for this statement
+        self._delete_parse_result = DeleteParseResult.for_visitor()
+        # Use delete handler if available
+        handler = self._handlers.get("delete")
+        if handler:
+            handler.handle_visitor(ctx, self._delete_parse_result)
+        # Visit children to process FROM and WHERE clauses
+        return self.visitChildren(ctx)
+
     def visitOrderByClause(self, ctx: PartiQLParser.OrderByClauseContext) -> Any:
         """Handle ORDER BY clause for sorting"""
         _logger.debug("Processing ORDER BY clause")

pymongosql/sql/builder.py

@@ -49,6 +49,14 @@ def create_insert_builder():
 
         return MongoInsertBuilder()
 
+    @staticmethod
+    def create_delete_builder():
+        """Create a builder for DELETE queries"""
+        # Local import to avoid circular dependency during module import
+        from .delete_builder import MongoDeleteBuilder
+
+        return MongoDeleteBuilder()
+
 
 __all__ = [
     "ExecutionPlan",

pymongosql/sql/delete_builder.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Dict
+
+from .builder import ExecutionPlan
+
+_logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DeleteExecutionPlan(ExecutionPlan):
+    """Execution plan for DELETE operations against MongoDB."""
+
+    filter_conditions: Dict[str, Any] = field(default_factory=dict)
+    parameter_style: str = field(default="qmark")  # Parameter placeholder style: qmark (?) or named (:name)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert delete plan to dictionary representation."""
+        return {
+            "collection": self.collection,
+            "filter": self.filter_conditions,
+        }
+
+    def validate(self) -> bool:
+        """Validate the delete plan."""
+        errors = self.validate_base()
+
+        # Note: filter_conditions can be empty for DELETE FROM <collection> (delete all)
+        # which is valid, so we don't enforce filter presence
+
+        if errors:
+            _logger.error(f"Delete plan validation errors: {errors}")
+            return False
+
+        return True
+
+    def copy(self) -> "DeleteExecutionPlan":
+        """Create a copy of this delete plan."""
+        return DeleteExecutionPlan(
+            collection=self.collection,
+            filter_conditions=self.filter_conditions.copy() if self.filter_conditions else {},
+        )
+
+
+class MongoDeleteBuilder:
+    """Builder for constructing DeleteExecutionPlan objects."""
+
+    def __init__(self) -> None:
+        """Initialize the delete builder."""
+        self._plan = DeleteExecutionPlan()
+
+    def collection(self, collection: str) -> "MongoDeleteBuilder":
+        """Set the collection name."""
+        self._plan.collection = collection
+        return self
+
+    def filter_conditions(self, conditions: Dict[str, Any]) -> "MongoDeleteBuilder":
+        """Set the filter conditions for the delete operation."""
+        if conditions:
+            self._plan.filter_conditions = conditions
+        return self
+
+    def build(self) -> DeleteExecutionPlan:
+        """Build and return the DeleteExecutionPlan."""
+        if not self._plan.validate():
+            raise ValueError("Invalid delete plan")
+        return self._plan