JSON_VALUE / JSON_MODIFY / OPENJSON: read + partial-update for OwnsOne(...).ToJson() owned types and primitive collections (List<int> / List<string>). Three dispatch points — JSON_VALUE / JSON_MODIFY drop into ResolveBuiltIn (length 10 / 11); OPENJSON wins at ParseSingleFromSource's case-Name head (case-insensitive name match, parallel to SQL Server's reservation). OPENJSON implemented via Selection.FromOpenJson factory so the existing alias / qualifier / lateral-re-execution machinery transparently covers it. Shared JsonPath parser (lax/strict $[.foo|[N]]+) backs runtime walks via JsonElement (read) and JsonNode (modify) plus parse-time per-column path resolution in OPENJSON's WITH clause. System.Text.Json (runtime-shipped) for parse + mutation. Lax-default semantics; strict honored only in JSON_MODIFY's missing-leaf path (Msg 13608). OPENJSON WITH-clause types: int / bigint / decimal / float / bit / nvarchar / varchar / date / datetime2 / datetimeoffset / uniqueidentifier; AS JSON modifier raises NotSupportedException.

Author: RyanLamansky

.editorconfig

@@ -19,6 +19,8 @@ dotnet_diagnostic.IDE0040.severity = none # Add accessibility modifiers
 dotnet_diagnostic.IDE0061.severity = none # Use block body for local function
 dotnet_diagnostic.IDE0072.severity = none # Add missing cases
 
+dotnet_diagnostic.JSON002.severity = none # Probable JSON string detected
+
 dotnet_diagnostic.MSTEST0017.severity = error # Assertion arguments should be passed in the correct order (expected then actual)
 dotnet_diagnostic.MSTEST0024.severity = error # Do not store TestContext in a static or readonly field
 dotnet_diagnostic.MSTEST0025.severity = error # Use 'Assert.Fail' instead of always-failing constructs

CLAUDE.md

