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

sqlspec/builder/mixins/_merge_operations.py

@@ -1,3 +1,4 @@
+# pyright: reportPrivateUsage=false
 """MERGE operation mixins.
 
 Provides mixins for MERGE statement functionality including INTO,
@@ -10,6 +11,7 @@ from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
+from sqlspec.builder._parsing_utils import extract_sql_object_expression
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.utils.type_guards import has_query_builder_parameters
 
@@ -28,7 +30,9 @@ class MergeIntoClauseMixin:
     """Mixin providing INTO clause for MERGE builders."""
 
     __slots__ = ()
-    _expression: Optional[exp.Expression]
+
+    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,13 @@ 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()
+
+        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,13 +60,20 @@ class MergeUsingClauseMixin:
     """Mixin providing USING clause for MERGE builders."""
 
     __slots__ = ()
-    _expression: Optional[exp.Expression]
+
+    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."""
         msg = "Method must be provided by QueryBuilder subclass"
         raise NotImplementedError(msg)
 
+    def _generate_unique_parameter_name(self, base_name: str) -> str:
+        """Generate unique parameter name - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
     def using(self, source: Union[str, exp.Expression, Any], alias: Optional[str] = None) -> Self:
         """Set the source data for the MERGE operation (USING clause).
 
@@ -75,14 +88,40 @@ 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()
 
+        assert current_expr is not None
         source_expr: exp.Expression
         if isinstance(source, str):
             source_expr = exp.to_table(source, alias=alias)
+        elif isinstance(source, dict):
+            columns = list(source.keys())
+            values = list(source.values())
+
+            parameterized_values: list[exp.Expression] = []
+            for col, val in zip(columns, values):
+                column_name = col if isinstance(col, str) else str(col)
+                if "." in column_name:
+                    column_name = column_name.split(".")[-1]
+                param_name = self._generate_unique_parameter_name(column_name)
+                _, param_name = self.add_parameter(val, name=param_name)
+                parameterized_values.append(exp.Placeholder(this=param_name))
+
+            select_expr = exp.Select()
+            select_expressions = []
+            for i, col in enumerate(columns):
+                select_expressions.append(exp.alias_(parameterized_values[i], col))
+            select_expr.set("expressions", select_expressions)
+
+            from_expr = exp.From(this=exp.to_table("DUAL"))
+            select_expr.set("from", from_expr)
+
+            source_expr = exp.paren(select_expr)
+            if alias:
+                source_expr = exp.alias_(source_expr, alias, table=False)
         elif has_query_builder_parameters(source) and hasattr(source, "_expression"):
             subquery_builder_parameters = source.parameters
             if subquery_builder_parameters:
@@ -99,7 +138,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 +147,9 @@ class MergeOnClauseMixin:
     """Mixin providing ON clause for MERGE builders."""
 
     __slots__ = ()
-    _expression: Optional[exp.Expression]
+
+    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 +164,12 @@ 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()
 
+        assert current_expr is not None
         condition_expr: exp.Expression
         if isinstance(condition, str):
             parsed_condition: Optional[exp.Expression] = exp.maybe_parse(
@@ -143,7 +185,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 +194,9 @@ class MergeMatchedClauseMixin:
     """Mixin providing WHEN MATCHED THEN ... clauses for MERGE builders."""
 
     __slots__ = ()
-    _expression: Optional[exp.Expression]
+
+    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."""
@@ -164,21 +208,58 @@ class MergeMatchedClauseMixin:
         msg = "Method must be provided by QueryBuilder subclass"
         raise NotImplementedError(msg)
 
+    def _is_column_reference(self, value: str) -> bool:
+        """Check if a string value is a column reference rather than a literal.
+
+        Uses sqlglot to parse the value and determine if it represents a column
+        reference, function call, or other SQL expression rather than a literal.
+        """
+        if not isinstance(value, str):
+            return False
+
+        # If the string contains spaces and no SQL-like syntax, treat as literal
+        if " " in value and not any(x in value for x in [".", "(", ")", "*", "="]):
+            return False
+
+        # Only consider strings with dots (table.column), functions, or SQL keywords as column references
+        # Simple identifiers are treated as literals
+        if not any(x in value for x in [".", "(", ")"]):
+            # Check if it's a SQL keyword/function that should be treated as expression
+            sql_keywords = {"NULL", "CURRENT_TIMESTAMP", "CURRENT_DATE", "CURRENT_TIME", "DEFAULT"}
+            if value.upper() not in sql_keywords:
+                return False
+
+        try:
+            # Try to parse as SQL expression
+            parsed: Optional[exp.Expression] = exp.maybe_parse(value)
+            if parsed is None:
+                return False
+
+            # Check for SQL literals that should be treated as expressions
+            return isinstance(
+                parsed,
+                (exp.Dot, exp.Anonymous, exp.Func, exp.Null, exp.CurrentTimestamp, exp.CurrentDate, exp.CurrentTime),
+            )
+        except Exception:
+            # If parsing fails, treat as literal
+            return False
+
     def _add_when_clause(self, when_clause: exp.When) -> None:
         """Helper to add a WHEN clause to the MERGE statement.
 
         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]
