feat(sql): construct Postgres and Oracle providers; MySql/Odbc stay reserved

Widens the two provider gates so an authored `{"provider":"Postgres"}` or
`{"provider":"Oracle"}` binds that provider's own dialect instead of failing
"not available in this build":

- `SqlDriverFactoryExtensions.CreateDialect` gains a Postgres and an Oracle
  arm. There is deliberately no fallback arm — a default resolving to
  SqlServerDialect would construct happily and then emit T-SQL at a Postgres
  or Oracle server. The rejection message now names the three supported and
  the two still-reserved providers.
- `SqlDriverBrowser.DefaultDialectSelector` widens identically, so a provider
  the runtime constructs is also browsable; MySql/Odbc keep resolving to null
  and the caller keeps reporting them as unavailable.

Tests: the existing rejected-provider controls flip from Postgres to MySql
(factory) and Odbc (browser) so the reserved half stays falsifiable, and the
new legs assert the bound dialect TYPE rather than mere construction —
"no throw" alone would pass against a SqlServer fallback.

Doc-comment sweep (contract addition, one line each): the "v1 constructs
SqlServer only" / "reserved for P2" claims in SqlProvider, SqlDriverConfigDto,
ISqlDialect.Provider and SqlServerDialect are now false and were corrected in
the same change.

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Sql.Browser/SqlDriverBrowser.cs

@@ -80,8 +80,8 @@ public sealed class SqlDriverBrowser : IDriverBrowser
     /// <param name="dialectSelector">
     ///     Maps an authored <see cref="SqlProvider"/> onto the dialect that browses it, or <see langword="null"/>
     ///     for a provider this build does not carry. Defaults to <see cref="DefaultDialectSelector"/>
-    ///     (SqlServer only, in v1). A constructor parameter rather than a test hatch: it is also how a P2
-    ///     provider gets added without touching this class.
+    ///     (SqlServer, Postgres and Oracle). A constructor parameter rather than a test hatch: it is also how
+    ///     a further provider gets added without touching this class.
     /// </param>
     /// <param name="environmentReader">
     ///     Reads one environment variable. Defaults to <see cref="Environment.GetEnvironmentVariable(string)"/>.
@@ -117,14 +117,23 @@ public sealed class SqlDriverBrowser : IDriverBrowser
         ConnectionStringEnvironmentPrefix + connectionStringRef;
 
     /// <summary>
-    ///     The providers this build can browse. v1 constructs SQL Server only; every other
-    ///     <see cref="SqlProvider"/> member is a reserved name, so it resolves to <see langword="null"/> and
-    ///     the caller reports it as unavailable rather than crashing on a null dialect.
+    ///     The providers this build can browse — SQL Server, PostgreSQL and Oracle. The remaining
+    ///     <see cref="SqlProvider"/> members (<see cref="SqlProvider.MySql"/>, <see cref="SqlProvider.Odbc"/>)
+    ///     are reserved names, so they resolve to <see langword="null"/> and the caller reports them as
+    ///     unavailable rather than crashing on a null dialect.
+    ///     <para>Kept in step with <c>SqlDriverFactoryExtensions.CreateDialect</c>: a provider the runtime
+    ///     driver constructs but the browser cannot select would leave the operator authoring tags by hand
+    ///     against a database the AdminUI refuses to show them.</para>
     /// </summary>
     /// <param name="provider">The authored provider.</param>
     /// <returns>The dialect, or <see langword="null"/> when this build does not carry the provider.</returns>
-    public static ISqlDialect? DefaultDialectSelector(SqlProvider provider) =>
-        provider == SqlProvider.SqlServer ? new SqlServerDialect() : null;
+    public static ISqlDialect? DefaultDialectSelector(SqlProvider provider) => provider switch
+    {
+        SqlProvider.SqlServer => new SqlServerDialect(),
+        SqlProvider.Postgres => new PostgresDialect(),
+        SqlProvider.Oracle => new OracleDialect(),
+        _ => null,
+    };
 
     /// <inheritdoc />
     /// <exception cref="InvalidOperationException">
@@ -143,12 +152,13 @@ public sealed class SqlDriverBrowser : IDriverBrowser
         var literal = ReadPastedConnectionString(configJson);
         var config = Deserialize(configJson, literal);
 