@@ -365,6 +365,28 @@ Projection-count vs insert-list mismatch fires at parse time via `selection.Sche
 
 EF Core 10 doesn't emit `INSERT … SELECT` from SaveChanges (which uses INSERT…OUTPUT VALUES for single-row and MERGE for batched-multi-row); this is reachable from raw SQL (`FromSqlInterpolated` / direct command text) and from application-side bulk-copy patterns. CTE-prefix INSERTs (`WITH … INSERT t SELECT …`) aren't modeled — orthogonal to this bundle since the simulator has no CTE support.
 
+### JSON support: `JSON_VALUE` / `JSON_MODIFY` / `OPENJSON`
+Three pieces unlock EF Core 10's owned-types-as-JSON (`OwnsOne(...).ToJson()`) and primitive-collection (`List<int>` / `List<string>` etc.) emissions. JSON columns are plain `nvarchar(max)` — no special storage type. Probe-confirmed against SQL Server 2025 on 2026-05-10.
+
+`JSON_VALUE(json, path)` — scalar function returning `nvarchar`. Lax mode (default and EF Core's only emitted form): missing path / non-scalar match → SQL NULL. `strict $.foo` raises **Msg 13608** on miss. NULL `json` or NULL path → NULL. JSON booleans render as lowercase `'true'` / `'false'`; JSON numbers return raw text via `JsonElement.GetRawText` (e.g. `'42'`, `'1.5'`). Object / array matches return NULL in lax (the documented scalar-only restriction); strict raises but EF Core never depends on it.
+
+`JSON_MODIFY(json, path, newValue)` — scalar function returning `nvarchar`. Replaces the value at `path` with `newValue`. EF Core 10 emits `'strict $.City'`-shape paths from owned-as-JSON partial updates; the strict prefix is honored (missing leaf → Msg 13608). Bare `'$'` replaces the entire document. Lax-mode existing-key + NULL value removes the key; lax-mode missing key + non-NULL value adds it. Numeric / boolean `newValue` arguments stay JSON-typed (`{"n":42}` not `{"n":"42"}`); System.Text.Json `JsonValue.Create` handles primitive→JSON-text dispatch.
+
+`OPENJSON(json [, doc_path]) [WITH (col TYPE [path] [AS JSON], …)]` — rowset-returning function, structurally a new FromSource kind. Implemented via a `Selection.FromOpenJson(...)` factory (parallel to derived tables / CTEs / VALUES) so the existing alias / qualifier / lateral re-execution machinery transparently covers it. Without WITH: default schema `(key nvarchar, value nvarchar, type int)` — type codes 0=null / 1=string / 2=number / 3=true-or-false / 4=array / 5=object. With WITH: each column extracts via `$.<col-name>` (default) or explicit `'$path'`; primitive collections use the `'$'` self-reference shape. `AS JSON` modifier raises `NotSupportedException` (EF Core 10 doesn't emit it). NULL JSON / invalid JSON → zero rows under lax mode (matches EF's tolerance). For arrays: one row per element with `key` = decimal index. For objects: one row per property with `key` = property name.
+
+Dispatch: `JSON_VALUE` / `JSON_MODIFY` route through `Expression.cs:ResolveBuiltIn`'s length-keyed switch (10 / 11). `OPENJSON` is dispatched at `ParseSingleFromSource`'s `case Name tableName:` head — case-insensitive name match on `"OPENJSON"` wins over CTE / table lookup, parallel to how SQL Server reserves the function name. The path-string parser (`Parser/JsonPath.cs`) is shared between the three: a tiny grammar (`['lax'|'strict']? '$' (segment)*`) backing both runtime walks (via `JsonElement` for read paths, `JsonNode` for modify paths) and parse-time per-column path resolution in OPENJSON's WITH clause. Quoted-property escape `""` → literal `"` matches SQL Server (this is what EF Core's `'{"":"X"}'` + `$.""` parameter-wrap shape relies on).
+
+OPENJSON WITH-clause type subset: `int` / `bigint` / `decimal(p,s)` / `float` / `bit` / `nvarchar(N|max)` / `varchar(N)` / `date` / `datetime2(N)` / `datetimeoffset(N)` / `uniqueidentifier`. Coercion from JSON scalar text routes through `SqlValue.CoerceTo` (the existing CAST machinery). JSON `null` element → SQL NULL of the column's type. Backed by `System.Text.Json` (runtime-shipped, no NuGet dependency added).
+
+EF Core 10 emissions covered:
+- `Where(c => c.Address.City == "X")` → `JSON_VALUE([c].[Address], '$.City')`
+- `Where(c => c.Tags.Contains("x"))` → `OPENJSON(...) WITH ([value] nvarchar(max) '$')` inside `IN(SELECT)`
+- `c.Scores.Count` → `(SELECT COUNT(*) FROM OPENJSON(...))`
+- `c.Scores.Any(s => s > 15)` → `EXISTS (SELECT 1 FROM OPENJSON(...) WITH ([value] int '$') WHERE …)`
+- Owned-as-JSON partial UPDATE → `SET [Address] = JSON_MODIFY([Address], 'strict $.City', JSON_VALUE(@p0, '$.""'))`
+
+Not emitted by EF Core 10 (and not modeled): `JSON_QUERY` (object/array extraction; whole-owned-object reads use raw column + client-side deserialization), `ISJSON`, `FOR JSON PATH`/`AUTO`. Reachable from raw SQL only via `FromSqlInterpolated` / direct command text.
+
 ### MERGE / OUTPUT (EF Core SaveChanges shape only)
 - `INSERT ... OUTPUT INSERTED.<col>` (single-row).
 - `MERGE INTO target USING (VALUES ...) AS alias (cols) ON predicate WHEN NOT MATCHED THEN INSERT ... [OUTPUT ...]` (multi-row batch).

SqlServerSimulator.Tests.EFCore/EFCoreJson.cs

