Fixed OPENJSON ... WITH ... AS JSON on nvarchar(max) gap.

RyanLamansky · RyanLamansky · commit 11aef4017c73 · 2026-05-27T12:05:38.000-05:00
diff --git a/SqlServerSimulator.Tests/OpenJsonTests.cs b/SqlServerSimulator.Tests/OpenJsonTests.cs
@@ -184,6 +184,88 @@ public void OpenJson_AsJsonOnNonNVarcharMax_RaisesMsg13618()
             13618,
             "AS JSON option can be specified only for column of nvarchar(max) type in WITH clause.");
 
+    [TestMethod]
+    public void OpenJson_AsJson_ObjectSubtree_PreservesVerbatimText()
+        => AreEqual("{  \"b\" : 2 , \"a\" : 1  }", new Simulation().ExecuteScalar(
+            "select x from openjson('{ \"o\" : {  \"b\" : 2 , \"a\" : 1  } }') with (x nvarchar(max) '$.o' as json)"));
+
+    [TestMethod]
+    public void OpenJson_AsJson_ArraySubtree()
+        => AreEqual("[1,2,3]", new Simulation().ExecuteScalar(
+            "select x from openjson('{\"tags\":[1,2,3]}') with (x nvarchar(max) '$.tags' as json)"));
+
+    [TestMethod]
+    public void OpenJson_AsJson_ScalarUnderLax_Null()
+    {
+        using var reader = new Simulation().ExecuteReader(
+            "select x from openjson('{\"scalar\":42}') with (x nvarchar(max) '$.scalar' as json)");
+        IsTrue(reader.Read());
+        IsTrue(reader.IsDBNull(0));
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void OpenJson_AsJson_ScalarUnderStrict_RaisesMsg13624()
+        => new Simulation().AssertSqlError(
+            "select x from openjson('{\"scalar\":42}') with (x nvarchar(max) 'strict $.scalar' as json)",
+            13624,
+            "Object or array cannot be found in the specified JSON path.");
+
+    [TestMethod]
+    public void OpenJson_AsJson_MissingUnderStrict_RaisesMsg13608_State6()
+    {
+        var ex = new Simulation().AssertSqlError(
+            "select x from openjson('{\"a\":1}') with (x nvarchar(max) 'strict $.missing' as json)",
+            13608);
+        AreEqual("Property cannot be found on the specified JSON path.", ex.Message);
+        AreEqual((byte)6, ex.State);
+    }
+
+    [TestMethod]
+    public void OpenJson_AsJson_JsonNullUnderStrict_ReturnsNull()
+    {
+        using var reader = new Simulation().ExecuteReader(
+            "select x from openjson('{\"n\":null}') with (x nvarchar(max) 'strict $.n' as json)");
+        IsTrue(reader.Read());
+        IsTrue(reader.IsDBNull(0));
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void OpenJson_AsJson_MixedScalarAndSubtreeColumns()
+    {
+        using var reader = new Simulation().ExecuteReader("""
+            select name, addr, city from openjson('{"name":"Alice","address":{"city":"NYC"}}')
+            with (name nvarchar(100) '$.name', addr nvarchar(max) '$.address' as json, city nvarchar(50) '$.address.city')
+            """);
+        IsTrue(reader.Read());
+        AreEqual("Alice", reader.GetString(0));
+        AreEqual("{\"city\":\"NYC\"}", reader.GetString(1));
+        AreEqual("NYC", reader.GetString(2));
+    }
+
+    [TestMethod]
+    public void OpenJson_AsJson_ArraySource_ExtractsSubtreePerElement()
+    {
+        using var reader = new Simulation().ExecuteReader("""
+            select id, meta from openjson('[{"id":1,"meta":{"x":10}},{"id":2,"meta":{"y":20}}]')
+            with (id int '$.id', meta nvarchar(max) '$.meta' as json)
+            """);
+        var rows = new List<(int id, string meta)>();
+        while (reader.Read())
+            rows.Add((reader.GetInt32(0), reader.GetString(1)));
+        CollectionAssert.AreEqual(new[] { (1, "{\"x\":10}"), (2, "{\"y\":20}") }, rows);
+    }
+
+    // JSON_QUERY shares the AS JSON subtree-extraction rule: a strict-mode
+    // scalar match raises Msg 13624 (lax returns NULL).
+    [TestMethod]
+    public void JsonQuery_StrictScalar_RaisesMsg13624()
+        => new Simulation().AssertSqlError(
+            "select json_query('{\"a\":1}', 'strict $.a')",
+            13624,
+            "Object or array cannot be found in the specified JSON path.");
+
     // EF Core 10's primitive-collection .Any() shape: EXISTS over a
     // typed-OPENJSON subquery with a WHERE filter.
     [TestMethod]
diff --git a/SqlServerSimulator/Errors/SimulatedSqlException.JsonErrors.cs b/SqlServerSimulator/Errors/SimulatedSqlException.JsonErrors.cs
@@ -15,10 +15,22 @@ internal static SimulatedSqlException JsonInvalidPath(string path) =>
     /// Msg 13608: SQL Server raises this when a <c>strict</c>-mode JSON
     /// path resolves through a missing property / out-of-bounds index /
     /// non-object-or-array intermediate. Lax mode silently returns NULL
-    /// instead.
+    /// instead. The State byte is context-dependent: JSON_VALUE reports
+    /// state 2, an OPENJSON … WITH column reports state 6, and the
+    /// JSON_QUERY / JSON_MODIFY default is state 1.
     /// </summary>
-    internal static SimulatedSqlException JsonStrictPathNotFound() =>
-        new("Property cannot be found on the specified JSON path.", 13608, 16, 1);
+    internal static SimulatedSqlException JsonStrictPathNotFound(byte state = 1) =>
+        new("Property cannot be found on the specified JSON path.", 13608, 16, state);
+
+    /// <summary>
+    /// Msg 13624: a <c>strict</c>-mode JSON path under JSON_QUERY (or an
+    /// <c>OPENJSON … WITH (col … AS JSON)</c> column) resolved to a value
+    /// that is present but is neither an object nor an array. Lax mode
+    /// returns NULL instead; a JSON <c>null</c> value returns NULL in
+    /// both modes.
+    /// </summary>
+    internal static SimulatedSqlException JsonObjectOrArrayNotFound() =>
+        new("Object or array cannot be found in the specified JSON path.", 13624, 16, 1);
 
     /// <summary>
     /// Msg 13609: invalid JSON text passed to JSON_VALUE / JSON_QUERY /
diff --git a/SqlServerSimulator/Parser/Expressions/JsonQuery.cs b/SqlServerSimulator/Parser/Expressions/JsonQuery.cs
@@ -55,19 +55,8 @@ public override SqlValue Run(RuntimeContext runtime)
             if (match is null)
                 return SqlValue.Null(SqlType.NVarchar);
 
-            var element = match.Value;
-            return element.ValueKind switch
-            {
-                // Object / Array — JSON_QUERY returns the raw JSON text of
-                // the subtree (re-serialized via GetRawText, which preserves
-                // the input's whitespace shape — matching SQL Server's
-                // observable behavior on round-trip).
-                JsonValueKind.Object or JsonValueKind.Array => SqlValue.FromNVarchar(element.GetRawText()),
-                // Scalar match (String / Number / True / False / Null) —
-                // JSON_QUERY returns NULL in lax mode (Msg 13624 in strict,
-                // which EF / DACFx never depend on).
-                _ => SqlValue.Null(SqlType.NVarchar),
-            };
+            var subtree = JsonSubtree.Extract(match.Value, path.Mode);
+            return subtree is null ? SqlValue.Null(SqlType.NVarchar) : SqlValue.FromNVarchar(subtree);
         }
     }
 
