@@ -9,6 +9,10 @@
 from rhosocial.activerecord.backend.dialect.exceptions import UnsupportedFeatureError
 
 
+_SQL_SERVER_SPARSE_COLUMN_VERSION = (10, 0, 0)
+_SQL_SERVER_MASKED_COLUMN_VERSION = (13, 0, 0)
+
+
 class SQLServerAlterColumnModifierMixin:
     """SQL Server ALTER TABLE column modifiers.
 
@@ -57,4 +61,124 @@ def format_drop_table_constraint_action(self, action):
             result = f"DROP CONSTRAINT {name}"
         if getattr(action, "cascade", None):
             result += " CASCADE"
-        return result, ()
+        return result, ()
+
+    def format_alter_column_action(self, action):
+        """Dispatch an ALTER COLUMN action to a SQL Server-specific formatter.
+
+        SQL Server re-specifies the full column rather than applying the
+        standard SET/DROP subclauses. The ``operation`` value selects the
+        variant:
+
+        - ``SET DATA TYPE`` (or ``dialect_options["data_type"]``) renders the
+          T-SQL ``ALTER COLUMN col type [COLLATE ...] [NULL | NOT NULL] [SPARSE]``
+          form via ``format_alter_column_type_action``.
+        - ``ADD MASKED`` renders dynamic data masking via
+          ``format_add_masked_action``.
+        - ``DROP MASKED`` renders ``format_drop_masked_action``.
+        """
+        operation = action.operation
+        op_str = operation.value if hasattr(operation, "value") else str(operation)
+        dialect_options = getattr(action, "dialect_options", None) or {}
+
+        if op_str == "ADD MASKED" or "masked_function" in dialect_options:
+            return self.format_add_masked_action(action)
+        if op_str == "DROP MASKED" or dialect_options.get("drop_masked"):
+            return self.format_drop_masked_action(action)
+        if op_str == "SET DATA TYPE" or "data_type" in dialect_options:
+            return self.format_alter_column_type_action(action)
+
+        raise UnsupportedFeatureError(
+            self.name,
+            f"ALTER COLUMN {op_str}",
+            "SQL Server requires re-specifying the full column. Use "
+            "operation='SET DATA TYPE' with dialect_options to add "
+            "NULL/NOT NULL, COLLATE, SPARSE, or MASKED.",
+        )
+
+    def format_alter_column_type_action(self, action):
+        """Format a T-SQL ALTER COLUMN type change.
+
+        SQL Syntax:
+            ALTER COLUMN column data_type [COLLATE collation]
+            [NULL | NOT NULL] [SPARSE]
+
+        The data type comes from ``dialect_options["data_type"]`` or the
+        action's ``new_value``. ``not_null``, ``collate``, and ``sparse``
+        are carried in ``dialect_options``.
+        """
+        dialect_options = getattr(action, "dialect_options", None) or {}
+        data_type = dialect_options.get("data_type") or action.new_value
+        if data_type is None:
+            raise ValueError("data type is required for ALTER COLUMN")
+
+        parts = [
+            "ALTER COLUMN",
+            self.format_identifier(action.column_name),
+            str(data_type),
+        ]
+
+        collate = dialect_options.get("collate")
+        if collate:
+            parts.append(f"COLLATE {collate}")
+
+        not_null = dialect_options.get("not_null")
+        if not_null is not None:
+            parts.append("NOT NULL" if not_null else "NULL")
+
+        if dialect_options.get("sparse"):
+            if self.version < _SQL_SERVER_SPARSE_COLUMN_VERSION:  # type: ignore[attr-defined]
+                raise UnsupportedFeatureError(
+                    self.name,
+                    "SPARSE column",
+                    suggestion="requires SQL Server 2008+.",
+                )
+            parts.append("SPARSE")
+
+        return " ".join(parts), ()
+
+    def format_add_masked_action(self, action):
+        """Format ALTER COLUMN ... ADD MASKED (dynamic data masking, 2016+).
+
+        SQL Syntax:
+            ALTER COLUMN column ADD MASKED WITH (FUNCTION = 'mask_function')
+
+        The mask function is carried in ``dialect_options["masked_function"]``
+        or the action's ``new_value``.
+        """
+        if self.version < _SQL_SERVER_MASKED_COLUMN_VERSION:  # type: ignore[attr-defined]
+            raise UnsupportedFeatureError(
+                self.name,
+                "ADD MASKED (dynamic data masking)",
+                suggestion="requires SQL Server 2016+.",
+            )
+
+        dialect_options = getattr(action, "dialect_options", None) or {}
+        function = dialect_options.get("masked_function") or action.new_value
+        if function is None:
+            raise ValueError("masked_function is required for ADD MASKED")
+
+        escaped = str(function).replace("'", "''")
+        return (
+            f"ALTER COLUMN {self.format_identifier(action.column_name)} "
+            f"ADD MASKED WITH (FUNCTION = '{escaped}')",
+            (),
+        )
+
+    def format_drop_masked_action(self, action):
+        """Format ALTER COLUMN ... DROP MASKED (dynamic data masking, 2016+).
+
+        SQL Syntax:
+            ALTER COLUMN column DROP MASKED
+        """
+        if self.version < _SQL_SERVER_MASKED_COLUMN_VERSION:  # type: ignore[attr-defined]
+            raise UnsupportedFeatureError(
+                self.name,
+                "DROP MASKED (dynamic data masking)",
+                suggestion="requires SQL Server 2016+.",
+            )
+
+        return (
+            f"ALTER COLUMN {self.format_identifier(action.column_name)} DROP MASKED",
+            (),
+        )
@@ -102,6 +102,8 @@
 from .collation import validate_sqlserver_collation_name
 from .alter_table_modifier import SQLServerAlterColumnModifierMixin
 from .mixins.sequence import SQLServerSequenceMixin
+from .mixins.pivot import SQLServerPivotMixin
+from .mixins.columnstore import SQLServerColumnstoreIndexMixin
 from .mixins.protocol_support import SQLServerProtocolSupportMixin
 # SQLServerPartitionMixin is registered lazily in _register_partition_formatters()
 
@@ -178,6 +180,8 @@ class SQLServerDialect(
     SQLServerAlterColumnModifierMixin,  # Before DDLColumnMixin to override format_*_action
     SQLServerProtocolSupportMixin,  # SQL Server protocol contract implementations
     SQLServerSequenceMixin,  # NEXT VALUE FOR formatter (2012+)
+    SQLServerPivotMixin,  # PIVOT / UNPIVOT formatters (2005+)
+    SQLServerColumnstoreIndexMixin,  # columnstore index DDL (2012+/2014+/2022+)
     DDLColumnMixin,
     DDLTypeMixin,
     # Feature mixins
@@ -1689,6 +1693,20 @@ def format_top_n_clause(self, n: int, percentage: bool = False) -> str:
             return f"TOP {n} PERCENT"
         return f"TOP {n}"
 
+    def format_query_option_clause(self, clause) -> Tuple[str, tuple]:
+        """Format an OPTION query hint clause.
+
+        SQL Server exposes optimizer hints through the query-level OPTION
+        clause (available in all versions):
+
+            OPTION (hint1, hint2, ...)
+
+        The clause holds pre-rendered hint strings (see
+        ``expression.option_hint`` factories such as ``recompile_hint``,
+        ``maxdop_hint``, and ``optimize_for_hint``).
+        """
+        return f"OPTION ({', '.join(clause.hints)})", ()
+
 
 # Lazy import to avoid circular dependency (backend → dialect → mixins.types → backend)
 def _register_type_formatters():
 
@@ -6,6 +6,17 @@
 from .temporal import SQLServerTemporalPeriodDefinition, SQLServerSystemVersioningClause
 from .openjson import SQLServerOpenJsonExpression, OpenJsonColumn
 from .sequence import SQLServerNextValueForExpression
+from .option_hint import (
+    SQLServerOptionHintClause,
+    recompile_hint,
+    maxdop_hint,
+    optimize_for_hint,
+    hash_join_hint,
+    loop_join_hint,
+    merge_join_hint,
+)
+from .pivot import SQLServerPivotExpression, SQLServerUnpivotExpression
+from .columnstore import SQLServerColumnstoreIndexExpression
 from .functions import (
     SQLServerTryCastExpression,
     SQLServerTryConvertExpression,
@@ -24,6 +35,16 @@
     "SQLServerOpenJsonExpression",
     "OpenJsonColumn",
     "SQLServerNextValueForExpression",
+    "SQLServerOptionHintClause",
+    "recompile_hint",
+    "maxdop_hint",
+    "optimize_for_hint",
+    "hash_join_hint",
+    "loop_join_hint",
+    "merge_join_hint",
+    "SQLServerPivotExpression",
+    "SQLServerUnpivotExpression",
+    "SQLServerColumnstoreIndexExpression",
     "SQLServerTryCastExpression",
     "SQLServerTryConvertExpression",
     "SQLServerContainsPredicate",
 
@@ -0,0 +1,71 @@
+# src/rhosocial/activerecord/backend/impl/sqlserver/expression/columnstore.py
+"""SQL Server columnstore index DDL expression.
+
+Columnstore indexes are the analytic workload workhorse of SQL Server:
+
+    CREATE CLUSTERED COLUMNSTORE INDEX cci ON t;            -- 2014+, updatable
+    CREATE NONCLUSTERED COLUMNSTORE INDEX ncci ON t (c);    -- 2012+, read-only
+    CREATE COLUMNSTORE INDEX cci ON t ORDER (c1, c2);       -- 2022+, ordered CCI
+
+SQL generation and version gating are delegated to the dialect's
+``format_create_columnstore_index_statement`` formatter.
+"""
+
+from typing import Optional, Sequence, TYPE_CHECKING
+
+from rhosocial.activerecord.backend.expression.bases import BaseExpression, SQLQueryAndParams
+
+if TYPE_CHECKING:
+    from ..dialect import SQLServerDialect
+
+
+class SQLServerColumnstoreIndexExpression(BaseExpression):
+    """SQL Server CREATE [CLUSTERED|NONCLUSTERED] COLUMNSTORE INDEX statement.
+
+    Attributes:
+        index_name: Name of the columnstore index.
+        table_name: Table on which the index is created.
+        columns: Key columns. Required for NONCLUSTERED columnstore
+            (``clustered=False``), forbidden for clustered columnstore.
+        clustered: If ``None`` the CLUSTERED/NONCLUSTERED keyword is omitted
+            (defaults to a clustered columnstore); ``True`` renders
+            CLUSTERED, ``False`` renders NONCLUSTERED.
+        order_columns: Optional ORDER (...) columns for ordered clustered
+            columnstore (SQL Server 2022+).
+
+    Example:
+        >>> expr = SQLServerColumnstoreIndexExpression(
+        ...     dialect, "cci", "t", clustered=True, order_columns=["c1", "c2"]
+        ... )
+        >>> sql, params = expr.to_sql()
+        >>> assert sql == "CREATE CLUSTERED COLUMNSTORE INDEX [cci] ON [t] ORDER ([c1], [c2])"
+    """
+
+    def __init__(
+        self,
+        dialect: "SQLServerDialect",
+        index_name: str,
+        table_name: str,
+        columns: Sequence[str] = (),
+        clustered: Optional[bool] = None,
+        order_columns: Sequence[str] = (),
+    ):
+        super().__init__(dialect)
+        self.index_name = index_name
+        self.table_name = table_name
+        self.columns = list(columns)
+        self.clustered = clustered
+        self.order_columns = list(order_columns)
+
+    def validate(self, strict: bool = True) -> None:
+        if not strict:
+            return
+        if self.clustered is False and not self.columns:
+            raise ValueError("NONCLUSTERED columnstore requires key columns")
+        if self.clustered is not False and self.columns:
+            raise ValueError("clustered columnstore does not allow key columns")
+        if self.order_columns and self.clustered is False:
+            raise ValueError("ORDER (...) is only valid for clustered columnstore")
+
+    def to_sql(self) -> SQLQueryAndParams:
+        return self.dialect.format_create_columnstore_index_statement(self)
@@ -0,0 +1,94 @@
+# src/rhosocial/activerecord/backend/impl/sqlserver/expression/option_hint.py
+"""SQL Server OPTION query hint clause.
+
+SQL Server exposes optimizer hints through the query-level ``OPTION`` clause
+rather than comment-style hints:
+
+    SELECT ... OPTION (MAXDOP 4, RECOMPILE, OPTIMIZE FOR (@p = 10));
+
+This module defines ``SQLServerOptionHintClause`` together with factory
+helpers that produce the individual hint expressions. SQL generation is
+delegated to the dialect's ``format_query_option_clause`` formatter. The
+OPTION clause is available in every supported SQL Server version (2005+).
+"""
+
+from typing import Any, Sequence, Tuple, TYPE_CHECKING
+
+from rhosocial.activerecord.backend.expression.bases import BaseExpression, SQLQueryAndParams
+
+if TYPE_CHECKING:
+    from ..dialect import SQLServerDialect
+
+
+def recompile_hint() -> str:
+    """Return a RECOMPILE hint forcing a new plan for each execution."""
+    return "RECOMPILE"
+
+
+def maxdop_hint(degree: int) -> str:
+    """Return a MAXDOP hint limiting the degree of parallelism."""
+    return f"MAXDOP {degree}"
+
+
+def optimize_for_hint(pairs: Sequence[Tuple[str, Any]]) -> str:
+    """Return an OPTIMIZE FOR hint.
+
+    Args:
+        pairs: Sequence of ``(variable, value)`` tuples. A ``None`` value
+            renders the ``UNKNOWN`` literal, e.g.
+            ``[("@p", 10), ("@q", None)]`` renders
+            ``OPTIMIZE FOR (@p = 10, @q = UNKNOWN)``.
+    """
+    parts = []
+    for variable, value in pairs:
+        if value is None:
+            parts.append(f"{variable} = UNKNOWN")
+        else:
+            parts.append(f"{variable} = {value}")
+    return f"OPTIMIZE FOR ({', '.join(parts)})"
+
+
+def hash_join_hint() -> str:
+    """Return a HASH JOIN hint for the whole query."""
+    return "HASH JOIN"
+
+
+def loop_join_hint() -> str:
+    """Return a LOOP JOIN hint for the whole query."""
+    return "LOOP JOIN"
+
+
+def merge_join_hint() -> str:
+    """Return a MERGE JOIN hint for the whole query."""
+    return "MERGE JOIN"
+
+
+class SQLServerOptionHintClause(BaseExpression):
+    """SQL Server OPTION query hint clause.
+
+    Holds the individual hint expressions and delegates rendering to the
+    dialect's ``format_query_option_clause``.
+
+    Attributes:
+        hints: List of hint strings (see the module-level factories).
+
+    Example:
+        >>> clause = SQLServerOptionHintClause(
+        ...     dialect, [maxdop_hint(4), recompile_hint(), optimize_for_hint([("@p", 10)])]
+        ... )
+        >>> sql, params = clause.to_sql()
+        >>> assert sql == "OPTION (MAXDOP 4, RECOMPILE, OPTIMIZE FOR (@p = 10))"
+    """
+
+    def __init__(self, dialect: "SQLServerDialect", hints: Sequence[str]):
+        super().__init__(dialect)
+        self.hints = list(hints)
+
+    def validate(self, strict: bool = True) -> None:
+        if not strict:
+            return
+        if not self.hints:
+            raise ValueError("at least one query hint is required")
+
+    def to_sql(self) -> SQLQueryAndParams:
+        return self.dialect.format_query_option_clause(self)