@@ -0,0 +1,175 @@
+using Microsoft.EntityFrameworkCore;
+using SqlServerSimulator.EFCore;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// EF Core 10 oracle tests for the JSON pieces: <c>OwnsOne(...).ToJson()</c>
+/// owned-types-as-JSON read/update paths (JSON_VALUE / JSON_MODIFY) and
+/// primitive-collection read paths (OPENJSON). Each test takes the LINQ
+/// shape EF Core would emit naturally and validates the simulator returns
+/// the expected results, exercising the LINQ→SQL pipeline end-to-end.
+/// </summary>
+[TestClass]
+public class EFCoreJson
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private static JsonContext NewContext()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table Companies (
+                Id int identity primary key,
+                Name nvarchar(max) not null,
+                Address nvarchar(max) null,
+                Tags nvarchar(max) not null,
+                Scores nvarchar(max) not null
+            )
+            """);
+        return new JsonContext(simulation);
+    }
+
+    private static JsonContext SeededContext(params (string name, string? city, List<string> tags, List<int> scores)[] companies)
+    {
+        var ctx = NewContext();
+        foreach (var (name, city, tags, scores) in companies)
+        {
+            _ = ctx.Companies.Add(new Company
+            {
+                Name = name,
+                Address = city is null ? null : new Address { City = city, Street = "addr" },
+                Tags = tags,
+                Scores = scores,
+            });
+        }
+        _ = ctx.SaveChanges();
+        return ctx;
+    }
+
+    [TestMethod]
+    public void OwnedAsJson_Insert_StoresJsonText()
+    {
+        using var ctx = SeededContext(("Acme", "Springfield", new() { "alpha" }, new() { 10 }));
+        var company = ctx.Companies.AsNoTracking().Single();
+        Assert.AreEqual("Springfield", company.Address!.City);
+    }
+
+    [TestMethod]
+    public void OwnedAsJson_WhereByCity_FiltersWithJsonValue()
+    {
+        using var ctx = SeededContext(
+            ("A", "Springfield", new(), new()),
+            ("B", "Shelbyville", new(), new()),
+            ("C", "Springfield", new(), new()));
+        var matches = ctx.Companies.AsNoTracking().Where(c => c.Address!.City == "Springfield").Count();
+        Assert.AreEqual(2, matches);
+    }
+
+    [TestMethod]
+    public void OwnedAsJson_ProjectCity_UsesJsonValue()
+    {
+        using var ctx = SeededContext(("A", "Springfield", new(), new()));
+        var city = ctx.Companies.AsNoTracking().Select(c => c.Address!.City).Single();
+        Assert.AreEqual("Springfield", city);
+    }
+
+    [TestMethod]
+    public void OwnedAsJson_PartialUpdate_UsesJsonModify()
+    {
+        using var ctx = SeededContext(("A", "Springfield", new(), new()));
+        var company = ctx.Companies.Single();
+        company.Address!.City = "Shelbyville";
+        _ = ctx.SaveChanges();
+
+        using var verifyCtx = new JsonContext(ctx.Simulation);
+        Assert.AreEqual("Shelbyville", verifyCtx.Companies.AsNoTracking().Single().Address!.City);
+    }
+
+    [TestMethod]
+    public void PrimitiveCollection_Contains_UsesOpenJson()
+    {
+        using var ctx = SeededContext(
+            ("A", null, new() { "alpha", "beta" }, new()),
+            ("B", null, new() { "gamma" }, new()),
+            ("C", null, new() { "beta", "delta" }, new()));
+        var ids = ctx.Companies.AsNoTracking()
+            .Where(c => c.Tags.Contains("beta"))
+            .OrderBy(c => c.Id)
+            .Select(c => c.Name)
+            .ToList();
+        CollectionAssert.AreEqual(new[] { "A", "C" }, ids);
+    }
+
+    [TestMethod]
+    public void PrimitiveCollection_Count_UsesOpenJson()
+    {
+        using var ctx = SeededContext(
+            ("A", null, new(), new() { 10, 20, 30 }),
+            ("B", null, new(), new()),
+            ("C", null, new(), new() { 42 }));
+        var counts = ctx.Companies.AsNoTracking()
+            .OrderBy(c => c.Id)
+            .Select(c => new { c.Name, ScoreCount = c.Scores.Count })
+            .ToList();
+        Assert.HasCount(3, counts);
+        Assert.AreEqual(3, counts[0].ScoreCount);
+        Assert.AreEqual(0, counts[1].ScoreCount);
+        Assert.AreEqual(1, counts[2].ScoreCount);
+    }
+
+    [TestMethod]
+    public void PrimitiveCollection_AnyWithPredicate_UsesOpenJson()
+    {
+        using var ctx = SeededContext(
+            ("A", null, new(), new() { 10, 20 }),
+            ("B", null, new(), new() { 5, 8 }),
+            ("C", null, new(), new() { 100 }));
+        var names = ctx.Companies.AsNoTracking()
+            .Where(c => c.Scores.Any(s => s > 15))
+            .OrderBy(c => c.Id)
+            .Select(c => c.Name)
+            .ToList();
+        CollectionAssert.AreEqual(new[] { "A", "C" }, names);
+    }
+}
+
+internal sealed class Company
+{
+    public int Id { get; set; }
+    public string Name { get; set; } = "";
+    public Address? Address { get; set; }
+    public List<string> Tags { get; set; } = [];
+    public List<int> Scores { get; set; } = [];
+}
+
+internal sealed class Address
+{
+    public string Street { get; set; } = "";
+    public string City { get; set; } = "";
+}
+
+internal sealed class JsonContext(Simulation simulation) : DbContext
+{
+    public readonly Simulation Simulation = simulation;
+
+    public DbSet<Company> Companies => Set<Company>();
+
+    protected override void OnConfiguring(DbContextOptionsBuilder options)
+    {
+        _ = options.UseSqlServerSimulator(this.Simulation.CreateDbConnection());
+    }
+
+    protected override void OnModelCreating(ModelBuilder mb)
+    {
+        _ = mb.Entity<Company>(b =>
+        {
+            _ = b.OwnsOne(c => c.Address, a =>
+            {
+                _ = a.ToJson();
+            });
+            _ = b.PrimitiveCollection(c => c.Tags);
+            _ = b.PrimitiveCollection(c => c.Scores);
+        });
+    }
+}

SqlServerSimulator.Tests/JsonScalarTests.cs

@@ -0,0 +1,141 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Behavioral tests for the <c>JSON_VALUE</c> and <c>JSON_MODIFY</c>
+/// scalar functions. These cover the EF Core 10 owned-types-as-JSON
+/// read + partial-update emissions and a few raw-SQL shapes documented
+/// against SQL Server 2025.
+/// </summary>
+[TestClass]
+public sealed class JsonScalarTests
+{
+    [TestMethod]
+    public void JsonValue_PropertyAccess()
+        => AreEqual("Springfield", ExecuteScalar("select json_value('{\"city\":\"Springfield\",\"zip\":\"12345\"}', '$.city')"));
+
+    [TestMethod]
+    public void JsonValue_MissingPath_ReturnsNullLax()
+        => IsInstanceOfType<DBNull>(ExecuteScalar("select json_value('{\"city\":\"X\"}', '$.missing')"));
+
+    [TestMethod]
+    public void JsonValue_NullJson_ReturnsNull()
+        => IsInstanceOfType<DBNull>(ExecuteScalar("select json_value(null, '$.x')"));
+
+    [TestMethod]
+    public void JsonValue_NullPath_ReturnsNull()
+        => IsInstanceOfType<DBNull>(ExecuteScalar("select json_value('{\"x\":1}', null)"));
+
+    [TestMethod]
+    public void JsonValue_BooleanValue_ReturnsLowercaseLiteral()
+        => AreEqual("true", ExecuteScalar("select json_value('{\"flag\":true}', '$.flag')"));
+
+    [TestMethod]
+    public void JsonValue_NumberValue_ReturnsRawText()
+        => AreEqual("42", ExecuteScalar("select json_value('{\"n\":42}', '$.n')"));
+
+    [TestMethod]
+    public void JsonValue_NullJsonValue_ReturnsNull()
+        => IsInstanceOfType<DBNull>(ExecuteScalar("select json_value('{\"n\":null}', '$.n')"));
+
+    /// <summary>Lax mode: scalar-only — non-scalar match yields NULL, not the JSON text.</summary>
+    [TestMethod]
+    public void JsonValue_ObjectMatch_ReturnsNullLax()
+        => IsInstanceOfType<DBNull>(ExecuteScalar("select json_value('{\"obj\":{\"a\":1}}', '$.obj')"));
+
+    [TestMethod]
+    public void JsonValue_ArrayMatch_ReturnsNullLax()
+        => IsInstanceOfType<DBNull>(ExecuteScalar("select json_value('{\"arr\":[1,2,3]}', '$.arr')"));
+
+    [TestMethod]
+    public void JsonValue_NestedPropertyAccess()
+        => AreEqual("inner", ExecuteScalar("select json_value('{\"a\":{\"b\":{\"c\":\"inner\"}}}', '$.a.b.c')"));
+
+    [TestMethod]
+    public void JsonValue_ArrayIndex()
+        => AreEqual("middle", ExecuteScalar("select json_value('{\"items\":[\"first\",\"middle\",\"last\"]}', '$.items[1]')"));
+
+    /// <summary>
+    /// EF Core 10 emits this exact shape when transferring a value through a
+    /// parameter wrapped as <c>{"":"&lt;value&gt;"}</c> so JSON_VALUE handles
+    /// parameter type detection without needing per-type SqlParameter typing.
+    /// </summary>
+    [TestMethod]
+    public void JsonValue_QuotedPropertyEmpty_EfWrapShape()
+        => AreEqual("Shelbyville", ExecuteScalar("select json_value('{\"\":\"Shelbyville\"}', '$.\"\"')"));
+
+    [TestMethod]
+    public void JsonValue_InvalidJson_ReturnsNullLax()
+        => IsInstanceOfType<DBNull>(ExecuteScalar("select json_value('{not valid}', '$.x')"));
+
+    [TestMethod]
+    public void JsonValue_StrictPrefix_OnMissingPathRaises()
+        => AssertSqlError("select json_value('{\"a\":1}', 'strict $.missing')", 13608,
+            "Property cannot be found on the specified JSON path.");
+
+    [TestMethod]
+    public void JsonValue_LaxPrefix_ExplicitParses()
+        => AreEqual("v", ExecuteScalar("select json_value('{\"a\":\"v\"}', 'lax $.a')"));
+
+    [TestMethod]
+    public void JsonValue_InvalidPath_RaisesMsg13607()
+        => AssertSqlError("select json_value('{}', 'no-leading-dollar')", 13607);
+
+    [TestMethod]
+    public void JsonModify_ReplaceExistingProperty()
+        => AreEqual("{\"city\":\"New\"}", ExecuteScalar("select json_modify('{\"city\":\"Old\"}', '$.city', 'New')"));
+
+    [TestMethod]
+    public void JsonModify_ReplaceNestedProperty()
+        => AreEqual("{\"a\":{\"b\":\"Y\"}}", ExecuteScalar("select json_modify('{\"a\":{\"b\":\"X\"}}', '$.a.b', 'Y')"));
+
+    [TestMethod]
+    public void JsonModify_AppendToArray()
+        => AreEqual("[1,2,3,4]", ExecuteScalar("select json_modify('[1,2,3]', '$[3]', 4)"));
+
+    [TestMethod]
+    public void JsonModify_ReplaceArrayElement()
+        => AreEqual("[1,99,3]", ExecuteScalar("select json_modify('[1,2,3]', '$[1]', 99)"));
+
+    [TestMethod]
+    public void JsonModify_LaxMissing_AddsProperty()
+        => AreEqual("{\"a\":1,\"b\":2}", ExecuteScalar("select json_modify('{\"a\":1}', '$.b', 2)"));
+
+    [TestMethod]
+    public void JsonModify_LaxNullValue_RemovesExistingProperty()
+        => AreEqual("{\"a\":1}", ExecuteScalar("select json_modify('{\"a\":1,\"b\":2}', '$.b', null)"));
+
+    [TestMethod]
+    public void JsonModify_StrictMissing_RaisesMsg13608()
+        => AssertSqlError("select json_modify('{\"a\":1}', 'strict $.b', 'x')", 13608,
+            "Property cannot be found on the specified JSON path.");
+
+    [TestMethod]
+    public void JsonModify_StrictArrayOob_RaisesMsg13608()
+        => AssertSqlError("select json_modify('[1,2]', 'strict $[5]', 99)", 13608);
+
+    [TestMethod]
+    public void JsonModify_NullJson_ReturnsNull()
+        => IsInstanceOfType<DBNull>(ExecuteScalar("select json_modify(null, '$.x', 1)"));
+
+    [TestMethod]
+    public void JsonModify_NumericValue_StaysJsonNumber()
+        => AreEqual("{\"n\":42}", ExecuteScalar("select json_modify('{\"n\":0}', '$.n', 42)"));
+
+    [TestMethod]
+    public void JsonModify_BooleanValue_StaysJsonBoolean()
+        => AreEqual("{\"flag\":true}", ExecuteScalar("select json_modify('{\"flag\":false}', '$.flag', cast(1 as bit))"));
+
+    // The EF Core 10 SaveChanges shape for partial-update of an owned-as-JSON
+    // scalar property: JSON_MODIFY with strict path + JSON_VALUE-from-parameter.
+    [TestMethod]
+    public void JsonModify_EfPartialUpdateShape()
+    {
+        var simulation = new Simulation();
+        AreEqual(
+            "{\"City\":\"Shelbyville\",\"Street\":\"1 Main\"}",
+            simulation.ExecuteScalar("select json_modify('{\"City\":\"Springfield\",\"Street\":\"1 Main\"}', 'strict $.City', json_value('{\"\":\"Shelbyville\"}', '$.\"\"'))"));
+    }
+}