-        // Provider first: "this build cannot browse Postgres" is true regardless of how the database is
+        // Provider first: "this build cannot browse MySql" is true regardless of how the database is
         // named, and answering it before touching the environment keeps the two failures from masking.
         var dialect = _dialectSelector(config.Provider)
             ?? throw new InvalidOperationException(
-                $"Sql provider '{config.Provider}' is not available in this build; v1 browses "
-                + $"'{SqlProvider.SqlServer}' only.");
+                $"Sql provider '{config.Provider}' is not available in this build; browsing supports "
+                + $"'{SqlProvider.SqlServer}', '{SqlProvider.Postgres}' and '{SqlProvider.Oracle}' "
+                + $"('{SqlProvider.MySql}' and '{SqlProvider.Odbc}' are reserved names).");
 
         var reference = config.ConnectionStringRef;
         var connectionString = ResolveConnectionString(literal, reference);

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts/SqlDriverConfigDto.cs

@@ -16,7 +16,7 @@ namespace ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts;
 /// </summary>
 public sealed class SqlDriverConfigDto
 {
-    /// <summary>Which ADO.NET provider/dialect backs this instance. Defaults to <see cref="SqlProvider.SqlServer"/> — the only provider v1 constructs.</summary>
+    /// <summary>Which ADO.NET provider/dialect backs this instance. Defaults to <see cref="SqlProvider.SqlServer"/>; <see cref="SqlProvider.Postgres"/> and <see cref="SqlProvider.Oracle"/> are also constructed.</summary>
     public SqlProvider Provider { get; init; } = SqlProvider.SqlServer;
 
     /// <summary>

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts/SqlProvider.cs

@@ -1,21 +1,25 @@
 namespace ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts;
 
-/// <summary>Which ADO.NET provider/dialect backs a Sql driver instance. v1 constructs only SqlServer.</summary>
+/// <summary>
+///     Which ADO.NET provider/dialect backs a Sql driver instance. <b>Constructed:</b> SqlServer, Postgres,
+///     Oracle — each over a fully managed provider package, no native client install. <b>Reserved:</b> MySql
+///     and Odbc are declared names only; authoring one fails at driver construction and at browse.
+/// </summary>
 public enum SqlProvider
 {
-    /// <summary>Microsoft SQL Server via <c>Microsoft.Data.SqlClient</c> — the only provider v1 constructs.</summary>
+    /// <summary>Microsoft SQL Server via <c>Microsoft.Data.SqlClient</c>.</summary>
     SqlServer,
 
-    /// <summary>PostgreSQL (Npgsql) — reserved for P2; not constructed in v1.</summary>
+    /// <summary>PostgreSQL via the managed <c>Npgsql</c> provider.</summary>
     Postgres,
 
-    /// <summary>MySQL / MariaDB — reserved; not constructed in v1.</summary>
+    /// <summary>MySQL / MariaDB — reserved; no dialect ships, so this is not constructed.</summary>
     MySql,
 
-    /// <summary>Generic ODBC — reserved for P2; not constructed in v1.</summary>
+    /// <summary>Generic ODBC — reserved; no dialect ships, so this is not constructed.</summary>
     Odbc,
 
-    /// <summary>Oracle — reserved; not constructed in v1.</summary>
+    /// <summary>Oracle Database via the fully managed <c>Oracle.ManagedDataAccess.Core</c> provider.</summary>
     Oracle,
 }
 

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Sql.Dialect/ISqlDialect.cs

@@ -28,7 +28,11 @@ namespace ZB.MOM.WW.OtOpcUa.Driver.Sql;
 /// </summary>
 public interface ISqlDialect
 {
-    /// <summary>Which backend this dialect speaks. v1 constructs <see cref="SqlProvider.SqlServer"/> only.</summary>
+    /// <summary>
+    ///     Which backend this dialect speaks. One implementation ships per constructed
+    ///     <see cref="SqlProvider"/> member — <see cref="SqlProvider.SqlServer"/>,
+    ///     <see cref="SqlProvider.Postgres"/> and <see cref="SqlProvider.Oracle"/>.
+    /// </summary>
     SqlProvider Provider { get; }
 
     /// <summary>

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Sql.Dialect/SqlServerDialect.cs

@@ -7,7 +7,7 @@ using ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts;
 namespace ZB.MOM.WW.OtOpcUa.Driver.Sql;
 
 /// <summary>
-///     Microsoft SQL Server dialect (design §2.2) — the only provider v1 constructs. Bracket quoting,
+///     Microsoft SQL Server dialect (design §2.2) — the default provider. Bracket quoting,
 ///     <c>INFORMATION_SCHEMA</c> catalog SQL, and the design §3.7 type-family map.
 ///     <para>Stateless and immutable, so a single instance is safely shared by the driver's poll reader and
 ///     the AdminUI browse session.</para>

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Sql/SqlDriverFactoryExtensions.cs

@@ -201,17 +201,27 @@ public static class SqlDriverFactoryExtensions
 
     /// <summary>
     ///     Selects the provider seam.
-    ///     <para>v1 constructs <see cref="SqlProvider.SqlServer"/> only. The other members exist on the shipped
-    ///     enum as reserved names; authoring one is a config mistake that must fail at construction with a
-    ///     message that says so, rather than silently degrading to T-SQL against a non-SQL-Server database.</para>
+    ///     <para>This build constructs <see cref="SqlProvider.SqlServer"/>, <see cref="SqlProvider.Postgres"/>
+    ///     and <see cref="SqlProvider.Oracle"/>. <see cref="SqlProvider.MySql"/> and
+    ///     <see cref="SqlProvider.Odbc"/> remain reserved names on the shipped enum; authoring one is a config
+    ///     mistake that must fail at construction with a message that says so, rather than silently degrading
+    ///     to another backend's SQL dialect against a database that does not speak it.</para>
+    ///     <para><b>Every arm returns that provider's OWN dialect — there is no fallback arm.</b> A default
+    ///     that resolved to <see cref="SqlServerDialect"/> would construct happily and then emit T-SQL
+    ///     (<c>INFORMATION_SCHEMA</c>, <c>TOP 1</c>, <c>@</c> markers) at a Postgres or Oracle server, which
+    ///     fails at poll time as an unintelligible provider error rather than here as a config error.</para>
     /// </summary>
     private static ISqlDialect CreateDialect(SqlProvider provider, string driverInstanceId)
         => provider switch
         {
             SqlProvider.SqlServer => new SqlServerDialect(),
+            SqlProvider.Postgres => new PostgresDialect(),
+            SqlProvider.Oracle => new OracleDialect(),
             _ => throw new InvalidOperationException(
                 $"Sql driver config for '{driverInstanceId}' names provider '{provider}', which is not " +
-                $"available in this build. Only '{nameof(SqlProvider.SqlServer)}' is supported."),
+                $"available in this build. Supported: '{nameof(SqlProvider.SqlServer)}', " +
+                $"'{nameof(SqlProvider.Postgres)}', '{nameof(SqlProvider.Oracle)}'. Reserved (declared on " +
+                $"the enum but not implemented): '{nameof(SqlProvider.MySql)}', '{nameof(SqlProvider.Odbc)}'."),
         };
 
     /// <summary>

tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Sql.Browser.Tests/SqlDriverBrowserTests.cs

@@ -45,12 +45,21 @@ public sealed class SqlDriverBrowserTests
         new SqlDriverBrowser().DriverType.ShouldBe(SqlDriver.DriverTypeName);
     }
 