diff --git a/SqlServerSimulator/Parser/JsonPath.cs b/SqlServerSimulator/Parser/JsonPath.cs
@@ -130,16 +130,18 @@ private static void SkipWhitespace(string text, ref int i)
     /// the matched element or null when a segment misses (lax mode);
     /// raises Msg 13608 in strict mode. The "missing" cases are (a) property
     /// name not present in an object, (b) array index out of bounds,
-    /// (c) traversing into a non-object/non-array.
+    /// (c) traversing into a non-object/non-array. <paramref name="strictNotFoundState"/>
+    /// carries the caller's context-specific Msg 13608 State byte (OPENJSON
+    /// columns report 6; the default 1 matches JSON_QUERY).
     /// </summary>
-    public JsonElement? Walk(JsonElement root)
+    public JsonElement? Walk(JsonElement root, byte strictNotFoundState = 1)
     {
         var current = root;
         foreach (var segment in this.Segments)
         {
             var next = TryStep(current, segment);
             if (next is null)
-                return this.Mode == JsonPathMode.Strict ? throw SimulatedSqlException.JsonStrictPathNotFound() : null;
+                return this.Mode == JsonPathMode.Strict ? throw SimulatedSqlException.JsonStrictPathNotFound(strictNotFoundState) : null;
             current = next.Value;
         }
         return current;
diff --git a/SqlServerSimulator/Parser/JsonSubtree.cs b/SqlServerSimulator/Parser/JsonSubtree.cs
@@ -0,0 +1,27 @@
+using System.Text.Json;
+
+namespace SqlServerSimulator.Parser;
+
+/// <summary>
+/// The JSON_QUERY-style subtree-extraction rule shared by <c>JSON_QUERY</c>
+/// and the <c>OPENJSON … WITH (col … AS JSON)</c> column modifier: an
+/// object/array match yields its verbatim source text (whitespace and
+/// key order preserved, via <see cref="JsonElement.GetRawText"/>), a JSON
+/// <c>null</c> yields SQL NULL, and any other (non-null) scalar yields SQL
+/// NULL under lax mode or Msg 13624 under strict.
+/// </summary>
+internal static class JsonSubtree
+{
+    /// <summary>
+    /// Classifies an already-resolved JSON element. Returns the verbatim
+    /// subtree text for an object/array; <c>null</c> for a JSON-null match
+    /// or — under lax mode — a non-null scalar. Raises Msg 13624 for a
+    /// non-null scalar under strict mode.
+    /// </summary>
+    public static string? Extract(JsonElement element, JsonPathMode mode) => element.ValueKind switch
+    {
+        JsonValueKind.Object or JsonValueKind.Array => element.GetRawText(),
+        JsonValueKind.Null => null,
+        _ => mode == JsonPathMode.Strict ? throw SimulatedSqlException.JsonObjectOrArrayNotFound() : null,
+    };
+}
diff --git a/SqlServerSimulator/Parser/Selection.OpenJson.cs b/SqlServerSimulator/Parser/Selection.OpenJson.cs
@@ -104,7 +104,17 @@ private static IEnumerable<byte[]> EnumerateOpenJsonRows(
                 root = match.Value;
             }
 
-            if (root.ValueKind == JsonValueKind.Array)
+            // An explicit WITH schema evaluates its column paths relative to
+            // the root document: an array root yields one row per element
+            // (paths relative to the element), an object root yields a single
+            // row (paths relative to the root). The default (key, value, type)
+            // schema instead unfolds the root — one row per array element or
+            // per object property.
+            if (root.ValueKind == JsonValueKind.Object && withColumns is not null)
+            {
+                yield return BuildOpenJsonRow(root, withColumns, schema, key: "");
+            }
+            else if (root.ValueKind == JsonValueKind.Array)
             {
                 var index = 0;
                 foreach (var element in root.EnumerateArray())
@@ -153,7 +163,7 @@ private static byte[] BuildOpenJsonRow(JsonElement element, OpenJsonColumn[]? wi
         for (var i = 0; i < withColumns.Length; i++)
         {
             var column = withColumns[i];
-            var matched = column.Path.Walk(element);
+            var matched = column.Path.Walk(element, strictNotFoundState: 6);
             values[i] = matched is null
                 ? SqlValue.Null(column.Type)
                 : ExtractColumnValue(matched.Value, column);
@@ -169,6 +179,15 @@ private static byte[] BuildOpenJsonRow(JsonElement element, OpenJsonColumn[]? wi
     /// </summary>
     private static SqlValue ExtractColumnValue(JsonElement element, OpenJsonColumn column)
     {
+        if (column.AsJson)
+        {
+            // AS JSON: return the matched object/array subtree as verbatim
+            // text. A JSON null or (under lax) a non-null scalar yields NULL;
+            // a non-null scalar under strict raised Msg 13624 inside Extract.
+            var subtree = JsonSubtree.Extract(element, column.Path.Mode);
+            return subtree is null ? SqlValue.Null(column.Type) : SqlValue.FromNVarchar(subtree).CoerceTo(column.Type);
+        }
+
         if (element.ValueKind == JsonValueKind.Null)
             return SqlValue.Null(column.Type);
 
@@ -252,9 +271,8 @@ public static Selection ParseOpenJson(ParserContext context, Func<MultiPartName,
     /// Parses the body of an OPENJSON <c>WITH (col TYPE [path] [AS JSON], ...)</c>
     /// clause. Enters with <see cref="ParserContext.Token"/> on the
     /// <c>WITH</c> keyword; on return Token sits on the closing <c>)</c>.
-    /// <c>AS JSON</c> isn't modeled — raises NotSupportedException so users
-    /// get a diagnostic when they try owned-many-as-JSON-with-AS-JSON
-    /// shapes (EF Core 10 doesn't emit these).
+    /// <c>AS JSON</c> is accepted only on <c>nvarchar(max)</c> columns
+    /// (Msg 13618 otherwise) and flags the column for subtree extraction.
     /// </summary>
     private static OpenJsonColumn[] ParseOpenJsonWithColumns(ParserContext context, Func<MultiPartName, SqlType>? outerTypeResolver)
     {
@@ -320,21 +338,25 @@ private static OpenJsonColumn[] ParseOpenJsonWithColumns(ParserContext context,
                 path = JsonPath.Parse("$." + columnName);
             }
 
-            // AS JSON modifier — real SQL Server only accepts it on
+            // AS JSON modifier — real SQL Server accepts it only on
             // nvarchar(max) columns and raises Msg 13618 for any other type
-            // (probe-confirmed). The simulator emits the matching rejection
-            // for non-nvarchar(max) types but still raises NotSupportedException
-            // for the accepted nvarchar(max) shape, which the simulator hasn't
-            // built the surrounding sub-tree extraction for. EF Core 10 doesn't
-            // emit the AS JSON modifier.
+            // (probe-confirmed). The matched object/array subtree is later
+            // extracted as verbatim JSON text; see ExtractColumnValue.
+            var asJson = false;
             if (context.Token is ReservedKeyword { Keyword: Keyword.As })
             {
+                if (context.GetNextRequired() is not Name { Value: var modifier }
+                    || !string.Equals(modifier, "JSON", StringComparison.OrdinalIgnoreCase))
+                {
+                    throw SimulatedSqlException.SyntaxErrorNear(context);
+                }
                 if (resolvedType is not NVarcharSqlType { length: SqlType.MaxLengthSentinel })
                     throw SimulatedSqlException.OpenJsonAsJsonRequiresNVarcharMax();
-                throw new NotSupportedException("OPENJSON column-level AS JSON modifier on nvarchar(max) isn't modeled.");
+                asJson = true;
+                context.MoveNextRequired();
             }
 
-            columns.Add(new OpenJsonColumn(columnName, resolvedType, path));
+            columns.Add(new OpenJsonColumn(columnName, resolvedType, path, asJson));
 
             if (context.Token is Operator { Character: ')' })
                 break;
@@ -351,9 +373,14 @@ private static OpenJsonColumn[] ParseOpenJsonWithColumns(ParserContext context,
 /// is parsed once at FROM-source-parse time (not per row) since the WITH
 /// clause's path argument is always a string literal.
 /// </summary>
-internal sealed class OpenJsonColumn(string name, SqlType type, JsonPath path)
+internal sealed class OpenJsonColumn(string name, SqlType type, JsonPath path, bool asJson)
 {
     public readonly string Name = name;
     public readonly SqlType Type = type;
     public readonly JsonPath Path = path;
+
+    /// <summary>The <c>AS JSON</c> modifier was present: the column extracts
+    /// the matched object/array subtree as verbatim JSON text rather than
+    /// coercing a scalar leaf to <see cref="Type"/>.</summary>
+    public readonly bool AsJson = asJson;
 }
diff --git a/docs/claude/function-coverage-todo.md b/docs/claude/function-coverage-todo.md
@@ -144,7 +144,6 @@ Functions that exist only in Azure SQL Database / Fabric surfaces, not in the SQ
 
 Real bugs / limitations against shipped functions — fixes are tickable work, not design decisions.
 
-- [ ] **OPENJSON ... WITH ... AS JSON** on `nvarchar(max)` raises `NotSupportedException` (sub-tree extraction missing); non-`nvarchar(max)` raises Msg 13618.
 - [ ] **REPLICATE** of a MAX-typed *column* reference truncates to 8000 bytes (parse-time type resolver doesn't reach FROM-source columns; literal / CAST-target inputs work).
 - [ ] **GROUPING / GROUPING_ID** only accept `Reference` arguments — `GROUPING(a+1)` paired with `GROUP BY a+1` always raises Msg 8161 instead of matching structurally.
 - [ ] **STRING_SPLIT(..., ..., CAST(@v AS INT))** wrapped-variable accepted; real SQL Server rejects all variable-bearing `enable_ordinal` shapes regardless of wrapping.
diff --git a/docs/claude/json.md b/docs/claude/json.md
@@ -21,7 +21,9 @@ Value formatting matches real SQL Server byte-for-byte except float / real (docu
 - other strings → JSON-escaped (`\"` `\\` `\b` `\f` `\n` `\r` `\t` `\uHHHH` for control chars; non-ASCII / `/` / `<` / `>` left literal)
 - nested `JSON_OBJECT` / `JSON_ARRAY` / `JSON_QUERY` results — embedded **raw** (not re-quoted), via compile-time `JsonValueRender.ProducesJson(Expression)` detection that unwraps `Parenthesized`. Other strings — including `'{"x":1}'` literals — go through the quote-and-escape path, matching SQL Server's JSON-typed-input detection without needing an `SqlValue`-level marker bit.
 
-`OPENJSON(json [, doc_path]) [WITH (col TYPE [path] [AS JSON], …)]` — rowset-returning, structurally a new FromSource kind. Without WITH: default schema `(key nvarchar, value nvarchar, type int)` — type codes 0=null/1=string/2=number/3=bool/4=array/5=object. With WITH: each column extracts via `$.<col-name>` (default) or explicit `'$path'`; primitive collections use `'$'`. `AS JSON` modifier → `NotSupportedException` on `nvarchar(max)` (sub-tree extraction not modeled, even though real SQL Server accepts the column form there); on a non-`nvarchar(max)` column `AS JSON` raises **Msg 13618**, matching real. NULL/invalid JSON → zero rows under lax.
+`OPENJSON(json [, doc_path]) [WITH (col TYPE [path] [AS JSON], …)]` — rowset-returning, structurally a new FromSource kind. Without WITH: default schema `(key nvarchar, value nvarchar, type int)` — type codes 0=null/1=string/2=number/3=bool/4=array/5=object, unfolding the root one row per array element / object property. With WITH: column paths are root-relative — an **array root yields one row per element** (paths relative to the element), an **object root yields a single row** (paths relative to the root). Each column extracts via `$.<col-name>` (default) or explicit `'$path'`; primitive collections use `'$'`. NULL/invalid JSON → zero rows under lax.
+
+`AS JSON` column modifier — accepted only on `nvarchar(max)` (any other declared type raises **Msg 13618** at parse). Extracts the matched subtree via the shared `JsonSubtree.Extract` (the same rule backing `JSON_QUERY`): object/array → verbatim source text (whitespace and key order preserved, via `JsonElement.GetRawText`); JSON `null` → SQL NULL in both modes; any other (non-null) scalar → SQL NULL in lax, **Msg 13624** in strict; a missing path → SQL NULL in lax, **Msg 13608 State 6** in strict (the OPENJSON-context state, threaded through `JsonPath.Walk`'s `strictNotFoundState` — JSON_VALUE reports State 2, JSON_QUERY/JSON_MODIFY State 1).
 
 OPENJSON WITH-clause types: `int`/`bigint`/`decimal(p,s)`/`float`/`bit`/`nvarchar(N|max)`/`varchar(N)`/`date`/`datetime2(N)`/`datetimeoffset(N)`/`uniqueidentifier`. Coercion via `SqlValue.CoerceTo`. Backed by `System.Text.Json`. JSON-path quoted-property escape `""` → literal `"`.
 
