sqlspec 0.24.1__py3-none-any.whl → 0.25.0__py3-none-any.whl

sqlspec/builder/mixins/_insert_operations.py

@@ -1,3 +1,4 @@
+# pyright: reportPrivateUsage=false
 """INSERT operation mixins.
 
 Provides mixins for INSERT statement functionality including
@@ -25,8 +26,9 @@ class InsertIntoClauseMixin:
 
     __slots__ = ()
 
-    # Type annotation for PyRight - this will be provided by the base class
-    _expression: Optional[exp.Expression]
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     def into(self, table: str) -> Self:
         """Set the target table for the INSERT statement.
@@ -40,14 +42,17 @@ class InsertIntoClauseMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        if self._expression is None:
-            self._expression = exp.Insert()
-        if not isinstance(self._expression, exp.Insert):
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Insert())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Insert):
             msg = "Cannot set target table on a non-INSERT expression."
             raise SQLBuilderError(msg)
 
         setattr(self, "_table", table)
-        self._expression.set("this", exp.to_table(table))
+        current_expr.set("this", exp.to_table(table))
         return self
 
 
@@ -57,8 +62,9 @@ class InsertValuesMixin:
 
     __slots__ = ()
 
-    # Type annotation for PyRight - this will be provided by the base class
-    _expression: Optional[exp.Expression]
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     _columns: Any  # Provided by QueryBuilder
 
@@ -74,14 +80,17 @@ class InsertValuesMixin:
 
     def columns(self, *columns: Union[str, exp.Expression]) -> Self:
         """Set the columns for the INSERT statement and synchronize the _columns attribute on the builder."""
-        if self._expression is None:
-            self._expression = exp.Insert()
-        if not isinstance(self._expression, exp.Insert):
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Insert())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Insert):
             msg = "Cannot set columns on a non-INSERT expression."
             raise SQLBuilderError(msg)
 
         # Get the current table from the expression
-        current_this = self._expression.args.get("this")
+        current_this = current_expr.args.get("this")
         if current_this is None:
             msg = "Table must be set using .into() before setting columns."
             raise SQLBuilderError(msg)
@@ -95,11 +104,11 @@ class InsertValuesMixin:
 
             # Create Schema object with table and columns
             schema = exp.Schema(this=table_name, expressions=column_identifiers)
-            self._expression.set("this", schema)
+            current_expr.set("this", schema)
         # No columns specified - ensure we have just a Table object
         elif isinstance(current_this, exp.Schema):
             table_name = current_this.this
-            self._expression.set("this", exp.Table(this=table_name))
+            current_expr.set("this", exp.Table(this=table_name))
 
         try:
             cols = self._columns
@@ -126,9 +135,12 @@ class InsertValuesMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        if self._expression is None:
-            self._expression = exp.Insert()
-        if not isinstance(self._expression, exp.Insert):
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Insert())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Insert):
             msg = "Cannot add values to a non-INSERT expression."
             raise SQLBuilderError(msg)
 
@@ -137,8 +149,8 @@ class InsertValuesMixin:
                 msg = "Cannot mix positional values with keyword values."
                 raise SQLBuilderError(msg)
             try:
-                _columns = self._columns
-                if not _columns:
+                cols = self._columns
+                if not cols:
                     self.columns(*kwargs.keys())
             except AttributeError:
                 pass
@@ -156,8 +168,8 @@ class InsertValuesMixin:
         elif len(values) == 1 and hasattr(values[0], "items"):
             mapping = values[0]
             try:
-                _columns = self._columns
-                if not _columns:
+                cols = self._columns
+                if not cols:
                     self.columns(*mapping.keys())
             except AttributeError:
                 pass
@@ -174,9 +186,9 @@ class InsertValuesMixin:
                     row_exprs.append(exp.Placeholder(this=param_name))
         else:
             try:
-                _columns = self._columns
-                if _columns and len(values) != len(_columns):
-                    msg = f"Number of values ({len(values)}) does not match the number of specified columns ({len(_columns)})."
+                cols = self._columns
+                if cols and len(values) != len(cols):
+                    msg = f"Number of values ({len(values)}) does not match the number of specified columns ({len(cols)})."
                     raise SQLBuilderError(msg)
             except AttributeError:
                 pass