+    /// <summary>
+    ///     The browse-side gate, asserted as a partition of the whole enum: the three carried providers each
+    ///     resolve to <b>their own</b> dialect, and every remaining member resolves to <see langword="null"/>.
+    ///     Enumerating <see cref="Enum.GetValues{TEnum}"/> for the reserved half is what makes a future enum
+    ///     member fail here rather than silently browse as SQL Server.
+    /// </summary>
     [Fact]
-    public void DefaultDialectSelector_carriesSqlServerOnly()
+    public void DefaultDialectSelector_carriesSqlServerPostgresAndOracle()
     {
         SqlDriverBrowser.DefaultDialectSelector(SqlProvider.SqlServer).ShouldBeOfType<SqlServerDialect>();
+        SqlDriverBrowser.DefaultDialectSelector(SqlProvider.Postgres).ShouldBeOfType<PostgresDialect>();
+        SqlDriverBrowser.DefaultDialectSelector(SqlProvider.Oracle).ShouldBeOfType<OracleDialect>();
 
-        foreach (var provider in Enum.GetValues<SqlProvider>().Where(p => p != SqlProvider.SqlServer))
+        SqlProvider[] carried = [SqlProvider.SqlServer, SqlProvider.Postgres, SqlProvider.Oracle];
+        foreach (var provider in Enum.GetValues<SqlProvider>().Where(p => !carried.Contains(p)))
             SqlDriverBrowser.DefaultDialectSelector(provider).ShouldBeNull();
     }
 
