Merge branch 'MicrosoftDocs:main' into create-vector-index-update-dm-20250708

Author: yorek

docs/includes/entra-id-tutorial.md

@@ -103,7 +103,7 @@ Or,
 
    1. For the **Method of certificate creation**, use **Generate**.
 
-   1. Add a certificate name and subject.
+   1. Add a certificate name and subject. The certificate name must be unique. A certificate name that matches an existing certificate causes an error when the login is created.
 
    1. The recommended validity period is at most 12 months. The rest of the values can be left as default.
 

docs/relational-databases/performance/optimized-locking.md

@@ -4,7 +4,7 @@ description: "Learn about the optimized locking enhancement to the database engi
 author: MikeRayMSFT
 ms.author: mikeray
 ms.reviewer: randolphwest, peskount, praspu, dfurman
-ms.date: 04/14/2025
+ms.date: 07/07/2025
 ms.service: sql
 ms.subservice: performance
 ms.topic: conceptual
@@ -235,6 +235,19 @@ LAQ is disabled for the database if the percentage of the potentially wasted wor
 
 If the wasted work and the number of restarted statements fall below their respective thresholds, LAQ is re-enabled for the database.
 
+#### LAQ limitations
+
+Lock after qualification might not be used in the following scenarios:
+
+- When disabled by [LAQ heuristics](#laq-heuristics).
+- When conflicting locking hints, such as `UPDLOCK`, `READCOMMITTEDLOCK`, `XLOCK`, or `HOLDLOCK` are used.
+- When the transaction isolation level is other than `READ COMMITTED`, or when the `READ_COMMITTED_SNAPSHOT` database option is disabled.
+- When the table being modified has a columnstore index.
+- When the DML statement includes variable assignment.
+- When the DML statement has an `OUTPUT` clause.
+- When the DML statement uses more than one index seek or scan operator to read the rows being modified.
+- In `MERGE` statements.
+
 ### <a id="behavior"></a> Query behavior changes with optimized locking and RCSI
 
 Concurrent workloads under read committed snapshot isolation (RCSI) that rely on strict execution order of transactions might experience differences in query behavior when optimized locking is enabled.
@@ -304,7 +317,7 @@ The following improvements help you monitor and troubleshoot blocking and deadlo
     - Under each resource in the deadlock report `<resource-list>`, each `<xactlock>` element reports the underlying resources and specific information for locks of each member of a deadlock. For more information and an example, see [Optimized locking and deadlocks](../sql-server-deadlocks-guide.md#optimized-locking-and-deadlocks).
 - Extended events
     - The `lock_after_qual_stmt_abort` event fires when a statement is internally aborted and restarted because of a conflict with another transaction. For more information, see [Lock after qualification (LAQ)](#lock-after-qualification-laq).
-    - In [!INCLUDE [sssql25-md](../../includes/sssql25-md.md)], the `locking_stats` event fires for every database every several minutes and provides aggregate locking statistics for the time interval, such as the number of lock escalations, whether TID locking and LAQ components of optimized locking are enabled, and the number of queries that were ineligible for LAQ for various reasons. This event fires even if optimized locking is disabled.
+    - In [!INCLUDE [sssql25-md](../../includes/sssql25-md.md)], the `locking_stats` event fires for every database every several minutes and provides aggregate locking statistics for the time interval, such as the number of lock escalations, whether TID locking and LAQ components of optimized locking are enabled, and the number of queries where LAQ wasn't used for various reasons. This event fires even if optimized locking is disabled.
 
 ## Best practices with optimized locking
 

docs/relational-databases/security/authentication-access/azure-ad-authentication-sql-server-setup-tutorial.md

@@ -15,4 +15,4 @@ monikerRange: ">=sql-server-ver16||>= sql-server-linux-ver16"
 
 [!INCLUDE [SQL Server 2022](../../../includes/applies-to-version/sqlserver2022.md)]
 
-[!INCLUDE [entra-id-tutorial](../../../includes/entra-id-tutorial.md)]
+[!INCLUDE [entra-id-tutorial](../../../includes/entra-id-tutorial.md)]

docs/relational-databases/statistics/statistics.md

@@ -4,7 +4,7 @@ description: The Query Optimizer uses statistics to create query plans that impr
 author: WilliamDAssafMSFT
 ms.author: wiassaf
 ms.reviewer: derekw, randolphwest
-ms.date: 12/17/2024
+ms.date: 07/07/2025
 ms.service: sql
 ms.subservice: performance
 ms.topic: conceptual
@@ -206,6 +206,8 @@ In [!INCLUDE [ssNoVersion](../../includes/ssnoversion-md.md)] prior to [!INCLUDE
 
 Starting with [!INCLUDE [sssql22-md](../../includes/sssql22-md.md)], the auto drop option is enabled by default on all new and migrated databases. The `AUTO_DROP` property allows the creation of statistics objects in a mode such that a subsequent schema change *isn't* blocked by the statistic object, but instead the statistics are dropped as necessary. In this way, manually created statistics with auto drop enabled behave like auto-created statistics.
 
+In [!INCLUDE [ssazure-sqldb](../../includes/ssazure-sqldb.md)], [!INCLUDE [ssazuremi-md](../../includes/ssazuremi-md.md)], and [!INCLUDE [sssql22-md](../../includes/sssql22-md.md)] and later versions, automatically created statistics always behave as though the [AUTO_DROP](../../relational-databases/statistics/statistics.md#auto_drop-option) has been set.
+
 > [!NOTE]  
 > Trying to set or unset the auto drop property on auto-created statistics can raise errors. Auto-created statistics always uses auto drop. Some backups, when restored, can have this property set incorrectly until the next time the statistics object is updated (manually or automatically). However, auto-created statistics always behave like auto drop statistics. When restoring a database to [!INCLUDE [sssql22-md](../../includes/sssql22-md.md)] from a previous version, it's recommended to execute `sp_updatestats` on the database, setting the proper metadata for the statistics auto drop feature.
 
@@ -261,8 +263,8 @@ The Query Optimizer already creates statistics in the following ways:
 
 1. The Query Optimizer creates statistics for indexes on tables or views when the index is created. These statistics are created on the key columns of the index. If the index is a filtered index, the Query Optimizer creates filtered statistics on the same subset of rows specified for the filtered index. For more information about filtered indexes, see [Create filtered indexes](../indexes/create-filtered-indexes.md) and [CREATE INDEX](../../t-sql/statements/create-index-transact-sql.md).
 
-    > [!NOTE]  
-    > Starting with [!INCLUDE [ssSQL14](../../includes/sssql14-md.md)], statistics aren't created by scanning all rows in the table when a partitioned index is created or rebuilt. Instead, the Query Optimizer uses the default sampling algorithm to generate statistics. After upgrading a database with partitioned indexes, you might notice a difference in the histogram data for these indexes. This change in behavior might not affect query performance. To obtain statistics on partitioned indexes by scanning all the rows in the table, use `CREATE STATISTICS` or `UPDATE STATISTICS` with the `FULLSCAN` clause.
+   > [!NOTE]  
+   > In [!INCLUDE [ssSQL14](../../includes/sssql14-md.md)] and later versions, statistics aren't created by scanning all rows in the table when a partitioned index is created or rebuilt. Instead, the Query Optimizer uses the default sampling algorithm to generate statistics. After upgrading a database with partitioned indexes, you might notice a difference in the histogram data for these indexes. This change in behavior might not affect query performance. To obtain statistics on partitioned indexes by scanning all the rows in the table, use `CREATE STATISTICS` or `UPDATE STATISTICS` with the `FULLSCAN` clause.
 
 1. The Query Optimizer creates statistics for single columns in query predicates when [AUTO_CREATE_STATISTICS](../../t-sql/statements/alter-database-transact-sql-set-options.md#auto_create_statistics) is on.
 
@@ -442,69 +444,69 @@ To improve the cardinality estimates for variables and functions, follow these g
 
 - If a stored procedure contains a query that uses a passed-in parameter, avoid changing the parameter value within the stored procedure before using it in the query. The cardinality estimates for the query are based on the passed-in parameter value and not the updated value. To avoid changing the parameter value, you can rewrite the query to use two stored procedures.
 
-    For example, the following stored procedure `Sales.GetRecentSales` changes the value of the parameter `@date` when `@date` is `NULL`.
-
-    ```sql
-    USE AdventureWorks2022;
-    GO
-
-    IF OBJECT_ID('Sales.GetRecentSales', 'P') IS NOT NULL
-        DROP PROCEDURE Sales.GetRecentSales;
-    GO
-
-    CREATE PROCEDURE Sales.GetRecentSales
-    @date DATETIME
-    AS
-    BEGIN
-        IF @date IS NULL
-            SET @date = DATEADD(MONTH, -3,
-                (SELECT MAX(ORDERDATE)
-                FROM Sales.SalesOrderHeader));
-        SELECT *
-        FROM Sales.SalesOrderHeader AS h, Sales.SalesOrderDetail AS d
-        WHERE h.SalesOrderID = d.SalesOrderID
-            AND h.OrderDate > @date;
-    END
-    GO
-    ```
-
-    If the first call to the stored procedure `Sales.GetRecentSales` passes a `NULL` for the `@date` parameter, the Query Optimizer compiles the stored procedure with the cardinality estimate for `@date = NULL` even though the query predicate isn't called with `@date = NULL`. This cardinality estimate might be significantly different than the number of rows in the actual query result. As a result, the Query Optimizer might choose a suboptimal query plan. To help avoid this, you can rewrite the stored procedure into two procedures as follows:
-
-    ```sql
-    USE AdventureWorks2022;
-    GO
-
-    IF OBJECT_ID('Sales.GetNullRecentSales', 'P') IS NOT NULL
-        DROP PROCEDURE Sales.GetNullRecentSales;
-    GO
-
-    CREATE PROCEDURE Sales.GetNullRecentSales
-    @date DATETIME
-    AS
-    BEGIN
-        IF @date IS NULL
-            SET @date = DATEADD(MONTH, -3,
-                (SELECT MAX(ORDERDATE)
-                FROM Sales.SalesOrderHeader));
-        EXECUTE Sales.GetNonNullRecentSales @date;
-    END
-    GO
-
-    IF OBJECT_ID('Sales.GetNonNullRecentSales', 'P') IS NOT NULL
-        DROP PROCEDURE Sales.GetNonNullRecentSales;
-    GO
-
-    CREATE PROCEDURE Sales.GetNonNullRecentSales
-    @date DATETIME
-    AS
-    BEGIN
-        SELECT *
-        FROM Sales.SalesOrderHeader AS h, Sales.SalesOrderDetail AS d
-        WHERE h.SalesOrderID = d.SalesOrderID
-            AND h.OrderDate > @date;
-    END
-    GO
-    ```
+  For example, the following stored procedure `Sales.GetRecentSales` changes the value of the parameter `@date` when `@date` is `NULL`.
+
+  ```sql
+  USE AdventureWorks2022;
+  GO
+
+  IF OBJECT_ID('Sales.GetRecentSales', 'P') IS NOT NULL
+      DROP PROCEDURE Sales.GetRecentSales;
+  GO
+
+  CREATE PROCEDURE Sales.GetRecentSales
+  @date DATETIME
+  AS
+  BEGIN
+      IF @date IS NULL
+          SET @date = DATEADD(MONTH, -3,
+              (SELECT MAX(ORDERDATE)
+              FROM Sales.SalesOrderHeader));
+      SELECT *
+      FROM Sales.SalesOrderHeader AS h, Sales.SalesOrderDetail AS d
+      WHERE h.SalesOrderID = d.SalesOrderID
+          AND h.OrderDate > @date;
+  END
+  GO
+  ```
+
+  If the first call to the stored procedure `Sales.GetRecentSales` passes a `NULL` for the `@date` parameter, the Query Optimizer compiles the stored procedure with the cardinality estimate for `@date = NULL` even though the query predicate isn't called with `@date = NULL`. This cardinality estimate might be significantly different than the number of rows in the actual query result. As a result, the Query Optimizer might choose a suboptimal query plan. To help avoid this, you can rewrite the stored procedure into two procedures as follows:
+
+  ```sql
+  USE AdventureWorks2022;
+  GO
+
+  IF OBJECT_ID('Sales.GetNullRecentSales', 'P') IS NOT NULL
+      DROP PROCEDURE Sales.GetNullRecentSales;
+  GO
+
+  CREATE PROCEDURE Sales.GetNullRecentSales
+  @date DATETIME
+  AS
+  BEGIN
+      IF @date IS NULL
+          SET @date = DATEADD(MONTH, -3,
+              (SELECT MAX(ORDERDATE)
+              FROM Sales.SalesOrderHeader));
+      EXECUTE Sales.GetNonNullRecentSales @date;
+  END
+  GO
+
+  IF OBJECT_ID('Sales.GetNonNullRecentSales', 'P') IS NOT NULL
+      DROP PROCEDURE Sales.GetNonNullRecentSales;
+  GO
+
+  CREATE PROCEDURE Sales.GetNonNullRecentSales
+  @date DATETIME
+  AS
+  BEGIN
+      SELECT *
+      FROM Sales.SalesOrderHeader AS h, Sales.SalesOrderDetail AS d
+      WHERE h.SalesOrderID = d.SalesOrderID
+          AND h.OrderDate > @date;
+  END
+  GO
+  ```
 
 <a id="improving-cardinality-estimates-with-query-hints"></a>