CREATE SCHEMA + schema-qualified resolution: Database gains a Schemas dict (pre-seeded with dbo) routed via BatchContext.ParseObjectName / TryResolveTable / TryResolveSchema; every table-lookup site (Selection FROM, Insert/Update/Delete/Merge, Drop, Truncate, Create, SelectInto, SET IDENTITY_INSERT, IDENT_CURRENT) consumes the unified pair. Msg 2714 on duplicate, Msg 2760 on reserved-name (dbo/sys/INFORMATION_SCHEMA) and missing-schema CREATE TABLE; Msg 208 / 3701 carry the qualified name with proper single-quoting (also fixed missing quotes in pre-existing Msg 208 wording); Msg 4701 leaf-only quirk preserved. AUTHORIZATION clause and embedded schema_element form raise NotSupportedException — trailing statement-start tokens parse as separate statements (matches the common idiom).

Author: RyanLamansky

CLAUDE.md

@@ -0,0 +1,281 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for <c>CREATE SCHEMA</c> + schema-qualified table access. Schemas
+/// live in <see cref="Database.Schemas"/>; unqualified references resolve
+/// through the default <c>dbo</c> entry; two-part <c>schema.table</c> and
+/// three-part <c>db.schema.table</c> route through the named schema. Probed
+/// against SQL Server 2025 (2026-05-11).
+/// </summary>
+[TestClass]
+public sealed class CreateSchemaTests
+{
+    [TestMethod]
+    public void CreateSchema_BareForm_Succeeds()
+        => AreEqual(1, new Simulation().ExecuteScalar("""
+            create schema audit;
+            create table audit.t (id int);
+            insert audit.t values (1);
+            select count(*) from audit.t
+            """));
+
+    [TestMethod]
+    public void CreateSchema_Duplicate_Msg2714()
+        => new Simulation().AssertSqlError(
+            "create schema audit; create schema audit",
+            2714,
+            "There is already an object named 'audit' in the database.");
+
+    [TestMethod]
+    public void CreateSchema_DuplicateCaseInsensitive_Msg2714()
+        => new Simulation().AssertSqlError(
+            "create schema audit; create schema AUDIT",
+            2714);
+
+    [TestMethod]
+    public void CreateSchema_Dbo_Msg2760()
+        => new Simulation().AssertSqlError(
+            "create schema dbo",
+            2760,
+            "The specified schema name \"dbo\" either does not exist or you do not have permission to use it.");
+
+    [TestMethod]
+    public void CreateSchema_Sys_Msg2760()
+        => new Simulation().AssertSqlError("create schema sys", 2760);
+
+    [TestMethod]
+    public void CreateSchema_InformationSchema_Msg2760()
+        => new Simulation().AssertSqlError("create schema INFORMATION_SCHEMA", 2760);
+
+    [TestMethod]
+    public void CreateSchema_Authorization_NotSupported()
+        => Throws<NotSupportedException>(() =>
+            new Simulation().ExecuteNonQuery("create schema audit authorization dbo"));
+
+    /// <summary>
+    /// Real SQL Server treats trailing tokens after <c>CREATE SCHEMA</c> as
+    /// the <c>&lt;schema_element&gt;</c> list (inline CREATE TABLE / VIEW /
+    /// GRANT) — the simulator doesn't implement schema_element grammar, but
+    /// trailing statement-starting keywords parse as the next statement in the
+    /// batch (CREATE / SELECT / INSERT / etc. are statement boundaries that
+    /// the dispatch loop picks up cleanly). Net effect is the same as the
+    /// common idiom; only the AUTHORIZATION clause and unusual non-boundary
+    /// trailers raise <see cref="NotSupportedException"/>.
+    /// </summary>
+    [TestMethod]
+    public void CreateSchema_FollowedByCreateTable_DispatchesAsTwoStatements()
+        => AreEqual(1, new Simulation().ExecuteScalar("""
+            create schema audit
+            create table audit.t (id int)
+            insert audit.t values (1);
+            select count(*) from audit.t
+            """));
+
+    [TestMethod]
+    public void TwoPartName_Select_Works()
+        => AreEqual(42, new Simulation().ExecuteScalar("""
+            create schema audit;
+            create table audit.t (id int);
+            insert audit.t values (42);
+            select id from audit.t
+            """));
+
+    [TestMethod]
+    public void TwoPartName_Insert_Works()
+        => AreEqual(2, new Simulation().ExecuteScalar("""
+            create schema audit;
+            create table audit.t (id int);
+            insert audit.t values (1);
+            insert into audit.t values (2);
+            select max(id) from audit.t
+            """));
+
+    [TestMethod]
+    public void TwoPartName_Update_Works()
+        => AreEqual(99, new Simulation().ExecuteScalar("""
+            create schema audit;
+            create table audit.t (id int);
+            insert audit.t values (1);
+            update audit.t set id = 99;
+            select id from audit.t
+            """));
+
+    [TestMethod]
+    public void TwoPartName_Delete_Works()
+        => AreEqual(0, new Simulation().ExecuteScalar("""
+            create schema audit;
+            create table audit.t (id int);
+            insert audit.t values (1), (2), (3);
+            delete from audit.t;
+            select count(*) from audit.t
+            """));
+
+    [TestMethod]
+    public void TwoPartName_DropTable_Works()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = """
+            create schema audit;
+            create table audit.t (id int);
+            drop table audit.t
+            """;
+        _ = cmd.ExecuteNonQuery();
+        cmd.CommandText = "create table audit.t (id int)";
+        _ = cmd.ExecuteNonQuery();
+    }
+
+    [TestMethod]
+    public void TwoPartName_Truncate_Works()
+        => AreEqual(0, new Simulation().ExecuteScalar("""
+            create schema audit;
+            create table audit.t (id int);
+            insert audit.t values (1), (2);
+            truncate table audit.t;
+            select count(*) from audit.t
+            """));
+
+    [TestMethod]
+    public void TwoPartName_SelectInto_Works()
+        => AreEqual(3, new Simulation().ExecuteScalar("""
+            create schema staging;
+            create table dbo.src (id int);
+            insert dbo.src values (1), (2), (3);
+            select * into staging.dest from dbo.src;
+            select count(*) from staging.dest
+            """));
+
+    [TestMethod]
+    public void ThreePartName_CorrectDatabase_Works()
+        => AreEqual(7, new Simulation().ExecuteScalar("""
+            create schema audit;
+            create table audit.t (id int);
+            insert audit.t values (7);
+            select id from simulated.audit.t
+            """));
+
+    [TestMethod]
+    public void ThreePartName_WrongDatabase_Msg208()
+        => new Simulation().AssertSqlError("""
+            create schema audit;
+            create table audit.t (id int);
+            select * from baddb.audit.t
+            """, 208);
+
+    [TestMethod]
+    public void SchemaDoesNotExist_Select_Msg208()
+        => new Simulation().AssertSqlError(
+            "select * from badschema.t",
+            208,
+            "Invalid object name 'badschema.t'.");
+
+    [TestMethod]
+    public void SchemaDoesNotExist_CreateTable_Msg2760()
+        => new Simulation().AssertSqlError(
+            "create table badschema.t (id int)",
+            2760,
+            "The specified schema name \"badschema\" either does not exist or you do not have permission to use it.");
+
+    [TestMethod]
+    public void SchemaDoesNotExist_Insert_Msg208()
+        => new Simulation().AssertSqlError(
+            "insert badschema.t values (1)",
+            208);
+
+    [TestMethod]
+    public void SchemaDoesNotExist_DropTable_Msg3701()
+        => new Simulation().AssertSqlError(
+            "drop table badschema.t",
+            3701,
+            "Cannot drop the table 'badschema.t', because it does not exist or you do not have permission.");
+
+    [TestMethod]
+    public void SchemaDoesNotExist_DropTableIfExists_NoError()
+        => _ = new Simulation().ExecuteNonQuery("drop table if exists badschema.t");
+
+    /// <summary>
+    /// Probe-confirmed: Msg 4701 carries only the leaf in the message,
+    /// unlike Msg 208 / 3701 which embed the full qualified name.
+    /// </summary>
+    [TestMethod]
+    public void SchemaDoesNotExist_Truncate_Msg4701_LeafNameOnly()
+        => new Simulation().AssertSqlError(
+            "truncate table badschema.t",
+            4701,
+            "Cannot find the object \"t\" because it does not exist or you do not have permissions.");
+
+    [TestMethod]
+    public void SchemaExistsTableDoesNot_Select_Msg208()
+        => new Simulation().AssertSqlError("""
+            create schema audit;
+            select * from audit.nope
+            """, 208, "Invalid object name 'audit.nope'.");
+
+    [TestMethod]
+    public void IsolatedSchemas_SameTableName()
+    {
+        using var reader = new Simulation().ExecuteReader("""
+            create schema audit;
+            create schema staging;
+            create table audit.t (id int);
+            create table staging.t (id int);
+            insert audit.t values (1), (2);
+            insert staging.t values (100);
+            select (select count(*) from audit.t) as a, (select count(*) from staging.t) as s
+            """);
+        IsTrue(reader.Read());
+        AreEqual(2, reader.GetInt32(0));
+        AreEqual(1, reader.GetInt32(1));
+    }
+
+    [TestMethod]
+    public void UnqualifiedReference_ResolvesToDbo()
+        => AreEqual(5, new Simulation().ExecuteScalar("""
+            create schema audit;
+            create table dbo.t (id int);
+            create table audit.t (id int);
+            insert dbo.t values (5);
+            insert audit.t values (999);
+            select id from t
+            """));
+
+    [TestMethod]
+    public void ExplicitDbo_Equivalent_ToBare()
+        => AreEqual(5, new Simulation().ExecuteScalar("""
+            create table dbo.t (id int);
+            insert dbo.t values (5);
+            select id from t
+            """));
+
+    [TestMethod]
+    public void CrossSchemaJoin_Works()
+        => AreEqual(2, new Simulation().ExecuteScalar("""
+            create schema audit;
+            create table dbo.users (id int, name nvarchar(50));
+            create table audit.entries (user_id int, action nvarchar(50));
+            insert dbo.users values (1, 'alice'), (2, 'bob');
+            insert audit.entries values (1, 'login'), (1, 'logout'), (2, 'login');
+            select count(*) from dbo.users u inner join audit.entries e on u.id = e.user_id where u.id = 1
+            """));
+
+    [TestMethod]
+    public void DropSchema_NotSupported()
+        => Throws<DbException>(() =>
+            new Simulation().ExecuteNonQuery("create schema audit; drop schema audit"));
+
+    [TestMethod]
+    public void CreateSchema_PersistsAcrossBatches()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = "create schema audit";
+        _ = cmd.ExecuteNonQuery();
+        cmd.CommandText = "create table audit.t (id int); insert audit.t values (1); select count(*) from audit.t";
+        AreEqual(1, cmd.ExecuteScalar());
+    }
+}