@@ -178,6 +187,10 @@ public sealed class SqlDriverBrowserTests
 
     // ---- provider availability ----
 
+    /// <summary>
+    ///     The falsifiability control for the widened browse gate: <see cref="SqlProvider.MySql"/> is still
+    ///     reserved and must be reported as unavailable, naming itself.
+    /// </summary>
     [Fact]
     public async Task Open_providerThisBuildDoesNotCarry_saysNotAvailableInThisBuild()
     {
@@ -185,15 +198,15 @@ public sealed class SqlDriverBrowserTests
 
         var ex = await Should.ThrowAsync<InvalidOperationException>(() =>
             browser.OpenAsync(
-                ConfigJson("Postgres", connectionStringRef: "MesStaging"), CancellationToken.None));
+                ConfigJson("MySql", connectionStringRef: "MesStaging"), CancellationToken.None));
 
-        ex.Message.ShouldContain("Postgres");
+        ex.Message.ShouldContain("MySql");
         ex.Message.ShouldContain("not available in this build");
     }
 
     /// <summary>
     ///     Provider availability is answered before the environment is touched: "this build cannot browse
-    ///     Postgres" is true whatever the ref resolves to, and the two failures must not mask each other.
+    ///     MySql" is true whatever the ref resolves to, and the two failures must not mask each other.
     /// </summary>
     [Fact]
     public async Task Open_unavailableProviderAndUnresolvableRef_reportsTheProvider()
@@ -203,12 +216,34 @@ public sealed class SqlDriverBrowserTests
 
         var ex = await Should.ThrowAsync<InvalidOperationException>(() =>
             browser.OpenAsync(
-                ConfigJson("Oracle", connectionStringRef: "MesStaging"), CancellationToken.None));
+                ConfigJson("Odbc", connectionStringRef: "MesStaging"), CancellationToken.None));
 
         ex.Message.ShouldContain("not available in this build");
         reads.ShouldBeEmpty();
     }
 
+    /// <summary>
+    ///     A carried provider must get <b>past</b> the provider gate and on to the environment, so that a
+    ///     Postgres or Oracle browse fails (if at all) on the connection string rather than on availability.
+    ///     Asserted through the reads list: reaching the environment reader is the observable proof the gate
+    ///     let the provider through.
+    /// </summary>
+    [Theory]
+    [InlineData("Postgres")]
+    [InlineData("Oracle")]
+    public async Task Open_aCarriedProvider_passesTheGateAndResolvesTheRef(string provider)
+    {
+        var reads = new List<string>();
+        var browser = new SqlDriverBrowser(environmentReader: name => { reads.Add(name); return null; });
+
+        var ex = await Should.ThrowAsync<InvalidOperationException>(() =>
+            browser.OpenAsync(
+                ConfigJson(provider, connectionStringRef: "MesStaging"), CancellationToken.None));
+
+        ex.Message.ShouldNotContain("not available in this build");
+        reads.ShouldContain(SqlDriverBrowser.EnvironmentVariableFor("MesStaging"));
+    }
+
     // ---- malformed configuration ----
 
     [Theory]

tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Sql.Tests/SqlDriverFactoryTests.cs

@@ -122,6 +122,11 @@ public sealed class SqlDriverFactoryTests
 
     // ---- provider gate ----
 
