Support view creation with SQL

Author: Peng Ren

pymongosql/executor.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import logging
+import re
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Any, Dict, Optional, Sequence, Union
@@ -14,6 +15,7 @@
 from .sql.parser import SQLParser
 from .sql.query_builder import QueryExecutionPlan
 from .sql.update_builder import UpdateExecutionPlan
+from .sql.view_builder import ViewExecutionPlan
 
 _logger = logging.getLogger(__name__)
 
@@ -642,10 +644,124 @@ def execute(
         return self._execute_execution_plan(self._execution_plan, connection, parameters)
 
 
+class ViewExecution(ExecutionStrategy):
+    """Execution strategy for view statements (CREATE VIEW, DROP VIEW)."""
+
+    _DDL_PATTERN = re.compile(
+        r"^\s*(CREATE\s+VIEW|DROP\s+VIEW)\b",
+        re.IGNORECASE,
+    )
+
+    @property
+    def execution_plan(self) -> ViewExecutionPlan:
+        return self._execution_plan
+
+    def supports(self, context: ExecutionContext) -> bool:
+        return bool(self._DDL_PATTERN.match(context.query))
+
+    def _parse_sql(self, sql: str) -> ViewExecutionPlan:
+        normalized = " ".join(sql.split())
+
+        # CREATE VIEW view_name ON collection_name AS 'pipeline_json'
+        create_match = re.match(
+            r"CREATE\s+VIEW\s+(\w+)\s+ON\s+(\w+)\s+AS\s+'(.*)'",
+            normalized,
+            re.IGNORECASE | re.DOTALL,
+        )
+        if create_match:
+            import json
+
+            view_name = create_match.group(1)
+            source_collection = create_match.group(2)
+            pipeline_str = create_match.group(3)
+            try:
+                pipeline = json.loads(pipeline_str)
+            except json.JSONDecodeError as e:
+                raise SqlSyntaxError(f"Invalid pipeline JSON in CREATE VIEW: {e}")
+
+            if not isinstance(pipeline, list):
+                raise SqlSyntaxError("Pipeline must be a JSON array")
+
+            return ViewExecutionPlan(
+                collection=view_name,
+                ddl_type="create_view",
+                view_on=source_collection,
+                pipeline=pipeline,
+            )
+
+        # DROP VIEW view_name
+        drop_match = re.match(
+            r"DROP\s+VIEW\s+(\w+)\s*$",
+            normalized,
+            re.IGNORECASE,
+        )
+        if drop_match:
+            view_name = drop_match.group(1)
+            return ViewExecutionPlan(
+                collection=view_name,
+                ddl_type="drop_view",
+            )
+
+        raise SqlSyntaxError(f"Unsupported DDL statement: {sql}")
+
+    def _execute_execution_plan(
+        self,
+        execution_plan: ViewExecutionPlan,
+        connection: Any = None,
+        parameters: Optional[Union[Sequence[Any], Dict[str, Any]]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        try:
+            if not connection:
+                raise OperationalError("No connection provided")
+
+            db = connection.database
+
+            if execution_plan.ddl_type == "create_view":
+                command = {
+                    "create": execution_plan.collection,
+                    "viewOn": execution_plan.view_on,
+                    "pipeline": execution_plan.pipeline,
+                }
+                _logger.debug(f"Executing MongoDB create view command: {command}")
+                return _run_db_command(db, command, connection, "create view")
+
+            elif execution_plan.ddl_type == "drop_view":
+                # MongoDB drops views with the regular drop command
+                command = {"drop": execution_plan.collection}
+                _logger.debug(f"Executing MongoDB drop view command: {command}")
+                return _run_db_command(db, command, connection, "drop view")
+
+            else:
+                raise ProgrammingError(f"Unknown DDL type: {execution_plan.ddl_type}")
+
+        except PyMongoError as e:
+            _logger.error(f"MongoDB DDL execution failed: {e}")
+            raise DatabaseError(f"DDL execution failed: {e}")
+        except (ProgrammingError, DatabaseError, OperationalError):
+            raise
+        except Exception as e:
+            _logger.error(f"Unexpected error during DDL execution: {e}")
+            raise OperationalError(f"DDL 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 DDL execution for query: {context.query[:100]}")
+        self._execution_plan = self._parse_sql(context.query)
+
+        if not self._execution_plan.validate():
+            raise SqlSyntaxError("Generated DDL plan is invalid")
+
+        return self._execute_execution_plan(self._execution_plan, connection, parameters)
+
+
 class ExecutionPlanFactory:
     """Factory for creating appropriate execution strategy based on query context"""
 
-    _strategies = [StandardQueryExecution(), InsertExecution(), UpdateExecution(), DeleteExecution()]
+    _strategies = [ViewExecution(), StandardQueryExecution(), InsertExecution(), UpdateExecution(), DeleteExecution()]
 
     @classmethod
     def get_strategy(cls, context: ExecutionContext) -> ExecutionStrategy:

pymongosql/sql/partiql/PartiQLParser.g4

@@ -86,11 +86,13 @@ ddl
 createCommand
     : CREATE TABLE qualifiedName ( PAREN_LEFT tableDef PAREN_RIGHT )?                           # CreateTable
     | CREATE INDEX ON symbolPrimitive PAREN_LEFT pathSimple ( COMMA pathSimple )* PAREN_RIGHT   # CreateIndex
+    | CREATE VIEW symbolPrimitive ON symbolPrimitive AS LITERAL_STRING                          # CreateView
     ;
 
 dropCommand
     : DROP TABLE qualifiedName                                  # DropTable
     | DROP INDEX target=symbolPrimitive ON on=symbolPrimitive   # DropIndex
+    | DROP VIEW symbolPrimitive                                 # DropView
     ;
 
 tableDef

pymongosql/sql/partiql/PartiQLParser.py

@@ -2542,6 +2542,43 @@ def accept(self, visitor:ParseTreeVisitor):
                 return visitor.visitChildren(self)
 
 
+    class CreateViewContext(CreateCommandContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a PartiQLParser.CreateCommandContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def CREATE(self):
+            return self.getToken(PartiQLParser.CREATE, 0)
+        def VIEW(self):
+            return self.getToken(PartiQLParser.VIEW, 0)
+        def ON(self):
+            return self.getToken(PartiQLParser.ON, 0)
+        def AS(self):
+            return self.getToken(PartiQLParser.AS, 0)
+        def symbolPrimitive(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(PartiQLParser.SymbolPrimitiveContext)
+            else:
+                return self.getTypedRuleContext(PartiQLParser.SymbolPrimitiveContext,i)
+
+        def LITERAL_STRING(self):
+            return self.getToken(PartiQLParser.LITERAL_STRING, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCreateView" ):
+                listener.enterCreateView(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCreateView" ):
+                listener.exitCreateView(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitCreateView" ):
+                return visitor.visitCreateView(self)
+            else:
+                return visitor.visitChildren(self)
+
 
     def createCommand(self):
 
@@ -2698,6 +2735,34 @@ def accept(self, visitor:ParseTreeVisitor):
                 return visitor.visitChildren(self)
 
 
+    class DropViewContext(DropCommandContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a PartiQLParser.DropCommandContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def DROP(self):
+            return self.getToken(PartiQLParser.DROP, 0)
+        def VIEW(self):
+            return self.getToken(PartiQLParser.VIEW, 0)
+        def symbolPrimitive(self):
+            return self.getTypedRuleContext(PartiQLParser.SymbolPrimitiveContext,0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDropView" ):
+                listener.enterDropView(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDropView" ):
+                listener.exitDropView(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDropView" ):
+                return visitor.visitDropView(self)
+            else:
+                return visitor.visitChildren(self)
+
+
 
     def dropCommand(self):
 

pymongosql/sql/partiql/PartiQLParserListener.py

@@ -188,6 +188,15 @@ def exitCreateIndex(self, ctx:PartiQLParser.CreateIndexContext):
         pass
 
 
+    # Enter a parse tree produced by PartiQLParser#CreateView.
+    def enterCreateView(self, ctx:PartiQLParser.CreateViewContext):
+        pass
+
+    # Exit a parse tree produced by PartiQLParser#CreateView.
+    def exitCreateView(self, ctx:PartiQLParser.CreateViewContext):
+        pass
+
+
     # Enter a parse tree produced by PartiQLParser#DropTable.
     def enterDropTable(self, ctx:PartiQLParser.DropTableContext):
         pass
@@ -206,6 +215,15 @@ def exitDropIndex(self, ctx:PartiQLParser.DropIndexContext):
         pass
 
 
+    # Enter a parse tree produced by PartiQLParser#DropView.
+    def enterDropView(self, ctx:PartiQLParser.DropViewContext):
+        pass
+
+    # Exit a parse tree produced by PartiQLParser#DropView.
+    def exitDropView(self, ctx:PartiQLParser.DropViewContext):
+        pass
+
+
     # Enter a parse tree produced by PartiQLParser#tableDef.
     def enterTableDef(self, ctx:PartiQLParser.TableDefContext):
         pass

pymongosql/sql/partiql/PartiQLParserVisitor.py

@@ -109,6 +109,11 @@ def visitCreateIndex(self, ctx:PartiQLParser.CreateIndexContext):
         return self.visitChildren(ctx)
 
 
+    # Visit a parse tree produced by PartiQLParser#CreateView.
+    def visitCreateView(self, ctx:PartiQLParser.CreateViewContext):
+        return self.visitChildren(ctx)
+
+
     # Visit a parse tree produced by PartiQLParser#DropTable.
     def visitDropTable(self, ctx:PartiQLParser.DropTableContext):
         return self.visitChildren(ctx)
@@ -119,6 +124,11 @@ def visitDropIndex(self, ctx:PartiQLParser.DropIndexContext):
         return self.visitChildren(ctx)
 
 
+    # Visit a parse tree produced by PartiQLParser#DropView.
+    def visitDropView(self, ctx:PartiQLParser.DropViewContext):
+        return self.visitChildren(ctx)
+
+
     # Visit a parse tree produced by PartiQLParser#tableDef.
     def visitTableDef(self, ctx:PartiQLParser.TableDefContext):
         return self.visitChildren(ctx)

pymongosql/sql/view_builder.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+from .builder import ExecutionPlan
+
+_logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ViewExecutionPlan(ExecutionPlan):
+    """Execution plan for view statements (CREATE VIEW, DROP VIEW)."""
+
+    ddl_type: str = ""  # "create_view" or "drop_view"
+    view_on: Optional[str] = None  # Source collection for CREATE VIEW
+    pipeline: Optional[List[Dict[str, Any]]] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "ddl_type": self.ddl_type,
+            "collection": self.collection,
+        }
+        if self.ddl_type == "create_view":
+            result["view_on"] = self.view_on
+            result["pipeline"] = self.pipeline
+        return result
+
+    def validate(self) -> bool:
+        errors = self.validate_base()
+
+        if not self.ddl_type:
+            errors.append("DDL type is required")
+
+        if self.ddl_type == "create_view":
+            if not self.view_on:
+                errors.append("Source collection (ON) is required for CREATE VIEW")
+            if self.pipeline is None:
+                errors.append("Pipeline (AS) is required for CREATE VIEW")
+
+        if errors:
+            for err in errors:
+                _logger.warning(f"View plan validation error: {err}")
+            return False
+
+        return True