DROP SCHEMA + ALTER SCHEMA TRANSFER — schema lifecycle completes. DROP SCHEMA [IF EXISTS] routes through Simulation.Drop.cs's extended DropTargetKind switch alongside DROP TABLE/VIEW/FUNCTION/PROCEDURE/SEQUENCE/TRIGGER/TYPE; new DropOneSchema enforces Msg 15150 on reserved schemas (dbo / sys / INFORMATION_SCHEMA — probe-confirmed dbo isn't droppable even when empty, sharing IsReservedSchemaName with CreateSchema), Msg 15151 on missing-without-IF-EXISTS (silent miss when IF EXISTS), and Msg 3729 on non-empty (FirstSchemaResident walks Schema.SchemaObjects() first then falls through to TableTypes — the named object differs from real SQL Server's "first dependency-graph object" which is often an auto-named PK constraint, but the Msg / wording-prefix match probe). ALTER SCHEMA dest TRANSFER [(OBJECT|TYPE)::] source.obj routes through new TryParseAlterSchemaTransfer in Simulation.Alter.cs; OBJECT class walks HeapTables → Views → Functions → Procedures → Sequences first-hit-wins (triggers explicitly fail-fast with Msg 15347 since trigger schemas follow their parent automatically), TYPE class targets the parallel TableTypes namespace, and HeapTable / View transfers co-migrate every attached trigger via ReseatAttachedTriggers (their Trigger.Schema reference and SchemaId update to the destination's). Transfer / Object added as ContextualKeywords; tokenizer recognizes ':' as a single-char operator so the '::' class-prefix separator decomposes naturally into two adjacent tokens. SchemaObject.SchemaId dropped readonly (the TRANSFER path mutates it); every derived type's Schema reference field (View / Procedure / Sequence / TableType / Trigger / UserDefinedFunction) likewise dropped readonly. Probe-confirmed verbatim wording for all five error factories (CannotDropProtectedSchema 15150 / CannotDropSchemaDoesNotExist 15151 / CannotAlterSchemaDoesNotExist 15151 alter-variant / CannotFindObject 15151 find-object-variant / CannotFindType 15151 find-type-variant / CannotDropSchemaBecauseNotEmpty 3729 / ObjectAlreadyExistsInDestination 15530 / CannotTransferObjectOwnedByParent 15347). Missing destination → 15151 alter-variant; missing source object → 15151 find-object; same-schema TRANSFER is a silent no-op (probe-confirmed). 12 new SchemaTests covering all rejection paths plus successful transfers across every object class (table / view / sequence / table-type / trigger-co-migration); obsolete DropSchema_NotSupported test removed. 3344 / 264 tests pass; dotnet format clean. CLAUDE.md "Not modeled" entry collapsed; docs/claude/schemas.md gains full DROP SCHEMA + ALTER SCHEMA TRANSFER sections covering grammar, error paths, trigger co-migration, and the SchemaId-mutability change.

Author: RyanLamansky

CLAUDE.md

@@ -141,7 +141,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **Touching variables (DECLARE/SET/SELECT-assign), control flow (IF/BEGIN/WHILE/BREAK/CONTINUE/RETURN), TRY/CATCH+THROW+ERROR_*, PRINT, WAITFOR DELAY** → [`docs/claude/control-flow.md`](docs/claude/control-flow.md).
 - **Extending CTE shapes or recursive-CTE error handling** → [`docs/claude/ctes.md`](docs/claude/ctes.md).
 - **Touching JSON_VALUE / JSON_MODIFY / OPENJSON** → [`docs/claude/json.md`](docs/claude/json.md).
-- **Changing name resolution, schema lookup, CREATE SCHEMA, or OBJECT_ID** → [`docs/claude/schemas.md`](docs/claude/schemas.md).
+- **Changing name resolution, schema lookup, CREATE SCHEMA / DROP SCHEMA / ALTER SCHEMA TRANSFER, or OBJECT_ID** → [`docs/claude/schemas.md`](docs/claude/schemas.md).
 - **Adding or changing system metadata surfaces** (sys.* / INFORMATION_SCHEMA.*) → [`docs/claude/catalog-views.md`](docs/claude/catalog-views.md).
 - **Extending scalar UDFs, inline TVFs, views, updatable-view DML routing, stored procedures (CREATE/ALTER/DROP/EXEC), or dynamic SQL (`EXEC (@sql)` / `sp_executesql`)** → [`docs/claude/programmable.md`](docs/claude/programmable.md).
 - **Touching `#foo` routing, DROP TABLE, TRUNCATE TABLE** → [`docs/claude/temp-tables.md`](docs/claude/temp-tables.md).