+        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()
 
-        whens = self._expression.args.get("whens")
+        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)
 
@@ -208,7 +289,11 @@ class MergeMatchedClauseMixin:
             The current builder instance for method chaining.
         """
         # Combine set_values dict and kwargs
-        all_values = dict(set_values or {}, **kwargs)
+        all_values = {}
+        if set_values:
+            all_values.update(set_values)
+        if kwargs:
+            all_values.update(kwargs)
 
         if not all_values:
             msg = "No update values provided. Use set_values dict or kwargs."
@@ -217,35 +302,17 @@ class MergeMatchedClauseMixin:
         update_expressions: list[exp.EQ] = []
         for col, val in all_values.items():
             if hasattr(val, "expression") and hasattr(val, "sql"):
-                # Handle SQL objects (from sql.raw with parameters)
-                expression = getattr(val, "expression", None)
-                if expression is not None and isinstance(expression, exp.Expression):
-                    # Merge parameters from SQL object into builder
-                    if hasattr(val, "parameters"):
-                        sql_parameters = getattr(val, "parameters", {})
-                        for param_name, param_value in sql_parameters.items():
-                            self.add_parameter(param_value, name=param_name)
-                    value_expr = expression
-                else:
-                    # If expression is None, fall back to parsing the raw SQL
-                    sql_text = getattr(val, "sql", "")
-                    # Merge parameters even when parsing raw SQL
-                    if hasattr(val, "parameters"):
-                        sql_parameters = getattr(val, "parameters", {})
-                        for param_name, param_value in sql_parameters.items():
-                            self.add_parameter(param_value, name=param_name)
-                    # Check if sql_text is callable (like Expression.sql method)
-                    if callable(sql_text):
-                        sql_text = str(val)
-                    value_expr = exp.maybe_parse(sql_text) or exp.convert(str(sql_text))
+                value_expr = extract_sql_object_expression(val, builder=self)
             elif isinstance(val, exp.Expression):
                 value_expr = val
+            elif isinstance(val, str) and self._is_column_reference(val):
+                value_expr = exp.maybe_parse(val) or exp.column(val)
             else:
                 column_name = col if isinstance(col, str) else str(col)
                 if "." in column_name:
                     column_name = column_name.split(".")[-1]
                 param_name = self._generate_unique_parameter_name(column_name)
-                param_name = self.add_parameter(val, name=param_name)[1]
+                _, param_name = self.add_parameter(val, name=param_name)
                 value_expr = exp.Placeholder(this=param_name)
 
             update_expressions.append(exp.EQ(this=exp.column(col), expression=value_expr))
@@ -315,7 +382,8 @@ class MergeNotMatchedClauseMixin:
 
     __slots__ = ()
 
-    _expression: Optional[exp.Expression]
+    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."""
@@ -327,6 +395,54 @@ class MergeNotMatchedClauseMixin:
         msg = "Method must be provided by QueryBuilder subclass"
         raise NotImplementedError(msg)
 
+    def _is_column_reference(self, value: str) -> bool:
+        """Check if a string value is a column reference rather than a literal.
+
+        Uses sqlglot to parse the value and determine if it represents a column
+        reference, function call, or other SQL expression rather than a literal.
+        """
+        if not isinstance(value, str):
+            return False
+
+        # If the string contains spaces and no SQL-like syntax, treat as literal
+        if " " in value and not any(x in value for x in [".", "(", ")", "*", "="]):
+            return False
+
+        try:
+            # Try to parse as SQL expression
+            parsed: Optional[exp.Expression] = exp.maybe_parse(value)
+            if parsed is None:
+                return False
+
+            # If it parses to a Column, Dot (table.column), Identifier, or other SQL constructs
+
+        except Exception:
+            # If parsing fails, fall back to conservative approach
+            # Only treat simple identifiers as column references
+            return (
+                value.replace("_", "").replace(".", "").isalnum()
+                and (value[0].isalpha() or value[0] == "_")
+                and " " not in value
+                and "'" not in value
+                and '"' not in value
+            )
+        return bool(
+            isinstance(
+                parsed,
+                (
+                    exp.Column,
+                    exp.Dot,
+                    exp.Identifier,
+                    exp.Anonymous,
+                    exp.Func,
+                    exp.Null,
+                    exp.CurrentTimestamp,
+                    exp.CurrentDate,
+                    exp.CurrentTime,
+                ),
+            )
+        )
+
     def _add_when_clause(self, when_clause: exp.When) -> None:
         """Helper to add a WHEN clause to the MERGE statement - provided by QueryBuilder."""
         msg = "Method must be provided by QueryBuilder subclass"
