Reverting to at-use instantiation of VariableProcessor.

Author: cecily_carver

mysql_mimic/session.py

@@ -187,7 +187,6 @@ class Session(BaseSession):
     dialect: Type[Dialect] = MySQL
 
     def __init__(self, variables: Variables | None = None):
-        self._variable_processor: VariableProcessor
         self.variables = variables or SessionVariables(GlobalVariables())
 
         # Query middlewares.
@@ -278,9 +277,6 @@ async def close(self) -> None:
 
     async def handle_query(self, sql: str, attrs: Dict[str, str]) -> AllowedResult:
         self.timestamp = datetime.now(tz=self.timezone())
-        self._variable_processor = VariableProcessor(
-            mysql_function_mapping(self), self.variables
-        )
         result = None
         for expression in self._parse(sql):
             if not expression:
@@ -306,7 +302,9 @@ async def _query_info_schema(self, expression: exp.Expression) -> AllowedResult:
 
     async def _set_var_middleware(self, q: Query) -> AllowedResult:
         """Handles SET_VAR hints and replaces functions defined in the _functions mapping with their mapped values."""
-        with self._variable_processor.set_variables(q.expression):
+        with VariableProcessor(
+            mysql_function_mapping(self), self.variables, q.expression
+        ).set_variables():
             return await q.next()
 
     async def _use_middleware(self, q: Query) -> AllowedResult:

mysql_mimic/variable_processor.py

@@ -50,35 +50,36 @@ class VariableProcessor:
     original values.
     """
 
-    def __init__(self, functions: Mapping, variables: Variables):
+    def __init__(
+        self, functions: Mapping, variables: Variables, expression: exp.Expression
+    ):
         self._functions = functions
         self._variables = variables
+        self._expression = expression
 
         # Stores the original system variable values.
         self._orig: Dict[str, str] = {}
 
     @contextmanager
-    def set_variables(
-        self, expression: exp.Expression
-    ) -> Generator[exp.Expression, None, None]:
-        assignments = _get_var_assignments(expression)
+    def set_variables(self) -> Generator[exp.Expression, None, None]:
+        assignments = _get_var_assignments(self._expression)
         self._orig = {k: self._variables.get(k) for k in assignments}
         for k, v in assignments.items():
             self._variables.set(k, v)
 
-        self._replace_variables(expression)
+        self._replace_variables()
 
-        yield expression
+        yield self._expression
 
         for k, v in self._orig.items():
             self._variables.set(k, v)
 
-    def _replace_variables(self, expression: exp.Expression) -> None:
+    def _replace_variables(self) -> None:
         """Replaces certain functions in the query with literals provided from the mapping in _functions,
         and session parameters with the values of the session variables.
         """
-        if isinstance(expression, exp.Set):
-            for setitem in expression.expressions:
+        if isinstance(self._expression, exp.Set):
+            for setitem in self._expression.expressions:
                 if isinstance(setitem.this, exp.Binary):
                     # In the case of statements like: SET @@foo = @@bar
                     # We only want to replace variables on the right
@@ -87,7 +88,7 @@ def _replace_variables(self, expression: exp.Expression) -> None:
                         setitem.this.expression.transform(self._transform, copy=True),
                     )
         else:
-            expression.transform(self._transform, copy=False)
+            self._expression.transform(self._transform, copy=False)
 
     def _transform(self, node: exp.Expression) -> exp.Expression:
         new_node = None