@@ -186,11 +198,9 @@ class InsertValuesMixin:
                     row_exprs.append(v)
                 else:
                     try:
-                        _columns = self._columns
-                        if _columns and i < len(_columns):
-                            column_name = (
-                                str(_columns[i]).split(".")[-1] if "." in str(_columns[i]) else str(_columns[i])
-                            )
+                        cols = self._columns
+                        if cols and i < len(cols):
+                            column_name = str(cols[i]).split(".")[-1] if "." in str(cols[i]) else str(cols[i])
                             param_name = self._generate_unique_parameter_name(column_name)
                         else:
                             param_name = self._generate_unique_parameter_name(f"value_{i + 1}")
@@ -200,7 +210,7 @@ class InsertValuesMixin:
                     row_exprs.append(exp.Placeholder(this=param_name))
 
         values_expr = exp.Values(expressions=[row_exprs])
-        self._expression.set("expression", values_expr)
+        current_expr.set("expression", values_expr)
         return self
 
     def add_values(self, values: Sequence[Any]) -> Self:
@@ -221,8 +231,9 @@ class InsertFromSelectMixin:
 
     __slots__ = ()
 
-    # Type annotation for PyRight - this will be provided by the base class
-    _expression: Optional[exp.Expression]
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     _table: Any  # Provided by QueryBuilder
 
@@ -250,9 +261,12 @@ class InsertFromSelectMixin:
         except AttributeError:
             msg = "The target table must be set using .into() before adding values."
             raise SQLBuilderError(msg)
-        if self._expression is None:
-            self._expression = exp.Insert()
-        if not isinstance(self._expression, exp.Insert):
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Insert())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Insert):
             msg = "Cannot set INSERT source on a non-INSERT expression."
             raise SQLBuilderError(msg)
         subquery_parameters = select_builder._parameters
@@ -261,7 +275,7 @@ class InsertFromSelectMixin:
                 self.add_parameter(p_value, name=p_name)
         select_expr = select_builder._expression
         if select_expr and isinstance(select_expr, exp.Select):
-            self._expression.set("expression", select_expr.copy())
+            current_expr.set("expression", select_expr.copy())
         else:
             msg = "SelectBuilder must have a valid SELECT expression."
             raise SQLBuilderError(msg)

sqlspec/builder/mixins/_join_operations.py

@@ -1,3 +1,4 @@
+# pyright: reportPrivateUsage=false
 """JOIN operation mixins.
 
 Provides mixins for JOIN operations in SELECT statements.

sqlspec/builder/mixins/_merge_operations.py

@@ -1,3 +1,4 @@
+# pyright: reportPrivateUsage=false
 """MERGE operation mixins.
 
 Provides mixins for MERGE statement functionality including INTO,
@@ -28,7 +29,10 @@ class MergeIntoClauseMixin:
     """Mixin providing INTO clause for MERGE builders."""
 
     __slots__ = ()
-    _expression: Optional[exp.Expression]
+
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     def into(self, table: Union[str, exp.Expression], alias: Optional[str] = None) -> Self:
         """Set the target table for the MERGE operation (INTO clause).
@@ -41,11 +45,14 @@ class MergeIntoClauseMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        if self._expression is None:
-            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
-        if not isinstance(self._expression, exp.Merge):
-            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
-        self._expression.set("this", exp.to_table(table, alias=alias) if isinstance(table, str) else table)
+        current_expr = self.get_expression()
+        if current_expr is None or not isinstance(current_expr, exp.Merge):
+            self.set_expression(exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[])))
+            current_expr = self.get_expression()
+
+        # Type guard: current_expr is now guaranteed to be an Expression
+        assert current_expr is not None
+        current_expr.set("this", exp.to_table(table, alias=alias) if isinstance(table, str) else table)
         return self
 
 
@@ -54,7 +61,10 @@ class MergeUsingClauseMixin:
     """Mixin providing USING clause for MERGE builders."""
 
     __slots__ = ()
-    _expression: Optional[exp.Expression]
+
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
         """Add parameter - provided by QueryBuilder."""
@@ -75,11 +85,13 @@ class MergeUsingClauseMixin:
         Raises:
             SQLBuilderError: If the current expression is not a MERGE statement or if the source type is unsupported.
         """