@@ -170,8 +170,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **Table-variable named constraints / foreign keys** — `DECLARE @t TABLE (...)` shares its column-list parser with CREATE TABLE (see `docs/claude/table-variables.md`); column features (IDENTITY / UNIQUE / inline + table-level CHECK / computed columns / rowversion) all ship, alongside per-statement-atomic mutations and `OUTPUT … INTO <target>` for both `@t` and regular tables. Named constraints (`CONSTRAINT pk1 PRIMARY KEY`) and `FOREIGN KEY` raise Msg 102 (matches probe — real SQL Server's grammar disallows both shapes inside `DECLARE @t TABLE`). Multi-variable DECLARE with a table variable (`DECLARE @t1 TABLE (...), @t2 TABLE (...)`) and mixed scalar+table DECLARE also raise Msg 102/156. `SET IDENTITY_INSERT @t ON` likewise raises Msg 102 (probe-confirmed: there's no way to force a specific value into a table-variable identity column).
 - **Global temp tables (`##foo`)** — `NotSupportedException` at parse. Local `#foo` works; the lifecycle for global temps (drops when creator session closes, visible across sessions) is the deferred scope.
 - **`ALTER TABLE #foo`**, **`OBJECT_ID('tempdb..#foo')`** — none modeled (none of those exist for regular tables either yet). The common `IF OBJECT_ID(...) IS NOT NULL DROP TABLE` cleanup pattern works via `DROP TABLE IF EXISTS #foo` instead.
-- **`DROP SCHEMA`**, **`ALTER SCHEMA … TRANSFER`** — deferred. CREATE SCHEMA + schema-qualified resolution ships; lifecycle doesn't yet (catalog views — `sys.schemas`, `INFORMATION_SCHEMA.SCHEMATA` — do ship as of the catalog-view-expansion bundle).
-- **`CREATE SCHEMA AUTHORIZATION <owner>`** — `NotSupportedException` (simulator has no user / principal model).
+- **`CREATE SCHEMA AUTHORIZATION <owner>`** — `NotSupportedException` (simulator has no user / principal model). `DROP SCHEMA` + `ALTER SCHEMA … TRANSFER` both ship (see [`docs/claude/schemas.md`](docs/claude/schemas.md)): DROP enforces Msg 15150 / 15151 / 3729 rejections; TRANSFER routes OBJECT-class moves (HeapTable / View / Function / Procedure / Sequence) and TYPE-class moves (TableType) and co-migrates attached triggers with their parent table / view. Direct trigger transfer raises Msg 15347 (probe-confirmed: triggers follow their parent's schema automatically).
 - **CREATE SCHEMA's `<schema_element>` greedy form** — real SQL Server consumes trailing CREATE TABLE / VIEW / GRANT as part of the same CREATE SCHEMA statement (and requires CREATE SCHEMA to be the first statement in the batch as a result). The simulator instead dispatches the trailing tokens as their own statements — same end state for the common idiom, but mismatched-grammar trailers (e.g. anything that isn't a recognized statement start) raise `NotSupportedException`.
 - **`CREATE SCHEMA sys` / `INFORMATION_SCHEMA`** — raises Msg 2760 (matching real SQL Server). The schemas themselves exist as catalog-view hosts (`select * from sys.tables` / `select * from INFORMATION_SCHEMA.COLUMNS` work); legacy bare 1-part system-table access (`select * from systypes`) also still works.
 - T-SQL `GOTO` / labels — `IF` / `BEGIN…END` / `WHILE` / `BREAK` / `CONTINUE` / `RETURN` (bare + UDF-body and stored-procedure-body value form) ship; unconditional jumps don't.

SqlServerSimulator.Tests/CreateSchemaTests.cs

@@ -262,11 +262,6 @@ public void CrossSchemaJoin_Works()
             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()
     {
@@ -278,4 +273,238 @@ public void CreateSchema_PersistsAcrossBatches()
         cmd.CommandText = "create table audit.t (id int); insert audit.t values (1); select count(*) from audit.t";
         AreEqual(1, cmd.ExecuteScalar());
     }