SqlServerSimulator.Tests/CreateSchemaTests.cs

@@ -12,13 +12,35 @@ namespace SqlServerSimulator;
 /// <see cref="Simulation"/> ships with exactly one entry named
 /// <see cref="Simulation.DefaultDatabaseName"/>.
 /// </summary>
-internal sealed class Database(string name)
+internal sealed class Database
 {
+    /// <summary>The schema name an unqualified table reference resolves through.</summary>
+    public const string DefaultSchemaName = "dbo";
+
     /// <summary>Database name (the key in <see cref="Simulation.Databases"/>).</summary>
-    public readonly string Name = name;
+    public readonly string Name;
+
+    /// <summary>
+    /// Namespaces inside this database, keyed by name. Pre-populated with the
+    /// default <c>dbo</c> schema; <c>CREATE SCHEMA &lt;name&gt;</c> adds more.
+    /// Schema-qualified table references (<c>SELECT * FROM audit.t</c>) route
+    /// through here; unqualified references fall back to
+    /// <see cref="DefaultSchemaName"/>.
+    /// </summary>
+    public readonly ConcurrentDictionary<string, Schema> Schemas = new(Collation.Default);
 
-    /// <summary>User tables in this database, keyed by name.</summary>
-    public readonly ConcurrentDictionary<string, HeapTable> HeapTables = new(Collation.Default);
+    public Database(string name)
+    {
+        this.Name = name;
+        this.Schemas[DefaultSchemaName] = new Schema(DefaultSchemaName);
+    }
+
+    /// <summary>
+    /// Convenience accessor for the <c>dbo</c> schema's tables — the
+    /// unqualified-reference fallback path. Equivalent to
+    /// <c>Schemas[DefaultSchemaName].HeapTables</c>.
+    /// </summary>
+    public ConcurrentDictionary<string, HeapTable> DefaultSchemaTables => this.Schemas[DefaultSchemaName].HeapTables;
 
     /// <summary>
     /// Database compatibility level. Freshly-constructed databases default

SqlServerSimulator/Database.cs

@@ -1,5 +1,4 @@
 using SqlServerSimulator.Parser;
-using SqlServerSimulator.Parser.Tokens;
 
 namespace SqlServerSimulator;
 
@@ -21,7 +20,7 @@ internal static SimulatedSqlException IdentifierTooLong(ReadOnlySpan<char> first
     internal static SimulatedSqlException AmbiguousColumnName(string name) =>
         new($"Ambiguous column name '{name}'.", 209, 16, 1);
 
-    internal static SimulatedSqlException InvalidObjectName(StringToken name) => new($"Invalid object name {name}.", 208, 16, 1);
+    internal static SimulatedSqlException InvalidObjectName(MultiPartName name) => new($"Invalid object name '{name}'.", 208, 16, 1);
 
     internal static SimulatedSqlException MustDeclareScalarVariable(string name) => new($"Must declare the scalar variable \"@{name}\".", 137, 15, 2);
 

SqlServerSimulator/Errors/SimulatedSqlException.ResolutionErrors.cs

@@ -25,6 +25,16 @@ internal static SimulatedSqlException InvalidCompatibilityLevel() =>
 
     internal static SimulatedSqlException ThereIsAlreadyAnObject(string name) => new($"There is already an object named '{name}' in the database.", 2714, 16, 6);
 
+    /// <summary>
+    /// Mimics SQL Server error 2760: a statement referenced a schema that
+    /// doesn't exist (or whose principal the caller can't access). Probe-
+    /// confirmed wording — real SQL Server uses the same Msg / wording for
+    /// <c>CREATE TABLE missingschema.t</c>, <c>CREATE SCHEMA dbo</c> (when
+    /// targeting a built-in / reserved schema), and a few other lookups.
+    /// </summary>
+    internal static SimulatedSqlException SpecifiedSchemaNameDoesNotExist(string schemaName) =>
+        new($"The specified schema name \"{schemaName}\" either does not exist or you do not have permission to use it.", 2760, 16, 1);
+
     /// <summary>
     /// Mimics SQL Server error 2705: <c>SELECT … INTO target</c> produced a
     /// projection with two columns of the same name. Wording probe-confirmed