@@ -364,12 +480,16 @@ class MergeNotMatchedClauseMixin:
 
             parameterized_values: list[exp.Expression] = []
             for i, val in enumerate(values):
-                column_name = columns[i] if isinstance(columns[i], str) else str(columns[i])
-                if "." in column_name:
-                    column_name = column_name.split(".")[-1]
-                param_name = self._generate_unique_parameter_name(column_name)
-                param_name = self.add_parameter(val, name=param_name)[1]
-                parameterized_values.append(exp.Placeholder())
+                if isinstance(val, str) and self._is_column_reference(val):
+                    # Handle column references (like "s.data") as column expressions, not parameters
+                    parameterized_values.append(exp.maybe_parse(val) or exp.column(val))
+                else:
+                    column_name = columns[i] if isinstance(columns[i], str) else str(columns[i])
+                    if "." in column_name:
+                        column_name = column_name.split(".")[-1]
+                    param_name = self._generate_unique_parameter_name(column_name)
+                    _, param_name = self.add_parameter(val, name=param_name)
+                    parameterized_values.append(exp.Placeholder(this=param_name))
 
             insert_args["this"] = exp.Tuple(expressions=[exp.column(c) for c in columns])
             insert_args["expression"] = exp.Tuple(expressions=parameterized_values)
@@ -415,7 +535,8 @@ class MergeNotMatchedBySourceClauseMixin:
 
     __slots__ = ()
 