-        if self._expression is None:
-            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
-        if not isinstance(self._expression, exp.Merge):
-            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
+        current_expr = self.get_expression()
+        if current_expr is None or not isinstance(current_expr, exp.Merge):
+            self.set_expression(exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[])))
+            current_expr = self.get_expression()
 
+        # Type guard: current_expr is now guaranteed to be an Expression
+        assert current_expr is not None
         source_expr: exp.Expression
         if isinstance(source, str):
             source_expr = exp.to_table(source, alias=alias)
@@ -99,7 +111,7 @@ class MergeUsingClauseMixin:
             msg = f"Unsupported source type for USING clause: {type(source)}"
             raise SQLBuilderError(msg)
 
-        self._expression.set("using", source_expr)
+        current_expr.set("using", source_expr)
         return self
 
 
@@ -108,7 +120,10 @@ class MergeOnClauseMixin:
     """Mixin providing ON clause for MERGE builders."""
 
     __slots__ = ()
-    _expression: Optional[exp.Expression]
+
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     def on(self, condition: Union[str, exp.Expression]) -> Self:
         """Set the join condition for the MERGE operation (ON clause).
@@ -123,11 +138,13 @@ class MergeOnClauseMixin:
         Raises:
             SQLBuilderError: If the current expression is not a MERGE statement or if the condition type is unsupported.
         """
-        if self._expression is None:
-            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
-        if not isinstance(self._expression, exp.Merge):
-            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
+        current_expr = self.get_expression()
+        if current_expr is None or not isinstance(current_expr, exp.Merge):
+            self.set_expression(exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[])))
+            current_expr = self.get_expression()
 
+        # Type guard: current_expr is now guaranteed to be an Expression
+        assert current_expr is not None
         condition_expr: exp.Expression
         if isinstance(condition, str):
             parsed_condition: Optional[exp.Expression] = exp.maybe_parse(
@@ -143,7 +160,7 @@ class MergeOnClauseMixin:
             msg = f"Unsupported condition type for ON clause: {type(condition)}"
             raise SQLBuilderError(msg)
 
-        self._expression.set("on", condition_expr)
+        current_expr.set("on", condition_expr)
         return self
 
 
@@ -152,7 +169,10 @@ class MergeMatchedClauseMixin:
     """Mixin providing WHEN MATCHED THEN ... clauses for MERGE builders."""
 
     __slots__ = ()
-    _expression: Optional[exp.Expression]
+
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
         """Add parameter - provided by QueryBuilder."""
@@ -170,15 +190,17 @@ class MergeMatchedClauseMixin:
         Args:
             when_clause: The WHEN clause to add.
         """
-        if self._expression is None:
-            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))  # type: ignore[misc]
-        if not isinstance(self._expression, exp.Merge):
-            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))  # type: ignore[misc]
-
-        whens = self._expression.args.get("whens")
+        current_expr = self.get_expression()
+        if current_expr is None or not isinstance(current_expr, exp.Merge):
+            self.set_expression(exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[])))
+            current_expr = self.get_expression()
+
+        # Type guard: current_expr is now guaranteed to be an Expression
+        assert current_expr is not None
+        whens = current_expr.args.get("whens")
         if not whens:
             whens = exp.Whens(expressions=[])
-            self._expression.set("whens", whens)
+            current_expr.set("whens", whens)
 
         whens.append("expressions", when_clause)
 
@@ -315,7 +337,9 @@ class MergeNotMatchedClauseMixin:
 
     __slots__ = ()
 
-    _expression: Optional[exp.Expression]
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
         """Add parameter - provided by QueryBuilder."""
@@ -415,7 +439,9 @@ class MergeNotMatchedBySourceClauseMixin:
 
     __slots__ = ()
 
-    _expression: Optional[exp.Expression]
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
         """Add parameter - provided by QueryBuilder."""

sqlspec/builder/mixins/_order_limit_operations.py

@@ -1,3 +1,4 @@
+# pyright: reportPrivateUsage=false
 """ORDER BY, LIMIT, OFFSET, and RETURNING clause mixins.
 
 Provides mixins for query result ordering, limiting, and result

sqlspec/builder/mixins/_pivot_operations.py

@@ -1,3 +1,4 @@
+# pyright: reportPrivateUsage=false
 """PIVOT and UNPIVOT operation mixins.
 
 Provides mixins for PIVOT and UNPIVOT operations in SELECT statements.

sqlspec/builder/mixins/_select_operations.py

@@ -1,3 +1,4 @@
+# pyright: reportPrivateUsage=false
 """SELECT clause mixins.
 
 Provides mixins for SELECT statement functionality including column selection,
@@ -28,8 +29,9 @@ class SelectClauseMixin:
 
     __slots__ = ()
 
-    # Type annotation for PyRight - this will be provided by the base class
-    _expression: Optional[exp.Expression]
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     def select(self, *columns: Union[str, exp.Expression, "Column", "FunctionColumn", "SQL", "Case"]) -> Self:
         """Add columns to SELECT clause.
@@ -41,13 +43,17 @@ class SelectClauseMixin:
             The current builder instance for method chaining.
         """
         builder = cast("SQLBuilderProtocol", self)
-        if builder._expression is None:
-            builder._expression = exp.Select()
-        if not isinstance(builder._expression, exp.Select):
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Select())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Select):
             msg = "Cannot add select columns to a non-SELECT expression."
             raise SQLBuilderError(msg)
         for column in columns:
-            builder._expression = builder._expression.select(parse_column_expression(column, builder), copy=False)
+            current_expr = current_expr.select(parse_column_expression(column, builder), copy=False)
+        self.set_expression(current_expr)
         return cast("Self", builder)
 
     def distinct(self, *columns: Union[str, exp.Expression, "Column", "FunctionColumn", "SQL"]) -> Self:
@@ -129,13 +135,13 @@ class SelectClauseMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        if self._expression is None or not isinstance(self._expression, exp.Select):
+        current_expr = self.get_expression()
+        if current_expr is None or not isinstance(current_expr, exp.Select):
             return self
 
         for column in columns:
-            self._expression = self._expression.group_by(
-                exp.column(column) if isinstance(column, str) else column, copy=False
-            )
+            current_expr = current_expr.group_by(exp.column(column) if isinstance(column, str) else column, copy=False)
+        self.set_expression(current_expr)
         return self
 
     def group_by_rollup(self, *columns: Union[str, exp.Expression]) -> Self:
@@ -480,9 +486,12 @@ class SelectClauseMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        if self._expression is None:
-            self._expression = exp.Select()
-        if not isinstance(self._expression, exp.Select):
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Select())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Select):
             msg = "Cannot add window function to a non-SELECT expression."
             raise SQLBuilderError(msg)
 
@@ -525,7 +534,8 @@ class SelectClauseMixin:
                 over_args["frame"] = frame_expr
 
         window_expr = exp.Window(this=func_expr_parsed, **over_args)
-        self._expression.select(exp.alias_(window_expr, alias) if alias else window_expr, copy=False)
+        current_expr = current_expr.select(exp.alias_(window_expr, alias) if alias else window_expr, copy=False)
+        self.set_expression(current_expr)
         return self
 
     def case_(self, alias: "Optional[str]" = None) -> "CaseBuilder":
@@ -906,3 +916,21 @@ class Case:
         """
         case_expr = exp.Case(ifs=self._conditions, default=self._default)
         return cast("exp.Alias", exp.alias_(case_expr, alias))
+
+    @property
+    def conditions(self) -> "list[exp.If]":
+        """Get CASE conditions (public API).
+
+        Returns:
+            List of If expressions representing WHEN clauses
+        """
+        return self._conditions
+
+    @property
+    def default(self) -> Optional[exp.Expression]:
+        """Get CASE default value (public API).
+
+        Returns:
+            Default expression for the ELSE clause, or None
+        """
+        return self._default

sqlspec/builder/mixins/_update_operations.py

@@ -1,3 +1,4 @@
+# pyright: reportPrivateUsage=false
 """UPDATE operation mixins.
 
 Provides mixins for UPDATE statement functionality including
