Actual fix

Author: markingmyname

docs/relational-databases/system-stored-procedures/sp-getapplock-transact-sql.md

@@ -4,7 +4,7 @@ description: sp_getapplock places a lock on an application resource.
 author: markingmyname
 ms.author: maghan
 ms.reviewer: randolphwest
-ms.date: 06/23/2025
+ms.date: 03/02/2026
 ms.service: sql
 ms.subservice: system-objects
 ms.topic: "reference"
@@ -20,7 +20,7 @@ dev_langs:
   - "TSQL"
 monikerRange: "=azuresqldb-current || >=sql-server-2016 || >=sql-server-linux-2017 || =azuresqldb-mi-current || =fabric-sqldb"
 ---
-# sp_getapplock (Transact-SQL)
+# sys.sp_getapplock (Transact-SQL)
 
 [!INCLUDE [SQL Server Azure SQL Database Azure SQL Managed Instance FabricSQLDB](../../includes/applies-to-version/sql-asdb-asdbmi-fabricsqldb.md)]
 
@@ -31,7 +31,7 @@ Places a lock on an application resource.
 ## Syntax
 
 ```syntaxsql
-sp_getapplock
+sys.sp_getapplock
     [ [ @Resource = ] N'Resource' ]
     , [ @LockMode = ] 'LockMode'
     [ , [ @LockOwner = ] 'LockOwner' ]
@@ -71,11 +71,11 @@ The owner of the lock, which is the *@LockOwner* value when the lock was request
 
 #### [ @LockTimeout = ] *LockTimeout*
 
-A lock time-out value in milliseconds. *@LockTimeout* is **int**, and the default value is the same as the value returned by `@@LOCK_TIMEOUT`. A value of `-1` (default) indicates no time-out period (that is, wait forever). To indicate that a lock request should return a return code of `-1` instead of waiting for the lock when the request can't be granted immediately, specify `0`.
+A lock timeout value in milliseconds. *@LockTimeout* is **int**, and the default value is the same as the value returned by `@@LOCK_TIMEOUT`. A value of `-1` (default) indicates no timeout period (that is, wait forever). To indicate that a lock request should return a return code of `-1` instead of waiting for the lock when the request can't be granted immediately, specify `0`.
 
 #### [ @DbPrincipal = ] N'*DbPrincipal*'
 
-The user, role, or application role that's permissions to an object in a database. *@DbPrincipal* is **sysname**, with a default of `public`. The caller of the function must be a member of **database_principal**, **dbo**, or the **db_owner** fixed database role to call the function successfully. The default is **public**.
+The user, role, or application role that has permissions to an object in a database. *@DbPrincipal* is **sysname**, with a default of `public`. The caller of the function must be a member of **database_principal**, **dbo**, or the **db_owner** fixed database role to call the function successfully.
 
 ## Return code values
 
@@ -100,16 +100,16 @@ The lock resource created by `sp_getapplock` is created in the current database
 - The database principal specified in the *@DbPrincipal* parameter.
 - The lock name specified in the @Resource parameter.
 
-Only a member of the database principal specified in the *@DbPrincipal* parameter can acquire application locks that specify that principal. Members of the **dbo** and **db_owner** roles are implicitly considered members of all roles.
+Only a member of the database principal specified in the *@DbPrincipal* parameter can acquire application locks that specify that principal. Members of the **dbo** and **db_owner** fixed database roles are implicitly considered members of all roles.
 
 Locks can be explicitly released with `sp_releaseapplock`. When an application calls `sp_getapplock` multiple times for the same lock resource, `sp_releaseapplock` must be called the same number of times to release the lock. When a lock is opened with the `Transaction` lock owner, that lock is released when the transaction is committed or rolled back.
 
-If `sp_getapplock` is called multiple times for the same lock resource, but the lock mode that is specified in any of the requests isn't the same as the existing mode, the effect on the resource is a union of the two lock modes. In most cases, this means the lock mode is promoted to the stronger of the lock modes, the existing mode, or the newly requested mode. This stronger lock mode is held until the lock is ultimately released even if lock release calls occur before that time.
+If `sp_getapplock` is called multiple times for the same lock resource, but the lock mode that is specified in any of the requests isn't the same as the existing mode, the effect on the resource is a union of the two lock modes. In most cases, the lock mode is promoted to the stronger of the lock modes, the existing mode, or the newly requested mode. This stronger lock mode is held until the lock is ultimately released even if lock release calls occur before that time.
 
 For example, in the following sequence of calls, the resource is held in `Exclusive` mode instead of in `Shared` mode.
 
 ```sql
-USE AdventureWorks2022;
+USE AdventureWorks2025;
 GO
 
 BEGIN TRANSACTION;
@@ -139,7 +139,7 @@ A deadlock with an application lock doesn't roll back the transaction that reque
 Here's an example:
 
 ```sql
-USE AdventureWorks2022;
+USE AdventureWorks2025;
 GO
 
 BEGIN TRANSACTION;
@@ -171,14 +171,14 @@ Use the `sys.dm_tran_locks` dynamic management view or the `sp_lock` system stor
 
 ## Permissions
 
-Requires membership in the **public** role.
+Requires membership in the **public** fixed database role.
 
 ## Examples
 
 The following example places a shared lock, which is associated with the current transaction, on the resource `Form1` in the [!INCLUDE [sssampledbobject-md](../../includes/sssampledbobject-md.md)] database.
 
 ```sql
-USE AdventureWorks2022;
+USE AdventureWorks2025;
 GO
 
 BEGIN TRANSACTION;
@@ -201,7 +201,7 @@ BEGIN TRANSACTION;
 
 EXECUTE sp_getapplock
     @DbPrincipal = 'dbo',
-    @Resource = 'AdventureWorks2022',
+    @Resource = 'AdventureWorks2025',
     @LockMode = 'Shared';
 
 COMMIT TRANSACTION;
@@ -213,4 +213,3 @@ GO
 - [APPLOCK_MODE (Transact-SQL)](../../t-sql/functions/applock-mode-transact-sql.md)
 - [APPLOCK_TEST (Transact-SQL)](../../t-sql/functions/applock-test-transact-sql.md)
 - [sp_releaseapplock (Transact-SQL)](sp-releaseapplock-transact-sql.md)
-