-    _expression: Optional[exp.Expression]
+    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."""
@@ -432,6 +553,35 @@ class MergeNotMatchedBySourceClauseMixin:
         msg = "Method must be provided by QueryBuilder subclass"
         raise NotImplementedError(msg)
 
+    def _is_column_reference(self, value: str) -> bool:
+        """Check if a string value is a column reference rather than a literal.
+
+        Uses sqlglot to parse the value and determine if it represents a column
+        reference, function call, or other SQL expression rather than a literal.
+
+        Args:
+            value: The string value to check
+
+        Returns:
+            True if the value is a column reference, False if it's a literal
+        """
+        if not isinstance(value, str):
+            return False
+
+        try:
+            parsed: Optional[exp.Expression] = exp.maybe_parse(value)
+            if parsed is None:
+                return False
+
+        except Exception:
+            return False
+        return bool(
+            isinstance(
+                parsed,
+                (exp.Dot, exp.Anonymous, exp.Func, exp.Null, exp.CurrentTimestamp, exp.CurrentDate, exp.CurrentTime),
+            )
+        )
+
     def when_not_matched_by_source_then_update(
         self,
         set_values: Optional[dict[str, Any]] = None,
@@ -468,35 +618,17 @@ class MergeNotMatchedBySourceClauseMixin:
         update_expressions: list[exp.EQ] = []
         for col, val in all_values.items():
             if hasattr(val, "expression") and hasattr(val, "sql"):
-                # Handle SQL objects (from sql.raw with parameters)
-                expression = getattr(val, "expression", None)
-                if expression is not None and isinstance(expression, exp.Expression):
-                    # Merge parameters from SQL object into builder
-                    if hasattr(val, "parameters"):
-                        sql_parameters = getattr(val, "parameters", {})
-                        for param_name, param_value in sql_parameters.items():
-                            self.add_parameter(param_value, name=param_name)
-                    value_expr = expression
-                else:
-                    # If expression is None, fall back to parsing the raw SQL
-                    sql_text = getattr(val, "sql", "")
-                    # Merge parameters even when parsing raw SQL
-                    if hasattr(val, "parameters"):
-                        sql_parameters = getattr(val, "parameters", {})
-                        for param_name, param_value in sql_parameters.items():
-                            self.add_parameter(param_value, name=param_name)
-                    # Check if sql_text is callable (like Expression.sql method)
-                    if callable(sql_text):
-                        sql_text = str(val)
-                    value_expr = exp.maybe_parse(sql_text) or exp.convert(str(sql_text))
+                value_expr = extract_sql_object_expression(val, builder=self)
             elif isinstance(val, exp.Expression):
                 value_expr = val
+            elif isinstance(val, str) and self._is_column_reference(val):
+                value_expr = exp.maybe_parse(val) or exp.column(val)
             else:
                 column_name = col if isinstance(col, str) else str(col)
                 if "." in column_name:
                     column_name = column_name.split(".")[-1]
                 param_name = self._generate_unique_parameter_name(column_name)
-                param_name = self.add_parameter(val, name=param_name)[1]
+                _, param_name = self.add_parameter(val, name=param_name)
                 value_expr = exp.Placeholder(this=param_name)
 
             update_expressions.append(exp.EQ(this=exp.column(col), expression=value_expr))

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
@@ -10,7 +11,7 @@ from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
-from sqlspec.builder._parsing_utils import parse_order_expression
+from sqlspec.builder._parsing_utils import extract_expression, parse_order_expression
 from sqlspec.exceptions import SQLBuilderError
 
 if TYPE_CHECKING:
@@ -28,7 +29,6 @@ class OrderByClauseMixin:
 
     __slots__ = ()
 
-    # Type annotation for PyRight - this will be provided by the base class
     _expression: Optional[exp.Expression]
 
     def order_by(self, *items: Union[str, exp.Ordered, "Column"], desc: bool = False) -> Self:
@@ -57,9 +57,7 @@ class OrderByClauseMixin:
                     order_item = order_item.desc()
             else:
                 # Extract expression from Column objects or use as-is for sqlglot expressions
-                from sqlspec._sql import SQLFactory
-
-                extracted_item = SQLFactory._extract_expression(item)
+                extracted_item = extract_expression(item)
                 order_item = extracted_item
                 if desc and not isinstance(item, exp.Ordered):
                     order_item = order_item.desc()
@@ -74,7 +72,6 @@ class LimitOffsetClauseMixin:
 
     __slots__ = ()
 
-    # Type annotation for PyRight - this will be provided by the base class
     _expression: Optional[exp.Expression]
 
     def limit(self, value: int) -> Self:
@@ -121,7 +118,6 @@ class ReturningClauseMixin:
     """Mixin providing RETURNING clause."""
 
     __slots__ = ()
-    # Type annotation for PyRight - this will be provided by the base class
     _expression: Optional[exp.Expression]
 
     def returning(self, *columns: Union[str, exp.Expression, "Column", "ExpressionWrapper", "Case"]) -> Self:
@@ -144,8 +140,6 @@ class ReturningClauseMixin:
             msg = "RETURNING is only supported for INSERT, UPDATE, and DELETE statements."
             raise SQLBuilderError(msg)
         # Extract expressions from various wrapper types
-        from sqlspec._sql import SQLFactory
-
-        returning_exprs = [SQLFactory._extract_expression(c) for c in columns]
+        returning_exprs = [extract_expression(c) for c in columns]
         self._expression.set("returning", exp.Returning(expressions=returning_exprs))
         return self

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,
@@ -10,7 +11,7 @@ from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
-from sqlspec.builder._parsing_utils import parse_column_expression, parse_table_expression
+from sqlspec.builder._parsing_utils import parse_column_expression, parse_table_expression, to_expression
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.utils.type_guards import has_query_builder_parameters, is_expression
 
@@ -28,8 +29,8 @@ class SelectClauseMixin:
 
     __slots__ = ()
 
-    # Type annotation for PyRight - this will be provided by the base class
-    _expression: Optional[exp.Expression]
+    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 +42,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 +134,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 +485,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 +533,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":
@@ -855,12 +864,9 @@ class Case:
         Returns:
             Self for method chaining.
         """
-        from sqlspec._sql import SQLFactory
-
         cond_expr = exp.maybe_parse(condition) or exp.column(condition) if isinstance(condition, str) else condition
-        val_expr = SQLFactory._to_expression(value)
+        val_expr = to_expression(value)
 
-        # SQLGlot uses exp.If for CASE WHEN clauses, not exp.When
         when_clause = exp.If(this=cond_expr, true=val_expr)
         self._conditions.append(when_clause)
         return self
@@ -874,9 +880,7 @@ class Case:
         Returns:
             Self for method chaining.
         """
-        from sqlspec._sql import SQLFactory
-
-        self._default = SQLFactory._to_expression(value)
+        self._default = to_expression(value)
         return self
 
     def end(self) -> Self:
@@ -906,3 +910,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