Added HAS_DBACCESS, enabled method-level test parallelism for the SqlClient wire suite.

Author: RyanLamansky

SqlServerSimulator.Tests.SqlClient/Properties/AssemblyInfo.cs

@@ -0,0 +1 @@
+[assembly: Parallelize(Scope = ExecutionScope.MethodLevel)]

SqlServerSimulator.Tests/DbIdNameTests.cs

@@ -60,4 +60,38 @@ public void DbName_NullArg_ReturnsNull()
     [TestMethod]
     public void DbId_DbName_RoundTrip()
         => AreEqual("simulated", new Simulation().ExecuteScalar("select db_name(db_id())"));
+
+    [TestMethod]
+    public void HasDbAccess_HostedDatabase_Returns1()
+        => AreEqual(1, new Simulation().ExecuteScalar("select has_dbaccess('master')"));
+
+    [TestMethod]
+    public void HasDbAccess_CaseInsensitive()
+        => AreEqual(1, new Simulation().ExecuteScalar("select has_dbaccess('SiMuLaTeD')"));
+
+    // SSMS probes msdb at connect to decide whether to surface Agent
+    // features; the simulator doesn't model msdb, so NULL — same as a real
+    // server where the login can't see it.
+    [TestMethod]
+    public void HasDbAccess_UnknownDatabase_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select has_dbaccess('msdb')"));
+
+    [TestMethod]
+    public void HasDbAccess_EmptyOrNullName_ReturnsNull()
+    {
+        var simulation = new Simulation();
+        AreEqual(DBNull.Value, simulation.ExecuteScalar("select has_dbaccess('')"));
+        AreEqual(DBNull.Value, simulation.ExecuteScalar("select has_dbaccess(null)"));
+    }
+
+    [TestMethod]
+    public void HasDbAccess_NoArgument_RaisesMsg174()
+    {
+        var ex = new Simulation().AssertSqlError("select has_dbaccess()", 174);
+        AreEqual("The has_dbaccess function requires 1 argument(s).", ex.Message);
+    }
+
+    [TestMethod]
+    public void HasDbAccess_VariableArgument_Resolves()
+        => AreEqual(1, new Simulation().ExecuteScalar("declare @n sysname = 'master' select has_dbaccess(@n)"));
 }

SqlServerSimulator/Parser/Expression.cs

@@ -759,6 +759,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "CONTEXT_INFO" => new ContextInfoFunction(context),
                 "DATEDIFF_BIG" => new DateDiff.Big(context),
                 "ERROR_NUMBER" => new ErrorNumberFunction(context),
+                "HAS_DBACCESS" => new HasDbAccess(context),
                 "PERCENT_RANK" => WindowExpression.ParsePercentRank(context),
                 "ROWCOUNT_BIG" => new RowCountBig(context),
                 "SWITCHOFFSET" => new SwitchOffset(context),

SqlServerSimulator/Parser/Expressions/DatabaseScalarFunctions.cs

@@ -120,3 +120,40 @@ public override SqlValue Run(RuntimeContext runtime)
 
     internal override string DebugDisplay() => this.idArg is null ? "DB_NAME()" : $"DB_NAME({this.idArg.DebugDisplay()})";
 }
+
+/// <summary>
+/// SQL <c>HAS_DBACCESS('name')</c>: 1 when the named database is hosted (the
+/// simulator has no per-login database-access model, so every hosted database
+/// is accessible), NULL for an unknown / empty / NULL name. Result type is
+/// <see cref="SqlType.Int32"/>. Probe-confirmed against SQL Server 2025
+/// (2026-07-15): 1 for every accessible database, name lookup is
+/// case-insensitive, and a missing argument raises Msg 174. SSMS calls
+/// <c>has_dbaccess('msdb')</c> at connect to decide whether to surface
+/// Agent features — msdb isn't modeled, so it gets NULL, same as a real
+/// server without msdb access.
+/// </summary>
+internal sealed class HasDbAccess : Expression
+{
+    private readonly Expression nameArg;
+
+    public HasDbAccess(ParserContext context)
+    {
+        if (context.Token is Tokens.Operator { Character: ')' })
+            throw SimulatedSqlException.FunctionRequiresNArguments("has_dbaccess", 1);
+        this.nameArg = Parse(context);
+        if (context.Token is not Tokens.Operator { Character: ')' })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+    }
+
+    public override SqlValue Run(RuntimeContext runtime)
+    {
+        var name = this.nameArg.Run(runtime);
+        return !name.IsNull && runtime.Batch.Connection.Simulation.Databases.ContainsKey(name.CoerceTo(SqlType.NVarchar).AsString)
+            ? SqlValue.FromInt32(1)
+            : SqlValue.Null(SqlType.Int32);
+    }
+
+    public override SqlType GetSqlType(BatchContext batch, Func<MultiPartName, SqlType> resolveColumnType) => SqlType.Int32;
+
+    internal override string DebugDisplay() => $"HAS_DBACCESS({this.nameArg.DebugDisplay()})";
+}

docs/claude/schemas.md

@@ -59,6 +59,8 @@ Database ids: **master is always `database_id` 1, and user databases take 5, 6,
 
 **`DB_ID([name])`** / **`DB_NAME([id])`** (`Parser/Expressions/DatabaseScalarFunctions.cs`): round-trip the connection's view of `Simulation.Databases` by name and id via `DbId.DatabasesWithIds` (master = 1, user databases from 5). Zero-arg `DB_ID()` returns the current database's id, zero-arg `DB_NAME()` returns its name. Unknown name / out-of-range id → NULL. NULL arg → NULL. Result types: `DB_ID` → `smallint`; `DB_NAME` → `sysname`.
 
+**`HAS_DBACCESS('name')`** (same file): int 1 when the named database is hosted — the simulator has no per-login database-access model, so hosted ⇒ accessible — NULL for unknown / empty / NULL names (case-insensitive lookup; missing argument → Msg 174). Probe-confirmed against SQL Server 2025 (2026-07-15). SSMS calls `has_dbaccess('msdb')` at connect to gate Agent features; unmodeled msdb gets NULL, reading as "no access", which is the honest answer.
+
 ## Three-part-name reach for metadata scalars
 
 Probe-confirmed against SQL Server 2025 (2026-05-23):