+
+    [TestMethod]
+    public void DropSchema_Empty_Succeeds()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = "create schema audit; drop schema audit; select schema_id('audit')";
+        AreEqual(DBNull.Value, cmd.ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void DropSchema_Missing_Msg15151()
+        => new Simulation().AssertSqlError(
+            "drop schema nope",
+            15151,
+            "Cannot drop the schema 'nope', because it does not exist or you do not have permission.");
+
+    [TestMethod]
+    public void DropSchema_IfExistsMissing_NoOp()
+        => AreEqual(1, new Simulation().ExecuteScalar("drop schema if exists nope; select 1"));
+
+    [TestMethod]
+    public void DropSchema_Dbo_Msg15150()
+        => new Simulation().AssertSqlError(
+            "drop schema dbo",
+            15150,
+            "Cannot drop the schema 'dbo'.");
+
+    [TestMethod]
+    public void DropSchema_Sys_Msg15150()
+        => new Simulation().AssertSqlError(
+            "drop schema sys",
+            15150);
+
+    [TestMethod]
+    public void DropSchema_InformationSchema_Msg15150()
+        => new Simulation().AssertSqlError(
+            "drop schema INFORMATION_SCHEMA",
+            15150);
+
+    [TestMethod]
+    public void DropSchema_NotEmpty_Msg3729()
+    {
+        var ex = new Simulation().AssertSqlError(
+            "create schema audit; create table audit.t (id int); drop schema audit",
+            3729);
+        IsTrue(ex.Message.StartsWith("Cannot drop schema 'audit' because it is being referenced by object", StringComparison.Ordinal));
+    }
+
+    [TestMethod]
+    public void AlterSchema_Transfer_TableMoves()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = """
+            create schema src;
+            create schema dst;
+            create table src.t (id int);
+            insert src.t values (1), (2);
+            alter schema dst transfer src.t;
+            select s.name from sys.tables t join sys.schemas s on s.schema_id = t.schema_id where t.name = 't'
+            """;
+        AreEqual("dst", cmd.ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void AlterSchema_Transfer_ExplicitObjectPrefix()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = """
+            create schema src;
+            create schema dst;
+            create table src.t (id int);
+            alter schema dst transfer object::src.t;
+            select count(*) from dst.t
+            """;
+        AreEqual(0, cmd.ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void AlterSchema_Transfer_NameCollision_Msg15530()
+        => new Simulation().AssertSqlError(
+            """
+            create schema src;
+            create schema dst;
+            create table src.t (id int);
+            create table dst.t (id int);
+            alter schema dst transfer src.t
+            """,
+            15530,
+            "The object with name \"t\" already exists.");
+
+    [TestMethod]
+    public void AlterSchema_Transfer_MissingSource_Msg15151()
+        => new Simulation().AssertSqlError(
+            "create schema src; create schema dst; alter schema dst transfer src.nope",
+            15151,
+            "Cannot find the object 'nope', because it does not exist or you do not have permission.");
+
+    [TestMethod]
+    public void AlterSchema_Transfer_MissingDest_Msg15151()
+        => new Simulation().AssertSqlError(
+            "create schema src; create table src.t (id int); alter schema nope transfer src.t",
+            15151,
+            "Cannot alter the schema 'nope', because it does not exist or you do not have permission.");
+
+    [TestMethod]
+    public void AlterSchema_Transfer_TypeMoves()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = """
+            create schema src;
+            create schema dst;
+            create type src.MyType as table (id int);
+            alter schema dst transfer type::src.MyType;
+            select s.name from sys.types tt join sys.schemas s on s.schema_id = tt.schema_id where tt.name = 'MyType'
+            """;
+        AreEqual("dst", cmd.ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void AlterSchema_Transfer_SameSchema_NoOp()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = """
+            create schema src;
+            create table src.t (id int);
+            alter schema src transfer src.t;
+            select count(*) from src.t
+            """;
+        AreEqual(0, cmd.ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void AlterSchema_Transfer_TriggerDirect_Msg15347()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using (var setup = conn.CreateCommand())
+        {
+            setup.CommandText = "create schema src; create schema dst; create table src.t (id int)";
+            _ = setup.ExecuteNonQuery();
+        }
+        using (var trg = conn.CreateCommand())
+        {
+            trg.CommandText = "create trigger src.tr on src.t after insert as select 1";
+            _ = trg.ExecuteNonQuery();
+        }
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = "alter schema dst transfer src.tr";
+        var ex = Throws<DbException>(() => cmd.ExecuteNonQuery());
+        AreEqual("15347", ex.Data["HelpLink.EvtID"]);
+        AreEqual("Cannot transfer an object that is owned by a parent object.", ex.Message);
+    }
+
+    [TestMethod]
+    public void AlterSchema_Transfer_TriggerFollowsParent()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using (var setup = conn.CreateCommand())
+        {
+            setup.CommandText = "create schema src; create schema dst; create table src.t (id int)";
+            _ = setup.ExecuteNonQuery();
+        }
+        using (var trg = conn.CreateCommand())
+        {
+            trg.CommandText = "create trigger src.tr on src.t after insert as select 1";
+            _ = trg.ExecuteNonQuery();
+        }
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = "alter schema dst transfer src.t; select s.name from sys.triggers t join sys.objects o on o.object_id = t.parent_id join sys.schemas s on s.schema_id = o.schema_id where t.name = 'tr'";
+        AreEqual("dst", cmd.ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void AlterSchema_Transfer_View_Works()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = """
+            create schema src;
+            create schema dst;
+            create table dbo.base (id int);
+            insert dbo.base values (1), (2);
+            """;
+        _ = cmd.ExecuteNonQuery();
+        cmd.CommandText = "create view src.v as select id from dbo.base";
+        _ = cmd.ExecuteNonQuery();
+        cmd.CommandText = "alter schema dst transfer src.v; select count(*) from dst.v";
+        AreEqual(2, cmd.ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void AlterSchema_Transfer_Sequence_Works()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = """
+            create schema src;
+            create schema dst;
+            create sequence src.s start with 100;
+            alter schema dst transfer src.s;
+            select next value for dst.s
+            """;
+        AreEqual(100L, cmd.ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void DropSchema_AfterTransferringOut_Succeeds()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = """
+            create schema src;
+            create schema dst;
+            create table src.t (id int);
+            alter schema dst transfer src.t;
+            drop schema src;
+            select schema_id('src')
+            """;
+        AreEqual(DBNull.Value, cmd.ExecuteScalar());
+    }
 }

SqlServerSimulator/Errors/SimulatedSqlException.SchemaErrors.cs

@@ -428,4 +428,84 @@ internal static SimulatedSqlException CannotUpdateTimestampColumn() =>
     /// </summary>
     internal static SimulatedSqlException MultipleTimestampColumns(string tableName, string secondColumnName) =>
         new($"A table can only have one timestamp column. Because table '{tableName}' already has one, the column '{secondColumnName}' cannot be added.", 2738, 16, 2);
+
+    /// <summary>
+    /// Mimics SQL Server error 15150: <c>DROP SCHEMA</c> targeted a built-in /
+    /// reserved schema (<c>dbo</c>, <c>sys</c>, <c>INFORMATION_SCHEMA</c>,
+    /// <c>guest</c>, …). Real SQL Server treats these as un-droppable even when
+    /// empty; the simulator matches that rejection. Probe-confirmed verbatim
+    /// against SQL Server 2025.
+    /// </summary>
+    internal static SimulatedSqlException CannotDropProtectedSchema(string schemaName) =>
+        new($"Cannot drop the schema '{schemaName}'.", 15150, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 15151 (drop-schema variant): <c>DROP SCHEMA</c>
+    /// targeted a name that doesn't exist (suppressed by <c>IF EXISTS</c>).
+    /// Probe-confirmed verbatim wording against SQL Server 2025; SQL Server
+    /// reuses Msg 15151 for several "doesn't exist or no permission" lookups
+    /// — the simulator surfaces the variant matching each statement's noun.
+    /// </summary>
+    internal static SimulatedSqlException CannotDropSchemaDoesNotExist(string schemaName) =>
+        new($"Cannot drop the schema '{schemaName}', because it does not exist or you do not have permission.", 15151, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 15151 (alter-schema variant): <c>ALTER SCHEMA
+    /// dest TRANSFER ...</c> named a destination schema that doesn't exist.
+    /// Probe-confirmed verbatim wording — same Msg / Class / State as the
+    /// drop-schema-missing variant, distinct only in the "alter" vs "drop"
+    /// verb in the message body.
+    /// </summary>
+    internal static SimulatedSqlException CannotAlterSchemaDoesNotExist(string schemaName) =>
+        new($"Cannot alter the schema '{schemaName}', because it does not exist or you do not have permission.", 15151, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 15151 (find-object variant): <c>ALTER SCHEMA
+    /// ... TRANSFER source.obj</c> named a source object (table / view /
+    /// function / procedure / sequence) that doesn't resolve. The object's
+    /// leaf name is reported (probe-confirmed) — the qualifier doesn't appear
+    /// in the canonical message.
+    /// </summary>
+    internal static SimulatedSqlException CannotFindObject(string objectLeafName) =>
+        new($"Cannot find the object '{objectLeafName}', because it does not exist or you do not have permission.", 15151, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 15151 (find-type variant): <c>ALTER SCHEMA
+    /// ... TRANSFER TYPE::source.name</c> named a user-defined type that
+    /// doesn't resolve. Probe-confirmed wording variant — the canonical
+    /// "type" noun replaces "object".
+    /// </summary>
+    internal static SimulatedSqlException CannotFindType(string typeLeafName) =>
+        new($"Cannot find the type '{typeLeafName}', because it does not exist or you do not have permission.", 15151, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 3729: <c>DROP SCHEMA</c> rejected because the
+    /// schema still contains at least one object. SQL Server names the first
+    /// object found in the dependency-graph walk (which often happens to be
+    /// an auto-named PK / UNIQUE / CHECK constraint rather than the table
+    /// itself); the simulator picks a representative name from the same
+    /// dict scan. Probe-confirmed verbatim wording against SQL Server 2025.
+    /// </summary>
+    internal static SimulatedSqlException CannotDropSchemaBecauseNotEmpty(string schemaName, string objectName) =>
+        new($"Cannot drop schema '{schemaName}' because it is being referenced by object '{objectName}'.", 3729, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 15530: <c>ALTER SCHEMA dest TRANSFER source.obj</c>
+    /// rejected because <paramref name="objectLeafName"/> is already present
+    /// in the destination schema. The canonical wording surfaces only the
+    /// object's leaf (the destination schema isn't part of the message).
+    /// Probe-confirmed verbatim against SQL Server 2025.
+    /// </summary>
+    internal static SimulatedSqlException ObjectAlreadyExistsInDestination(string objectLeafName) =>
+        new($"The object with name \"{objectLeafName}\" already exists.", 15530, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 15347: <c>ALTER SCHEMA TRANSFER</c> targeted
+    /// an object that's owned by a parent (the common case is a DML trigger,
+    /// whose schema follows its parent table / view automatically — the
+    /// trigger can't be transferred independently). Probe-confirmed verbatim
+    /// wording.
+    /// </summary>
+    internal static SimulatedSqlException CannotTransferObjectOwnedByParent() =>
+        new("Cannot transfer an object that is owned by a parent object.", 15347, 16, 1);
 }

SqlServerSimulator/Parser/ContextualKeyword.cs

@@ -48,6 +48,7 @@ enum ContextualKeyword
     Next,
     No,
     NoWait,
+    Object,
     Offset,
     Only,
     Out,
@@ -74,6 +75,7 @@ enum ContextualKeyword
     Time,
     TraceOff,
     TraceOn,
+    Transfer,
     Try,
     Type,
     Unbounded,

SqlServerSimulator/Parser/Tokenizer.cs

@@ -46,7 +46,7 @@ static class Tokenizer
             '-' => ParseMinusOrComment(command, ref index),
             '/' => ParseForwardSlashOrComment(command, ref index),
             '[' => ParseBracketDelimitedString(command, ref index),
-            '+' or '*' or '%' or '(' or ')' or ',' or '.' or ';' or '=' or '&' or '|' or '^' or '>' or '<' or '!' => new Operator(command, index++),
+            '+' or '*' or '%' or '(' or ')' or ',' or '.' or ';' or ':' or '=' or '&' or '|' or '^' or '>' or '<' or '!' => new Operator(command, index++),
             '$' when IsDollarAction(command, index) => ParseDollarAction(command, ref index),
             '$' or '¢' or '£' or '¥' or '฿' or (>= '₠' and <= '₱') => ParseCurrencyLiteral(command, ref index),
             var c => throw SimulatedSqlException.SyntaxErrorNear(c) // Might throw on valid-but-unsupported syntax.