+    /// <summary>
+    ///     The falsifiability control for the widened gate: <see cref="SqlProvider.MySql"/> is still a
+    ///     reserved name and must fail loudly at construction, naming itself. Without this leg, a gate that
+    ///     had quietly become "construct anything" would pass every test below.
+    /// </summary>
     [Fact]
     public void CreateInstance_aProviderThisBuildCannotConstruct_throwsSayingSo()
     {
@@ -130,12 +135,73 @@ public sealed class SqlDriverFactoryTests
             SqlConnectionStringResolver.EnvironmentVariableFor(name), "Host=h;Database=db");
 
         var ex = Should.Throw<InvalidOperationException>(() => SqlDriverFactoryExtensions.CreateInstance(
-            "d1", $$"""{"provider":"Postgres","connectionStringRef":"{{name}}"}""", null));
+            "d1", $$"""{"provider":"MySql","connectionStringRef":"{{name}}"}""", null));
 
-        ex.Message.ShouldContain("Postgres");
+        ex.Message.ShouldContain("MySql");
         ex.Message.ShouldContain("not available in this build");
     }
 
+    /// <summary>
+    ///     The reserved names are named as reserved — an operator reading the rejection must be able to tell
+    ///     "misspelled" from "this build does not carry it", so the message enumerates both halves.
+    /// </summary>
+    [Fact]
+    public void CreateInstance_aReservedProvider_namesTheSupportedAndTheReservedSets()
+    {
+        var name = NewRef();
+        using var _ = new EnvironmentVariableScope(
+            SqlConnectionStringResolver.EnvironmentVariableFor(name), "Host=h;Database=db");
+
+        var ex = Should.Throw<InvalidOperationException>(() => SqlDriverFactoryExtensions.CreateInstance(
+            "d1", $$"""{"provider":"Odbc","connectionStringRef":"{{name}}"}""", null));
+
+        ex.Message.ShouldContain(nameof(SqlProvider.SqlServer));
+        ex.Message.ShouldContain(nameof(SqlProvider.Postgres));
+        ex.Message.ShouldContain(nameof(SqlProvider.Oracle));
+    }
+
+    /// <summary>
+    ///     The widened gate, asserted on the thing that actually varies: which dialect the config binds to.
+    ///     Binding — not merely "no throw" — is what proves the provider reaches the poll path, since a gate
+    ///     that fell through to <c>SqlServerDialect</c> would also construct without complaint and then speak
+    ///     T-SQL at a Postgres server.
+    /// </summary>
+    [Theory]
+    [InlineData("SqlServer", typeof(SqlServerDialect))]
+    [InlineData("Postgres", typeof(PostgresDialect))]
+    [InlineData("Oracle", typeof(OracleDialect))]
+    public void ParseBinding_aSupportedProvider_bindsThatProvidersDialect(string provider, Type expected)
+    {
+        var name = NewRef();
+        using var _ = new EnvironmentVariableScope(
+            SqlConnectionStringResolver.EnvironmentVariableFor(name), "Host=h;Database=db");
+
+        var binding = SqlDriverFactoryExtensions.ParseBinding(
+            "d1", $$"""{"provider":"{{provider}}","connectionStringRef":"{{name}}"}""");
+
+        binding.Dialect.ShouldBeOfType(expected);
+        binding.Dialect.Provider.ShouldBe(Enum.Parse<SqlProvider>(provider));
+    }
+
+    /// <summary>
+    ///     End-to-end through the registered factory entry point, so the widening is proven on the path the
+    ///     bootstrapper actually calls — not only on the internal parse.
+    /// </summary>
+    [Theory]
+    [InlineData("Postgres")]
+    [InlineData("Oracle")]
+    public async Task CreateInstance_aNewlySupportedProvider_constructsPastTheProviderGate(string provider)
+    {
+        var name = NewRef();
+        using var _ = new EnvironmentVariableScope(
+            SqlConnectionStringResolver.EnvironmentVariableFor(name), "Host=h;Database=db");
+
+        await using var driver = SqlDriverFactoryExtensions.CreateInstance(
+            "d1", $$"""{"provider":"{{provider}}","connectionStringRef":"{{name}}"}""", null);
+
+        driver.ShouldNotBeNull();
+    }
+
     // ---- config validation (the reader and the shell deliberately do NOT do this) ----
 
     [Fact]