@@ -25,8 +26,9 @@ class UpdateTableClauseMixin:
 
     __slots__ = ()
 
-    # Type annotation for PyRight - this will be provided by the base class
-    _expression: Optional[exp.Expression]
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     def table(self, table_name: str, alias: Optional[str] = None) -> Self:
         """Set the table to update.
@@ -38,10 +40,14 @@ class UpdateTableClauseMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        if self._expression is None or not isinstance(self._expression, exp.Update):
-            self._expression = exp.Update(this=None, expressions=[], joins=[])
+        current_expr = self.get_expression()
+        if current_expr is None or not isinstance(current_expr, exp.Update):
+            self.set_expression(exp.Update(this=None, expressions=[], joins=[]))
+            current_expr = self.get_expression()
+
+        assert current_expr is not None
         table_expr: exp.Expression = exp.to_table(table_name, alias=alias)
-        self._expression.set("this", table_expr)
+        current_expr.set("this", table_expr)
         setattr(self, "_table", table_name)
         return self
 
@@ -52,8 +58,9 @@ class UpdateSetClauseMixin:
 
     __slots__ = ()
 
-    # Type annotation for PyRight - this will be provided by the base class
-    _expression: Optional[exp.Expression]
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
         """Add parameter - provided by QueryBuilder."""
@@ -130,9 +137,12 @@ class UpdateSetClauseMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        if self._expression is None:
-            self._expression = exp.Update()
-        if not isinstance(self._expression, exp.Update):
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Update())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Update):
             msg = "Cannot add SET clause to non-UPDATE expression."
             raise SQLBuilderError(msg)
         assignments = []
@@ -149,8 +159,8 @@ class UpdateSetClauseMixin:
         else:
             msg = "Invalid arguments for set(): use (column, value), mapping, or kwargs."
             raise SQLBuilderError(msg)
-        existing = self._expression.args.get("expressions", [])
-        self._expression.set("expressions", existing + assignments)
+        existing = current_expr.args.get("expressions", [])
+        current_expr.set("expressions", existing + assignments)
         return self
 
 
@@ -160,8 +170,9 @@ class UpdateFromClauseMixin:
 
     __slots__ = ()
 
-    # Type annotation for PyRight - this will be provided by the base class
-    _expression: Optional[exp.Expression]
+    # Type annotations for PyRight - these will be provided by the base class
+    def get_expression(self) -> Optional[exp.Expression]: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
 
     def from_(self, table: Union[str, exp.Expression, Any], alias: Optional[str] = None) -> Self:
         """Add a FROM clause to the UPDATE statement.
@@ -176,7 +187,8 @@ class UpdateFromClauseMixin:
         Raises:
             SQLBuilderError: If the current expression is not an UPDATE statement.
         """
-        if self._expression is None or not isinstance(self._expression, exp.Update):
+        current_expr = self.get_expression()
+        if current_expr is None or not isinstance(current_expr, exp.Update):
             msg = "Cannot add FROM clause to non-UPDATE expression. Set the main table first."
             raise SQLBuilderError(msg)
         table_expr: exp.Expression
@@ -194,9 +206,9 @@ class UpdateFromClauseMixin:
         else:
             msg = f"Unsupported table type for FROM clause: {type(table)}"
             raise SQLBuilderError(msg)
-        if self._expression.args.get("from") is None:
-            self._expression.set("from", exp.From(expressions=[]))
-        from_clause = self._expression.args["from"]
+        if current_expr.args.get("from") is None:
+            current_expr.set("from", exp.From(expressions=[]))
+        from_clause = current_expr.args["from"]
         if hasattr(from_clause, "append"):
             from_clause.append("expressions", table_expr)
         else: