merge: Sql driver Postgres + Oracle providers (managed Npgsql/ODP.NET, dialect-owned binding, live-gated fixtures)
This commit is contained in:
Joseph Doherty
@@ -371,4 +371,31 @@ public sealed class SqlBrowseSessionTests
|
||||
await session.AttributesAsync(columnNodeId, CancellationToken.None);
|
||||
session.LastUsedUtc.ShouldBeGreaterThan(afterExpand);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The browse path binds the <em>dialect's</em> parameter names, not a hardcoded <c>"@schema"</c>.
|
||||
/// Driven through <see cref="ColonMarkerDialect"/> (markers <c>:schema</c>/<c>:table</c>, bare bind
|
||||
/// names) — ODP.NET's shape, and the only place the two spellings differ.
|
||||
/// <para>Discriminating in two independent ways: a session still binding <c>"@schema"</c> leaves the
|
||||
/// colon marker unbound (the expand yields nothing, or the provider refuses the command), and the
|
||||
/// recorded names would carry the prefix.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task TheCatalogParameters_areBoundUnderTheDialectsBindNames()
|
||||
{
|
||||
await using var db = await SqliteBrowseFixture.CreateAsync();
|
||||
var dialect = new ColonMarkerDialect();
|
||||
await using var session = new SqlBrowseSession(db.Connection, dialect);
|
||||
|
||||
var tableNode = (await session.ExpandAsync(SchemaNodeId, CancellationToken.None))
|
||||
.First(n => n.DisplayName == SqliteBrowseFixture.KeyValueTable);
|
||||
var columns = await session.ExpandAsync(tableNode.NodeId, CancellationToken.None);
|
||||
|
||||
columns.ShouldContain(c => c.DisplayName == SqliteBrowseFixture.RealColumn);
|
||||
dialect.BoundParameterNames.ShouldContain("schema");
|
||||
dialect.BoundParameterNames.ShouldContain("table");
|
||||
dialect.BoundParameterNames.ShouldNotContain(n => n.StartsWith(':'));
|
||||
// Every catalog command went through the provider hook (Oracle's BindByName lives there).
|
||||
dialect.ConfiguredCommands.ShouldBe(2);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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]
|
||||
|
||||
+7
@@ -45,6 +45,13 @@
|
||||
— see its class docs.
|
||||
-->
|
||||
<Compile Include="..\ZB.MOM.WW.OtOpcUa.Driver.Sql.Tests\SqliteDialect.cs" Link="SqliteDialect.cs"/>
|
||||
<!--
|
||||
Linked for the same reason and on the same terms: ColonMarkerDialect is the control for
|
||||
dialect-owned parameter naming (":schema" in the text, bare "schema" on the parameter — ODP.NET's
|
||||
shape), and the browse session binds those names. It decorates SqliteDialect, which is already
|
||||
linked above, so the pair travels together.
|
||||
-->
|
||||
<Compile Include="..\ZB.MOM.WW.OtOpcUa.Driver.Sql.Tests\ColonMarkerDialect.cs" Link="ColonMarkerDialect.cs"/>
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
|
||||
+81
@@ -0,0 +1,81 @@
|
||||
# Dedicated, DISPOSABLE Oracle Database Free for the Sql driver's Oracle live gate
|
||||
# (OracleReadTests).
|
||||
#
|
||||
# ── SAFETY ─────────────────────────────────────────────────────────────────────
|
||||
# This stack owns its OWN container, `otopcua-sql-oracle`, on host port 11521 — deliberately not
|
||||
# the default 1521, so it can never be confused with a real Oracle listener on the rig. `restart:
|
||||
# "no"` so a killed container stays down rather than respawning.
|
||||
#
|
||||
# ── DEPLOY (docker runs on the shared Linux host, 10.100.0.35) ──────────────────
|
||||
# # from a Windows VM:
|
||||
# lmxopcua-fix sync sql-oracle # rsync this dir → /opt/otopcua-sql-oracle/
|
||||
# lmxopcua-fix up sql-oracle # single-service stack (+ one-shot seed), no profile arg
|
||||
#
|
||||
# # from macOS (there is no lmxopcua-fix there — drive the host over SSH):
|
||||
# rsync -av tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Sql.IntegrationTests/Docker/oracle/ \
|
||||
# dohertj2@10.100.0.35:/opt/otopcua-sql-oracle/
|
||||
# ssh dohertj2@10.100.0.35 'cd /opt/otopcua-sql-oracle && SQL_ORACLE_PASSWORD=... docker compose up -d'
|
||||
#
|
||||
# ⚠️ FIRST START TAKES MINUTES, not seconds — the image creates the database on first boot. The
|
||||
# healthcheck's start_period reflects that; the seed one-shot simply waits for it.
|
||||
#
|
||||
# ── RUN THE GATE ───────────────────────────────────────────────────────────────
|
||||
# export SQL_ORACLE_ENDPOINT=10.100.0.35:11521
|
||||
# export SQL_ORACLE_USER=otopcua # optional; this is the default
|
||||
# export SQL_ORACLE_PASSWORD=... # the same value this compose was brought up with
|
||||
# export SQL_ORACLE_SERVICE=FREEPDB1 # optional; this is the default (the image's PDB)
|
||||
# dotnet test tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Sql.IntegrationTests \
|
||||
# --filter "FullyQualifiedName~OracleReadTests"
|
||||
#
|
||||
# The one-shot `oracle-seed` service applies seed-oracle.sql once the server is healthy. The
|
||||
# gvenzl images also auto-run scripts mounted at /container-entrypoint-initdb.d, but that path
|
||||
# runs ONLY on the very first boot of an empty data volume — a re-seed after editing the script
|
||||
# would silently not happen. The one-shot service matches the mssql fixture and re-runs every
|
||||
# `docker compose up`, which is why it is used here.
|
||||
|
||||
name: otopcua-sql-oracle
|
||||
|
||||
services:
|
||||
oracle:
|
||||
image: gvenzl/oracle-free:23-slim
|
||||
container_name: otopcua-sql-oracle
|
||||
labels:
|
||||
project: lmxopcua
|
||||
restart: "no"
|
||||
environment:
|
||||
# SYS/SYSTEM password. Dev-only sandbox value for a throwaway container.
|
||||
ORACLE_PASSWORD: "${SQL_ORACLE_PASSWORD:-Oracle_dev_pw1}"
|
||||
# The image creates this non-SYS user (and its schema) inside the FREEPDB1 pluggable
|
||||
# database. It is the principal the suite connects as — nothing here ever uses SYS.
|
||||
APP_USER: otopcua
|
||||
APP_USER_PASSWORD: "${SQL_ORACLE_PASSWORD:-Oracle_dev_pw1}"
|
||||
ports:
|
||||
- "11521:1521"
|
||||
healthcheck:
|
||||
# healthcheck.sh ships in the image and reports the database OPEN, not merely the listener up.
|
||||
test: ["CMD", "healthcheck.sh"]
|
||||
interval: 15s
|
||||
timeout: 10s
|
||||
retries: 40
|
||||
start_period: 180s
|
||||
|
||||
# One-shot seed: waits for the database to pass its healthcheck, applies seed-oracle.sql, exits.
|
||||
# Reuses the server image purely because it already carries sqlplus.
|
||||
oracle-seed:
|
||||
image: gvenzl/oracle-free:23-slim
|
||||
labels:
|
||||
project: lmxopcua
|
||||
restart: "no"
|
||||
depends_on:
|
||||
oracle:
|
||||
condition: service_healthy
|
||||
environment:
|
||||
APP_USER_PASSWORD: "${SQL_ORACLE_PASSWORD:-Oracle_dev_pw1}"
|
||||
volumes:
|
||||
- ./seed-oracle.sql:/seed.sql:ro
|
||||
entrypoint:
|
||||
- "/bin/bash"
|
||||
- "-c"
|
||||
# -S silent, -L single login attempt (never prompt). The script's WHENEVER SQLERROR EXIT
|
||||
# makes a broken seed fail this service rather than leave a half-seeded schema behind.
|
||||
- "sqlplus -S -L otopcua/\"$${APP_USER_PASSWORD}\"@//oracle:1521/FREEPDB1 @/seed.sql"
|
||||
+76
@@ -0,0 +1,76 @@
|
||||
-- Seed for the Sql driver's Oracle live gate (OracleReadTests), applied once by the compose
|
||||
-- `oracle-seed` one-shot AS THE APPLICATION USER (otopcua) against the OWNED `otopcua-sql-oracle`
|
||||
-- container. Oracle equates a schema with a user, so everything below lands in the OTOPCUA schema.
|
||||
--
|
||||
-- The table shapes mirror the SQL Server fixture (SqlPollServerFixture) row for row — a present
|
||||
-- value, a present row with a NULL cell, and a wide-row table whose NEWEST row is deliberately not
|
||||
-- its first — so the same assertions can be made against both backends and a divergence between
|
||||
-- the two provider paths shows up as a failing assertion rather than as two suites that quietly
|
||||
-- test different things.
|
||||
--
|
||||
-- ⚠️ EVERY IDENTIFIER HERE IS UNQUOTED, AND THAT IS THE POINT. Oracle upper-cases an unquoted
|
||||
-- identifier, so the catalog stores OTOPCUA / TAG_VALUES / TAG_NAME while an operator authoring a
|
||||
-- tag in the AdminUI naturally types lower case. The suite's case-folding leg authors the lower-case
|
||||
-- spelling and expects `SqlCatalogGate` to resolve it through `SqlCatalog.TryMatch` (exact-ordinal
|
||||
-- first, then a UNIQUE case-insensitive match) and substitute the catalog's own UPPER-case spelling
|
||||
-- before `OracleDialect.QuoteIdentifier` double-quotes it — which is load-bearing, because a quoted
|
||||
-- "tag_values" and a quoted "TAG_VALUES" are DIFFERENT objects to Oracle. Quoting a name here would
|
||||
-- make that leg meaningless.
|
||||
|
||||
WHENEVER SQLERROR EXIT SQL.SQLCODE
|
||||
SET FEEDBACK OFF
|
||||
SET DEFINE OFF
|
||||
|
||||
-- Drop-and-recreate rather than merge-or-insert: the seed is an assertion contract, and a leftover
|
||||
-- row from an older revision of this file would make a passing test meaningless. ORA-00942 (table
|
||||
-- does not exist) is the expected outcome on a first run and is the only error swallowed.
|
||||
BEGIN
|
||||
EXECUTE IMMEDIATE 'DROP TABLE tag_values PURGE';
|
||||
EXCEPTION
|
||||
WHEN OTHERS THEN IF SQLCODE != -942 THEN RAISE; END IF;
|
||||
END;
|
||||
/
|
||||
|
||||
BEGIN
|
||||
EXECUTE IMMEDIATE 'DROP TABLE latest_status PURGE';
|
||||
EXCEPTION
|
||||
WHEN OTHERS THEN IF SQLCODE != -942 THEN RAISE; END IF;
|
||||
END;
|
||||
/
|
||||
|
||||
-- Key-value (EAV) source: tag_name → num_value, with a source timestamp.
|
||||
-- num_value is NUMBER, Oracle's one numeric family — which OracleDialect.MapColumnType folds to
|
||||
-- Float64 (the documented under-specification; see that method's remarks).
|
||||
CREATE TABLE tag_values (
|
||||
tag_name VARCHAR2(128) NOT NULL,
|
||||
num_value NUMBER,
|
||||
sample_ts TIMESTAMP(3) NOT NULL
|
||||
);
|
||||
|
||||
INSERT INTO tag_values (tag_name, num_value, sample_ts)
|
||||
VALUES ('Line1.Speed', 42, TIMESTAMP '2026-07-24 10:00:00');
|
||||
INSERT INTO tag_values (tag_name, num_value, sample_ts)
|
||||
VALUES ('Line1.Temp', NULL, TIMESTAMP '2026-07-24 10:00:01');
|
||||
INSERT INTO tag_values (tag_name, num_value, sample_ts)
|
||||
VALUES ('Line1.Pressure', 3.5, TIMESTAMP '2026-07-24 10:00:02');
|
||||
|
||||
-- Wide-row source: one row per station, several value columns. Station 8 is inserted LAST and is
|
||||
-- also the newest sample, while station 7 is first — so a topByTimestamp plan that lost its
|
||||
-- ORDER BY … DESC (or its FETCH FIRST 1 ROWS ONLY) returns a different, wrong value rather than a
|
||||
-- coincidentally right one.
|
||||
CREATE TABLE latest_status (
|
||||
station_id NUMBER(10) NOT NULL,
|
||||
oven_temp NUMBER,
|
||||
pressure NUMBER,
|
||||
sample_ts TIMESTAMP(3) NOT NULL
|
||||
);
|
||||
|
||||
INSERT INTO latest_status (station_id, oven_temp, pressure, sample_ts)
|
||||
VALUES (7, 180.5, 1.2, TIMESTAMP '2026-07-24 10:00:00');
|
||||
INSERT INTO latest_status (station_id, oven_temp, pressure, sample_ts)
|
||||
VALUES (9, NULL, 1.6, TIMESTAMP '2026-07-24 10:00:01');
|
||||
INSERT INTO latest_status (station_id, oven_temp, pressure, sample_ts)
|
||||
VALUES (8, 210.25, 1.4, TIMESTAMP '2026-07-24 10:00:02');
|
||||
|
||||
COMMIT;
|
||||
EXIT;
|
||||
+78
@@ -0,0 +1,78 @@
|
||||
# Dedicated, DISPOSABLE PostgreSQL for the Sql driver's Postgres live gate (PostgresReadTests).
|
||||
#
|
||||
# ── SAFETY ─────────────────────────────────────────────────────────────────────
|
||||
# This stack owns its OWN postgres container, `otopcua-sql-pg`, on host port 15432.
|
||||
# Nothing else on the rig runs PostgreSQL, so there is no shared-server hazard of the
|
||||
# kind the mssql blackhole fixture guards against — but the same discipline applies:
|
||||
# a distinct container_name and a distinct host port, and `restart: "no"` so a killed
|
||||
# container stays down rather than respawning.
|
||||
#
|
||||
# ── DEPLOY (docker runs on the shared Linux host, 10.100.0.35) ──────────────────
|
||||
# # from a Windows VM:
|
||||
# lmxopcua-fix sync sql-pg # rsync this dir → /opt/otopcua-sql-pg/
|
||||
# lmxopcua-fix up sql-pg # single-service stack (+ one-shot seed), no profile arg
|
||||
#
|
||||
# # from macOS (there is no lmxopcua-fix there — drive the host over SSH):
|
||||
# rsync -av tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Sql.IntegrationTests/Docker/postgres/ \
|
||||
# dohertj2@10.100.0.35:/opt/otopcua-sql-pg/
|
||||
# ssh dohertj2@10.100.0.35 'cd /opt/otopcua-sql-pg && SQL_PG_PASSWORD=... docker compose up -d'
|
||||
#
|
||||
# ── RUN THE GATE ───────────────────────────────────────────────────────────────
|
||||
# export SQL_PG_ENDPOINT=10.100.0.35:15432
|
||||
# export SQL_PG_USER=otopcua # optional; this is the default
|
||||
# export SQL_PG_PASSWORD=... # the same value this compose was brought up with
|
||||
# dotnet test tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Sql.IntegrationTests \
|
||||
# --filter "FullyQualifiedName~PostgresReadTests"
|
||||
#
|
||||
# The one-shot `postgres-seed` service applies seed-pg.sql once the server is healthy, so
|
||||
# the stack is self-seeding. Unlike the mssql fixture the suite does NOT seed defensively
|
||||
# on connect: the seed creates ROLES (an owner role that is not the connecting principal),
|
||||
# which the read-only fixture login deliberately cannot do — see seed-pg.sql.
|
||||
|
||||
name: otopcua-sql-pg
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:17-alpine
|
||||
container_name: otopcua-sql-pg
|
||||
labels:
|
||||
project: lmxopcua
|
||||
restart: "no"
|
||||
environment:
|
||||
# Dev-only sandbox password for a throwaway container; the seed gives the unprivileged
|
||||
# `otopcua` login the SAME value, which is what the suite reads from SQL_PG_PASSWORD.
|
||||
POSTGRES_PASSWORD: "${SQL_PG_PASSWORD:-Sqlpg_dev_pw1}"
|
||||
POSTGRES_DB: sqlpollfixture
|
||||
ports:
|
||||
- "15432:5432"
|
||||
healthcheck:
|
||||
# pg_isready against the fixture database: the server accepting a connection to the
|
||||
# database the seed targets is the readiness signal, not merely a listening socket.
|
||||
test:
|
||||
- "CMD-SHELL"
|
||||
- "pg_isready -U postgres -d sqlpollfixture || exit 1"
|
||||
interval: 5s
|
||||
timeout: 5s
|
||||
retries: 12
|
||||
start_period: 10s
|
||||
|
||||
# One-shot seed: waits for the server to pass its healthcheck, applies seed-pg.sql, exits.
|
||||
postgres-seed:
|
||||
image: postgres:17-alpine
|
||||
labels:
|
||||
project: lmxopcua
|
||||
restart: "no"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
environment:
|
||||
PGPASSWORD: "${SQL_PG_PASSWORD:-Sqlpg_dev_pw1}"
|
||||
APP_PASSWORD: "${SQL_PG_PASSWORD:-Sqlpg_dev_pw1}"
|
||||
volumes:
|
||||
- ./seed-pg.sql:/seed.sql:ro
|
||||
entrypoint:
|
||||
- "/bin/sh"
|
||||
- "-c"
|
||||
# ON_ERROR_STOP=1 so a broken seed fails the service rather than leaving a half-seeded
|
||||
# database that makes a later test failure look like a driver bug.
|
||||
- "psql -v ON_ERROR_STOP=1 -v app_password=\"$${APP_PASSWORD}\" -h postgres -U postgres -d sqlpollfixture -f /seed.sql"
|
||||
+87
@@ -0,0 +1,87 @@
|
||||
-- Seed for the Sql driver's PostgreSQL live gate (PostgresReadTests), applied once by the
|
||||
-- compose `postgres-seed` one-shot as the superuser against the OWNED `otopcua-sql-pg` container.
|
||||
--
|
||||
-- The table shapes mirror the SQL Server fixture (SqlPollServerFixture) row for row — a present
|
||||
-- value, a present row with a NULL cell, and a wide-row table whose NEWEST row is deliberately not
|
||||
-- its first — so the same assertions can be made against both backends and a divergence between
|
||||
-- the two provider paths shows up as a failing assertion rather than as two suites that quietly
|
||||
-- test different things.
|
||||
--
|
||||
-- ── TWO THINGS HERE ARE LOAD-BEARING, NOT SCAFFOLDING ─────────────────────────────────────────
|
||||
--
|
||||
-- 1. The schema is owned by `sqlpoll_owner` and the suite connects as `otopcua`, which holds
|
||||
-- USAGE + SELECT and nothing else. That is the exact provisioning `PostgresDialect.ListSchemasSql`
|
||||
-- was written for: `information_schema.schemata` lists only schemas the current role OWNS, so a
|
||||
-- granted-not-owning read-only poller would see an empty schema list, `SqlCatalogLoader` would
|
||||
-- throw its "the catalog returned no schemas at all" grant diagnosis, and every tag would be
|
||||
-- rejected. Sourcing the schema list from `information_schema.tables` instead is what makes this
|
||||
-- work — and a fixture where the poller owned its own schema would pass either way, proving
|
||||
-- nothing. Do not "simplify" this by creating the tables as `otopcua`.
|
||||
--
|
||||
-- 2. Every identifier is created UNQUOTED, so Postgres folds it to lower case in the catalog. The
|
||||
-- suite's case-folding leg authors the same names in UPPER case and expects them to resolve
|
||||
-- through `SqlCatalog.TryMatch` (exact-ordinal first, then a UNIQUE case-insensitive match, which
|
||||
-- substitutes the catalog's own spelling). Quoting a name here would make the catalog spelling
|
||||
-- mixed case and that leg would stop meaning anything.
|
||||
|
||||
\set ON_ERROR_STOP on
|
||||
|
||||
-- ── roles ─────────────────────────────────────────────────────────────────────────────────────
|
||||
-- \gexec runs the row the SELECT produced, and produces no row when the role already exists —
|
||||
-- the idempotent CREATE ROLE idiom. A DO block cannot be used for the login role: psql does not
|
||||
-- interpolate :'app_password' inside a dollar-quoted body.
|
||||
SELECT 'CREATE ROLE sqlpoll_owner NOLOGIN'
|
||||
WHERE NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'sqlpoll_owner')
|
||||
\gexec
|
||||
|
||||
SELECT 'CREATE ROLE otopcua LOGIN'
|
||||
WHERE NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'otopcua')
|
||||
\gexec
|
||||
|
||||
-- Set (or re-set) the password every run, so re-seeding with a different SQL_PG_PASSWORD converges
|
||||
-- rather than leaving the suite unable to log in.
|
||||
ALTER ROLE otopcua LOGIN PASSWORD :'app_password';
|
||||
|
||||
-- ── schema ────────────────────────────────────────────────────────────────────────────────────
|
||||
-- Drop-and-recreate rather than merge-or-insert: the seed is an assertion contract, and a leftover
|
||||
-- row from an older revision of this file would make a passing test meaningless. The blast radius
|
||||
-- is bounded to this fixture-owned schema.
|
||||
DROP SCHEMA IF EXISTS sqlpoll CASCADE;
|
||||
CREATE SCHEMA sqlpoll AUTHORIZATION sqlpoll_owner;
|
||||
|
||||
-- Everything below is created AS THE OWNER, not as the superuser — see note 1 above.
|
||||
SET ROLE sqlpoll_owner;
|
||||
|
||||
-- Key-value (EAV) source: tag_name → num_value, with a source timestamp.
|
||||
CREATE TABLE sqlpoll.tag_values (
|
||||
tag_name varchar(128) NOT NULL,
|
||||
num_value double precision NULL,
|
||||
sample_ts timestamp(3) NOT NULL
|
||||
);
|
||||
|
||||
INSERT INTO sqlpoll.tag_values (tag_name, num_value, sample_ts)
|
||||
VALUES ('Line1.Speed', 42.0, TIMESTAMP '2026-07-24 10:00:00'),
|
||||
('Line1.Temp', NULL, TIMESTAMP '2026-07-24 10:00:01'),
|
||||
('Line1.Pressure', 3.5, TIMESTAMP '2026-07-24 10:00:02');
|
||||
|
||||
-- Wide-row source: one row per station, several value columns. Station 8 is inserted LAST and is
|
||||
-- also the newest sample, while station 7 is first — so a topByTimestamp plan that lost its
|
||||
-- ORDER BY … DESC (or its LIMIT 1) returns a different, wrong value rather than a coincidentally
|
||||
-- right one.
|
||||
CREATE TABLE sqlpoll.latest_status (
|
||||
station_id integer NOT NULL,
|
||||
oven_temp double precision NULL,
|
||||
pressure double precision NULL,
|
||||
sample_ts timestamp(3) NOT NULL
|
||||
);
|
||||
|
||||
INSERT INTO sqlpoll.latest_status (station_id, oven_temp, pressure, sample_ts)
|
||||
VALUES (7, 180.5, 1.2, TIMESTAMP '2026-07-24 10:00:00'),
|
||||
(9, NULL, 1.6, TIMESTAMP '2026-07-24 10:00:01'),
|
||||
(8, 210.25, 1.4, TIMESTAMP '2026-07-24 10:00:02');
|
||||
|
||||
RESET ROLE;
|
||||
|
||||
-- ── grants: USAGE + SELECT and nothing else ───────────────────────────────────────────────────
|
||||
GRANT USAGE ON SCHEMA sqlpoll TO otopcua;
|
||||
GRANT SELECT ON ALL TABLES IN SCHEMA sqlpoll TO otopcua;
|
||||
@@ -0,0 +1,545 @@
|
||||
using System.Data.Common;
|
||||
using System.Globalization;
|
||||
using System.Text.Json.Nodes;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.Commons.Browsing;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Sql.Browser;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.Sql.IntegrationTests;
|
||||
|
||||
/// <summary>
|
||||
/// The <c>Sql</c> driver against a <b>real Oracle Database</b>, over the fully managed ODP.NET provider
|
||||
/// (<c>Oracle.ManagedDataAccess.Core</c>) <c>OracleDialect</c> ships. Four things are exercised nowhere
|
||||
/// else in this driver's estate: the ODP.NET ADO.NET path, <c>OracleCommand.BindByName</c> against a
|
||||
/// real multi-parameter statement, the <c>ALL_*</c> catalog views that stand in for the
|
||||
/// <c>INFORMATION_SCHEMA</c> Oracle does not have, and <c>FETCH FIRST 1 ROWS ONLY</c> row limiting.
|
||||
/// <para><b><c>BindByName</c> is the sharpest edge, and the browse leg below is what proves it live.</b>
|
||||
/// ODP.NET binds by <em>position</em> by default, and <c>OracleDialect.ListTablesSql</c> names
|
||||
/// <c>:schema</c> twice (once per branch of its <c>UNION ALL</c>) while binding it once — under
|
||||
/// positional binding that statement cannot execute at all. The unit suite asserts the flag is set on a
|
||||
/// real <c>OracleCommand</c>; this asserts the statement it protects actually runs.</para>
|
||||
/// <para><b>Env-gated; skipping is the normal outcome.</b> See <see cref="OracleFixture"/> for the gate.
|
||||
/// With it unset nothing here opens a socket, so the suite is instant and green offline.</para>
|
||||
/// <para><b>Deliberately narrower than <see cref="SqlServerReadTests"/></b>, for the reason
|
||||
/// <see cref="PostgresReadTests"/> gives: the provider-agnostic read semantics are pinned once against
|
||||
/// SQL Server and by the SQLite suites, and only what a <em>dialect</em> can get wrong is repeated
|
||||
/// per provider.</para>
|
||||
/// </summary>
|
||||
[Collection(OracleCollection.Name)]
|
||||
public sealed class OracleReadTests
|
||||
{
|
||||
private readonly OracleFixture _ora;
|
||||
|
||||
/// <summary>Initializes a new instance of the <see cref="OracleReadTests"/> class.</summary>
|
||||
/// <param name="ora">The seeded live-server fixture (collection-scoped).</param>
|
||||
public OracleReadTests(OracleFixture ora) => _ora = ora;
|
||||
|
||||
// ---- lifecycle: liveness + catalog load ----
|
||||
|
||||
/// <summary>
|
||||
/// Initialize's liveness check — <c>SELECT 1 FROM DUAL</c>, not the bare <c>SELECT 1</c> every other
|
||||
/// dialect uses — and its catalog load both succeed, and the driver reports Healthy with the endpoint
|
||||
/// described credential-free.
|
||||
/// <para>The catalog load is asserted indirectly but unambiguously: <c>SqlCatalogLoader</c> throws
|
||||
/// when the principal sees zero schemas, and a tag whose table did not resolve publishes
|
||||
/// <c>BadNodeIdUnknown</c> instead of a value — so the Good read below is only reachable once
|
||||
/// <c>ALL_USERS</c> / <c>ALL_TABLES</c> / <c>ALL_TAB_COLUMNS</c> have all answered the shape the
|
||||
/// loader expects.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task InitializeAsync_realOracle_reportsHealthyAndDescribesTheEndpoint()
|
||||
{
|
||||
SkipUnlessLive();
|
||||
|
||||
await using var driver = await StartAsync(KeyValue("Sql/Line1/Speed", OracleFixture.PresentKey));
|
||||
|
||||
var health = driver.GetHealth();
|
||||
health.State.ShouldBe(DriverState.Healthy);
|
||||
health.LastSuccessfulRead.ShouldNotBeNull();
|
||||
|
||||
// The endpoint description is what every log line and the Admin UI show. Oracle's connection string
|
||||
// names the database inside Data Source (host:port/service), so the service is what must survive —
|
||||
// and the credential must not.
|
||||
driver.Endpoint.ShouldContain(_ora.ServiceName);
|
||||
driver.Endpoint.ShouldNotContain("password", Case.Insensitive);
|
||||
|
||||
driver.GetHostStatuses().ShouldHaveSingleItem().State.ShouldBe(HostState.Running);
|
||||
}
|
||||
|
||||
// ---- key-value model ----
|
||||
|
||||
/// <summary>
|
||||
/// A seeded key-value row round-trips as a Good snapshot with its source timestamp.
|
||||
/// <para>The value column is a plain <c>NUMBER</c> — Oracle's single numeric family — which
|
||||
/// <c>OracleDialect.MapColumnType</c> folds to <see cref="DriverDataType.Float64"/>. This is the
|
||||
/// live confirmation of that documented under-specification: an integral-looking seeded value comes
|
||||
/// back as a floating-point node, and the escape hatch for an operator who needs otherwise is an
|
||||
/// explicit authored <c>"type"</c>.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task ReadAsync_realOracle_roundTripsSeededKeyValue()
|
||||
{
|
||||
SkipUnlessLive();
|
||||
|
||||
await using var driver = await StartAsync(KeyValue("Sql/Line1/Speed", OracleFixture.PresentKey));
|
||||
|
||||
var snapshots = await driver.ReadAsync(["Sql/Line1/Speed"], TestContext.Current.CancellationToken);
|
||||
|
||||
var snapshot = snapshots.ShouldHaveSingleItem();
|
||||
snapshot.StatusCode.ShouldBe(SqlStatusCodes.Good);
|
||||
Convert.ToDouble(snapshot.Value, CultureInfo.InvariantCulture).ShouldBe(OracleFixture.PresentValue);
|
||||
snapshot.SourceTimestampUtc.ShouldBe(OracleFixture.PresentKeyTimestampUtc);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Two keys on the same table fold into ONE query — <c>… WHERE "TAG_NAME" IN (:k0, :k1)</c> — and are
|
||||
/// sliced back to the right tags.
|
||||
/// <para><b>This is the live falsification of positional binding.</b> With
|
||||
/// <c>OracleCommand.BindByName</c> unset, ODP.NET fills the markers in statement order from the
|
||||
/// parameter collection regardless of their names, and the failure mode is not an exception but a
|
||||
/// <em>successful query over the wrong rows</em> — one tag's value published onto another tag's node.
|
||||
/// The two seeded values differ, so a swap fails the assertion rather than passing silently.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task ReadAsync_realOracle_foldsTwoKeysIntoOneGroupAndSlicesBackCorrectly()
|
||||
{
|
||||
SkipUnlessLive();
|
||||
|
||||
await using var driver = await StartAsync(
|
||||
KeyValue("Sql/Line1/Speed", OracleFixture.PresentKey),
|
||||
KeyValue("Sql/Line1/Pressure", OracleFixture.SecondPresentKey));
|
||||
|
||||
var snapshots = await driver.ReadAsync(
|
||||
["Sql/Line1/Speed", "Sql/Line1/Pressure"], TestContext.Current.CancellationToken);
|
||||
|
||||
snapshots.Count.ShouldBe(2);
|
||||
snapshots[0].StatusCode.ShouldBe(SqlStatusCodes.Good);
|
||||
Convert.ToDouble(snapshots[0].Value, CultureInfo.InvariantCulture)
|
||||
.ShouldBe(OracleFixture.PresentValue);
|
||||
snapshots[1].StatusCode.ShouldBe(SqlStatusCodes.Good);
|
||||
Convert.ToDouble(snapshots[1].Value, CultureInfo.InvariantCulture)
|
||||
.ShouldBe(OracleFixture.SecondPresentValue);
|
||||
}
|
||||
|
||||
// ---- wide-row model: the Oracle-specific row-limit syntax ----
|
||||
|
||||
/// <summary>
|
||||
/// The <c>topByTimestamp</c> selector resolves to the newest row.
|
||||
/// <para><b>This is the Oracle-specific leg.</b> The planner spells the row limit through the
|
||||
/// dialect's <c>SingleRowLimitSuffix</c> — a trailing <c>FETCH FIRST 1 ROWS ONLY</c> (the 12.1+
|
||||
/// ANSI clause), deliberately not <c>WHERE ROWNUM = 1</c>, which is assigned before
|
||||
/// <c>ORDER BY</c> runs and would take an arbitrary row and then sort it. The seed makes the newest
|
||||
/// row neither the first-inserted nor the lowest-keyed one, so that exact mistake returns a
|
||||
/// different, wrong value here rather than a coincidentally-right one.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task ReadAsync_realOracle_topByTimestampSelectsTheNewestRow()
|
||||
{
|
||||
SkipUnlessLive();
|
||||
|
||||
await using var driver = await StartAsync(WideRowTop("Sql/Newest/OvenTemp", OracleFixture.OvenTempColumn));
|
||||
|
||||
var snapshot = (await driver.ReadAsync(["Sql/Newest/OvenTemp"], TestContext.Current.CancellationToken))
|
||||
.ShouldHaveSingleItem();
|
||||
|
||||
snapshot.StatusCode.ShouldBe(SqlStatusCodes.Good);
|
||||
Convert.ToDouble(snapshot.Value, CultureInfo.InvariantCulture)
|
||||
.ShouldBe(OracleFixture.NewestStationOvenTemp);
|
||||
}
|
||||
|
||||
// ---- catalog case-folding (design §8.1 gate, against the real ALL_* views) ----
|
||||
|
||||
/// <summary>
|
||||
/// An operator who authors <c>otopcua.tag_values</c> against a catalog holding
|
||||
/// <c>OTOPCUA.TAG_VALUES</c> still reads. <b>Pinned as accepted, not rejected</b> — that is what
|
||||
/// <c>SqlCatalog.TryMatch</c> actually does: an exact <em>ordinal</em> hit wins, and failing that a
|
||||
/// <b>unique</b> case-insensitive hit is accepted and the catalog's own spelling substituted before
|
||||
/// anything is quoted into SQL.
|
||||
/// <para><b>On Oracle this is not tolerance, it is the only thing that works.</b> Oracle upper-cases
|
||||
/// an unquoted identifier, so the catalog holds <c>TAG_VALUES</c>; but
|
||||
/// <c>OracleDialect.QuoteIdentifier</c> emits a double-quoted — i.e. case-<em>sensitive</em> — name,
|
||||
/// and <c>"tag_values"</c> and <c>"TAG_VALUES"</c> are different objects to Oracle. Without the
|
||||
/// gate's substitution the authored lower-case spelling would reach the server naming an object that
|
||||
/// does not exist. Every AdminUI-authored tag would be affected, since nobody types SHOUTING
|
||||
/// identifiers by hand.</para>
|
||||
/// <para>The gate refuses only an <em>ambiguous</em> fold — two catalog names differing solely in
|
||||
/// case, which Oracle can only produce from quoted DDL — and that cannot arise from this seed; it is
|
||||
/// pinned offline in the unit suites.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task CatalogGate_realOracle_foldsALowerCasedAuthoredNameOntoTheUpperCaseCatalogSpelling()
|
||||
{
|
||||
SkipUnlessLive();
|
||||
|
||||
var lower = Tag("Sql/Line1/Speed", new JsonObject
|
||||
{
|
||||
["driver"] = "Sql",
|
||||
["model"] = "KeyValue",
|
||||
["table"] = OracleFixture.Qualified(OracleFixture.KeyValueTable).ToLowerInvariant(),
|
||||
["keyColumn"] = OracleFixture.KeyColumn.ToLowerInvariant(),
|
||||
["keyValue"] = OracleFixture.PresentKey,
|
||||
["valueColumn"] = OracleFixture.ValueColumn.ToLowerInvariant(),
|
||||
["timestampColumn"] = OracleFixture.TimestampColumn.ToLowerInvariant(),
|
||||
});
|
||||
|
||||
await using var driver = await StartAsync(lower);
|
||||
|
||||
var snapshot = (await driver.ReadAsync(["Sql/Line1/Speed"], TestContext.Current.CancellationToken))
|
||||
.ShouldHaveSingleItem();
|
||||
|
||||
SqlStatusCodes.IsGood(snapshot.StatusCode).ShouldBeTrue();
|
||||
Convert.ToDouble(snapshot.Value, CultureInfo.InvariantCulture).ShouldBe(OracleFixture.PresentValue);
|
||||
}
|
||||
|
||||
// ---- browse session: the AdminUI's schema → table → column walk ----
|
||||
|
||||
/// <summary>
|
||||
/// The AdminUI picker's walk — <c>RootAsync</c> (schemas) → <c>ExpandAsync</c> (tables) →
|
||||
/// <c>ExpandAsync</c> (columns) → <c>AttributesAsync</c> (the side panel) — sees the seeded table
|
||||
/// over a real database, and the leaf's mapped driver type is the one
|
||||
/// <c>OracleDialect.MapColumnType</c> promises for <c>NUMBER</c>.
|
||||
/// <para><b>The table expand is the <c>BindByName</c> proof.</b> It runs
|
||||
/// <c>OracleDialect.ListTablesSql</c>, whose <c>UNION ALL</c> names <c>:schema</c> twice against a
|
||||
/// single bound parameter — a statement that cannot execute under ODP.NET's default positional
|
||||
/// binding. Reaching a non-empty table list here is therefore evidence that
|
||||
/// <c>ConfigureCommand</c> ran at every command site, not just in the unit test.</para>
|
||||
/// <para>Unlike the Postgres walk, the schema list is NOT asserted to be a single item:
|
||||
/// <c>ALL_USERS</c> lists every user in the instance (Oracle equates a schema with a user), so the
|
||||
/// seeded schema is one of many.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task Browse_realOracle_walksSchemaToTableToColumnAndTypesTheLeaf()
|
||||
{
|
||||
SkipUnlessLive();
|
||||
|
||||
var config = new JsonObject
|
||||
{
|
||||
["provider"] = nameof(SqlProvider.Oracle),
|
||||
["connectionString"] = _ora.ConnectionString,
|
||||
}.ToJsonString();
|
||||
|
||||
await using var session = await new SqlDriverBrowser()
|
||||
.OpenAsync(config, TestContext.Current.CancellationToken);
|
||||
|
||||
// Asserted on the NAMES rather than with a predicate so a miss prints the list the catalog did
|
||||
// return, which is the only useful diagnostic when a browse walk comes back short.
|
||||
var schemas = await session.RootAsync(TestContext.Current.CancellationToken);
|
||||
schemas.Select(s => s.DisplayName).ShouldContain(OracleFixture.Schema);
|
||||
var schema = schemas.First(s => s.DisplayName == OracleFixture.Schema);
|
||||
|
||||
var tables = await session.ExpandAsync(schema.NodeId, TestContext.Current.CancellationToken);
|
||||
tables.Select(t => t.DisplayName).ShouldContain(OracleFixture.KeyValueTable);
|
||||
var table = tables.First(t => t.DisplayName == OracleFixture.KeyValueTable);
|
||||
|
||||
var columns = await session.ExpandAsync(table.NodeId, TestContext.Current.CancellationToken);
|
||||
columns.Select(c => c.DisplayName).ShouldBe(
|
||||
[OracleFixture.KeyColumn, OracleFixture.ValueColumn, OracleFixture.TimestampColumn]);
|
||||
columns.ShouldAllBe(c => c.Kind == BrowseNodeKind.Leaf);
|
||||
|
||||
// The side panel is what the browse-commit builds a tag from: the table has to travel with the
|
||||
// column, or the commit falls through to a generic blob the typed editor cannot read.
|
||||
var value = columns.Single(c => c.DisplayName == OracleFixture.ValueColumn);
|
||||
var attribute = (await session.AttributesAsync(value.NodeId, TestContext.Current.CancellationToken))
|
||||
.ShouldHaveSingleItem();
|
||||
attribute.DriverDataType.ShouldBe(nameof(DriverDataType.Float64)); // NUMBER
|
||||
|
||||
var address = attribute.AddressFields.ShouldNotBeNull();
|
||||
address["schema"].ShouldBe(OracleFixture.Schema);
|
||||
address["table"].ShouldBe(OracleFixture.KeyValueTable);
|
||||
address["columnName"].ShouldBe(OracleFixture.ValueColumn);
|
||||
}
|
||||
|
||||
// ---- helpers ----
|
||||
|
||||
/// <summary>Skips the calling test when the live-server gate is not configured or not reachable.</summary>
|
||||
private void SkipUnlessLive()
|
||||
{
|
||||
if (_ora.SkipReason is { } reason) Assert.Skip(reason);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Builds and initializes a driver over the seeded schema, with no injected factory — which is
|
||||
/// precisely what makes this suite exercise <c>OracleClientFactory.Instance</c>, the provider the
|
||||
/// dialect ships.
|
||||
/// </summary>
|
||||
private async Task<SqlDriver> StartAsync(params RawTagEntry[] tags)
|
||||
{
|
||||
var options = new SqlDriverOptions
|
||||
{
|
||||
RawTags = tags,
|
||||
CommandTimeout = TimeSpan.FromSeconds(15),
|
||||
OperationTimeout = TimeSpan.FromSeconds(20),
|
||||
};
|
||||
|
||||
var driver = new SqlDriver(
|
||||
options,
|
||||
driverInstanceId: "sql-oracle-integration",
|
||||
dialect: new OracleDialect(),
|
||||
connectionString: _ora.ConnectionString);
|
||||
|
||||
try
|
||||
{
|
||||
await driver.InitializeAsync("{}", TestContext.Current.CancellationToken);
|
||||
}
|
||||
catch
|
||||
{
|
||||
await driver.DisposeAsync();
|
||||
throw;
|
||||
}
|
||||
|
||||
return driver;
|
||||
}
|
||||
|
||||
/// <summary>A key-value tag over the seeded EAV table, authored in the catalog's own spelling.</summary>
|
||||
private static RawTagEntry KeyValue(string rawPath, string key) => Tag(rawPath, new JsonObject
|
||||
{
|
||||
["driver"] = "Sql",
|
||||
["model"] = "KeyValue",
|
||||
["table"] = OracleFixture.Qualified(OracleFixture.KeyValueTable),
|
||||
["keyColumn"] = OracleFixture.KeyColumn,
|
||||
["keyValue"] = key,
|
||||
["valueColumn"] = OracleFixture.ValueColumn,
|
||||
["timestampColumn"] = OracleFixture.TimestampColumn,
|
||||
});
|
||||
|
||||
/// <summary>A wide-row tag selected by newest timestamp.</summary>
|
||||
private static RawTagEntry WideRowTop(string rawPath, string column) => Tag(rawPath, new JsonObject
|
||||
{
|
||||
["driver"] = "Sql",
|
||||
["model"] = "WideRow",
|
||||
["table"] = OracleFixture.Qualified(OracleFixture.WideRowTable),
|
||||
["columnName"] = column,
|
||||
["timestampColumn"] = OracleFixture.TimestampColumn,
|
||||
["rowSelector"] = new JsonObject
|
||||
{
|
||||
["topByTimestamp"] = OracleFixture.TimestampColumn,
|
||||
},
|
||||
});
|
||||
|
||||
/// <summary>
|
||||
/// Wraps an authored <c>TagConfig</c> object as a raw tag entry. Composed as a
|
||||
/// <see cref="JsonObject"/> rather than as an interpolated string literal for the reason
|
||||
/// <see cref="SqlServerReadTests"/> gives.
|
||||
/// </summary>
|
||||
private static RawTagEntry Tag(string rawPath, JsonObject config) =>
|
||||
new(rawPath, config.ToJsonString(), WriteIdempotent: false);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A real, seeded <b>Oracle Database</b> schema standing in for the source the <c>Sql</c> driver polls —
|
||||
/// the Oracle counterpart of <see cref="SqlPollServerFixture"/>.
|
||||
/// <para><b>Env-gated, and the gate is checked before any socket is touched.</b> This fixture opens
|
||||
/// nothing unless <see cref="EndpointEnvVar"/> and <see cref="PasswordEnvVar"/> are both set; absent, it
|
||||
/// records <see cref="SkipReason"/> and every test calls <c>Assert.Skip</c>.</para>
|
||||
/// <para><b>This fixture does not seed — the compose stack does</b>
|
||||
/// (<c>Docker/oracle/docker-compose.yml</c> + <c>seed-oracle.sql</c>). Oracle equates a schema with a
|
||||
/// user, so the seed runs as the same <c>otopcua</c> principal the suite connects as and its objects
|
||||
/// land in the <c>OTOPCUA</c> schema.</para>
|
||||
/// <para><b>Every identifier constant below is UPPER case, and that is the catalog's spelling, not a
|
||||
/// style choice.</b> The seed's DDL is unquoted, so Oracle folds it up; the case-folding leg is the one
|
||||
/// place that deliberately authors the lower-case form an operator would actually type.</para>
|
||||
/// </summary>
|
||||
public sealed class OracleFixture : IAsyncLifetime
|
||||
{
|
||||
/// <summary>Listener endpoint in <c>host:port</c> form (e.g. <c>10.100.0.35:11521</c>). Absent ⇒ skip.</summary>
|
||||
public const string EndpointEnvVar = "SQL_ORACLE_ENDPOINT";
|
||||
|
||||
/// <summary>The login. Defaults to <see cref="DefaultUser"/>, the user the compose stack creates.</summary>
|
||||
public const string UserEnvVar = "SQL_ORACLE_USER";
|
||||
|
||||
/// <summary>The password. Required — never defaulted (see <see cref="ResolveConnectionString"/>).</summary>
|
||||
public const string PasswordEnvVar = "SQL_ORACLE_PASSWORD";
|
||||
|
||||
/// <summary>
|
||||
/// The service name the EZ-Connect descriptor addresses. Optional: defaults to
|
||||
/// <see cref="DefaultService"/>, the pluggable database the <c>gvenzl/oracle-free</c> image creates.
|
||||
/// </summary>
|
||||
public const string ServiceEnvVar = "SQL_ORACLE_SERVICE";
|
||||
|
||||
/// <summary>The application user the compose stack creates (<c>APP_USER</c>).</summary>
|
||||
public const string DefaultUser = "otopcua";
|
||||
|
||||
/// <summary>The image's pluggable-database service name.</summary>
|
||||
public const string DefaultService = "FREEPDB1";
|
||||
|
||||
/// <summary>Oracle's default listener port, used when <see cref="EndpointEnvVar"/> carries no port.</summary>
|
||||
public const int DefaultPort = 1521;
|
||||
|
||||
/// <summary>The schema the seed's objects live in — Oracle folds the unquoted user name up.</summary>
|
||||
public const string Schema = "OTOPCUA";
|
||||
|
||||
/// <summary>Seconds a connect attempt may take before the fixture calls the server unreachable.</summary>
|
||||
private const int ProbeConnectTimeoutSeconds = 10;
|
||||
|
||||
// ---- key-value (EAV) source ----
|
||||
|
||||
/// <summary>The key-value table: <c>TAG_NAME VARCHAR2(128), NUM_VALUE NUMBER, SAMPLE_TS TIMESTAMP(3)</c>.</summary>
|
||||
public const string KeyValueTable = "TAG_VALUES";
|
||||
|
||||
/// <summary>The key-value table's key column.</summary>
|
||||
public const string KeyColumn = "TAG_NAME";
|
||||
|
||||
/// <summary>The key-value table's value column.</summary>
|
||||
public const string ValueColumn = "NUM_VALUE";
|
||||
|
||||
/// <summary>The source-timestamp column carried by every seeded table.</summary>
|
||||
public const string TimestampColumn = "SAMPLE_TS";
|
||||
|
||||
/// <summary>A key whose row exists and whose value cell holds <see cref="PresentValue"/>.</summary>
|
||||
public const string PresentKey = "Line1.Speed";
|
||||
|
||||
/// <summary>The value seeded for <see cref="PresentKey"/>.</summary>
|
||||
public const double PresentValue = 42.0;
|
||||
|
||||
/// <summary>A second present key, so a group can legitimately fold more than one member.</summary>
|
||||
public const string SecondPresentKey = "Line1.Pressure";
|
||||
|
||||
/// <summary>The value seeded for <see cref="SecondPresentKey"/> — different from
|
||||
/// <see cref="PresentValue"/>, so a positional-binding swap is visible.</summary>
|
||||
public const double SecondPresentValue = 3.5;
|
||||
|
||||
/// <summary>The UTC source timestamp seeded for <see cref="PresentKey"/>.</summary>
|
||||
public static readonly DateTime PresentKeyTimestampUtc = new(2026, 7, 24, 10, 0, 0, DateTimeKind.Utc);
|
||||
|
||||
// ---- wide-row source ----
|
||||
|
||||
/// <summary>The wide-row table: <c>STATION_ID NUMBER(10), OVEN_TEMP/PRESSURE NUMBER, SAMPLE_TS TIMESTAMP(3)</c>.</summary>
|
||||
public const string WideRowTable = "LATEST_STATUS";
|
||||
|
||||
/// <summary>The wide-row table's value column the <c>topByTimestamp</c> leg reads.</summary>
|
||||
public const string OvenTempColumn = "OVEN_TEMP";
|
||||
|
||||
/// <summary>
|
||||
/// The <see cref="OvenTempColumn"/> of the row holding the <b>newest</b> <c>SAMPLE_TS</c> — what a
|
||||
/// <c>topByTimestamp</c> selector must resolve to. Its row is neither the first inserted nor the
|
||||
/// lowest-keyed, so a plan that lost its <c>ORDER BY … DESC</c> or its
|
||||
/// <c>FETCH FIRST 1 ROWS ONLY</c> picks a different value and the test says so.
|
||||
/// </summary>
|
||||
public const double NewestStationOvenTemp = 210.25;
|
||||
|
||||
/// <summary>Why the suite is skipping, or <see langword="null"/> when the server is reachable.</summary>
|
||||
public string? SkipReason { get; private set; }
|
||||
|
||||
/// <summary>The connection string to hand the code under test. Empty while <see cref="SkipReason"/> is set.</summary>
|
||||
public string ConnectionString { get; private set; } = string.Empty;
|
||||
|
||||
/// <summary>The resolved service name, for the endpoint-description assertion.</summary>
|
||||
public string ServiceName { get; private set; } = DefaultService;
|
||||
|
||||
/// <summary>The listener the fixture resolved, for skip/diagnostic messages. Never carries credentials.</summary>
|
||||
public string Server { get; private set; } = string.Empty;
|
||||
|
||||
/// <summary>Two-part name of a seeded object, in the form an authored tag's <c>table</c> carries.</summary>
|
||||
/// <param name="table">The bare table or view name.</param>
|
||||
/// <returns>The <c>schema.table</c> name.</returns>
|
||||
public static string Qualified(string table) => $"{Schema}.{table}";
|
||||
|
||||
/// <summary>
|
||||
/// Resolves the gate and probes the server with the dialect's own <c>LivenessSql</c>. A failure to
|
||||
/// connect is the offline case and becomes a <see cref="SkipReason"/>; nothing is created or seeded
|
||||
/// here (the compose stack owns that).
|
||||
/// </summary>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
public async ValueTask InitializeAsync()
|
||||
{
|
||||
if (ResolveConnectionString() is not { } resolved)
|
||||
{
|
||||
SkipReason =
|
||||
$"Set {EndpointEnvVar} (host:port) and {PasswordEnvVar} (and optionally {UserEnvVar}, " +
|
||||
$"default '{DefaultUser}', and {ServiceEnvVar}, default '{DefaultService}') to run the " +
|
||||
"Sql driver's live Oracle suite. Bring the fixture up from " +
|
||||
"Docker/oracle/docker-compose.yml first. No connection is attempted without these.";
|
||||
return;
|
||||
}
|
||||
|
||||
ConnectionString = resolved;
|
||||
|
||||
var dialect = new OracleDialect();
|
||||
try
|
||||
{
|
||||
var connection = dialect.Factory.CreateConnection()
|
||||
?? throw new InvalidOperationException("ODP.NET returned no connection object.");
|
||||
await using (connection.ConfigureAwait(false))
|
||||
{
|
||||
connection.ConnectionString = ConnectionString;
|
||||
await connection.OpenAsync().ConfigureAwait(false);
|
||||
|
||||
var command = connection.CreateCommand();
|
||||
await using (command.ConfigureAwait(false))
|
||||
{
|
||||
dialect.ConfigureCommand(command);
|
||||
command.CommandText = dialect.LivenessSql;
|
||||
await command.ExecuteScalarAsync().ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
SkipReason =
|
||||
$"Oracle at '{Server}' (service '{ServiceName}') was not reachable within " +
|
||||
$"{ProbeConnectTimeoutSeconds}s ({ex.GetType().Name}: {ex.Message}). Check " +
|
||||
$"{EndpointEnvVar}/{UserEnvVar}/{PasswordEnvVar}/{ServiceEnvVar} and that the fixture " +
|
||||
"stack is up (its first boot takes minutes), or leave them unset to skip.";
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Holds no long-lived connection, so there is nothing to tear down.</summary>
|
||||
/// <returns>A completed task.</returns>
|
||||
public ValueTask DisposeAsync() => ValueTask.CompletedTask;
|
||||
|
||||
/// <summary>
|
||||
/// Reads the gate and composes the connection string <b>through the dialect's own provider
|
||||
/// factory</b> (<see cref="DbProviderFactory.CreateConnectionStringBuilder"/>), setting keys via the
|
||||
/// abstract <see cref="DbConnectionStringBuilder"/> indexer.
|
||||
/// <para>That indirection is deliberate: it keeps this project free of a direct ODP.NET
|
||||
/// <c>PackageReference</c>, so the suite can only ever exercise the provider version the driver
|
||||
/// actually ships (see the csproj's no-direct-provider-reference note). Every key used here —
|
||||
/// <c>Data Source</c>, <c>User Id</c>, <c>Password</c>, <c>Connection Timeout</c> — was verified to
|
||||
/// be accepted through that indexer, so no provider-specific property is needed.</para>
|
||||
/// <para>The data source is an <b>EZ-Connect</b> descriptor (<c>host:port/service</c>), which needs
|
||||
/// no <c>tnsnames.ora</c> — deliberate, since the managed provider is meant to run with no client
|
||||
/// install and no Oracle configuration files anywhere near the test host.</para>
|
||||
/// </summary>
|
||||
/// <returns>The connection string, or <see langword="null"/> — touching no socket — when unconfigured.</returns>
|
||||
private string? ResolveConnectionString()
|
||||
{
|
||||
if (Environment.GetEnvironmentVariable(EndpointEnvVar) is not { Length: > 0 } endpoint) return null;
|
||||
|
||||
// A password is required rather than defaulted: guessing one would turn a misconfiguration into a
|
||||
// failed login, and Oracle locks an account after a handful of those.
|
||||
if (Environment.GetEnvironmentVariable(PasswordEnvVar) is not { Length: > 0 } password) return null;
|
||||
|
||||
var user = Environment.GetEnvironmentVariable(UserEnvVar) is { Length: > 0 } named
|
||||
? named
|
||||
: DefaultUser;
|
||||
|
||||
ServiceName = Environment.GetEnvironmentVariable(ServiceEnvVar) is { Length: > 0 } service
|
||||
? service
|
||||
: DefaultService;
|
||||
|
||||
var (host, port) = PostgresFixture.SplitEndpoint(endpoint, DefaultPort);
|
||||
Server = $"{host}:{port}";
|
||||
|
||||
var builder = new OracleDialect().Factory.CreateConnectionStringBuilder()
|
||||
?? throw new InvalidOperationException("ODP.NET returned no connection-string builder.");
|
||||
builder["Data Source"] = $"{host}:{port}/{ServiceName}";
|
||||
builder["User Id"] = user;
|
||||
builder["Password"] = password;
|
||||
builder["Connection Timeout"] = ProbeConnectTimeoutSeconds;
|
||||
return builder.ConnectionString;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Collection definition so the gate is resolved once per test session rather than once per test
|
||||
/// class — the same shape as <see cref="SqlPollServerCollection"/>.
|
||||
/// </summary>
|
||||
[CollectionDefinition(Name)]
|
||||
public sealed class OracleCollection : ICollectionFixture<OracleFixture>
|
||||
{
|
||||
/// <summary>The collection name test classes reference.</summary>
|
||||
public const string Name = "SqlOracleServer";
|
||||
}
|
||||
@@ -0,0 +1,511 @@
|
||||
using System.Data.Common;
|
||||
using System.Globalization;
|
||||
using System.Text.Json.Nodes;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.Commons.Browsing;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Sql.Browser;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.Sql.IntegrationTests;
|
||||
|
||||
/// <summary>
|
||||
/// The <c>Sql</c> driver against a <b>real PostgreSQL</b>, over the <c>Npgsql</c> provider
|
||||
/// <c>PostgresDialect</c> ships. The offline suites all run on SQLite, so three things are exercised
|
||||
/// nowhere else: the Npgsql ADO.NET path, Postgres' own row-limit syntax (a trailing <c>LIMIT 1</c>
|
||||
/// where T-SQL emits <c>SELECT TOP 1</c>), and <c>PostgresDialect</c>'s <c>information_schema</c>
|
||||
/// catalog SQL — including the deliberate choice to derive the schema list from
|
||||
/// <c>information_schema.tables</c> rather than <c>.schemata</c>, which only a
|
||||
/// granted-but-not-owning principal can prove.
|
||||
/// <para><b>Env-gated; skipping is the normal outcome.</b> See <see cref="PostgresFixture"/> for the
|
||||
/// gate. With it unset nothing here opens a socket, so the suite is instant and green offline — which
|
||||
/// is the point: a live test that goes red on a laptop teaches people to ignore red.</para>
|
||||
/// <para><b>Deliberately narrower than <see cref="SqlServerReadTests"/>.</b> The provider-agnostic
|
||||
/// read semantics (NULL cells, absent keys, declared-type overrides, pooling, cancellation) are pinned
|
||||
/// once against SQL Server and by the SQLite suites; repeating all of them per provider would buy
|
||||
/// runtime rather than coverage. What is repeated here is exactly what a <em>dialect</em> can get
|
||||
/// wrong: liveness, the catalog SQL, the row-limit syntax, identifier case-folding, and the browse
|
||||
/// walk an operator authors through.</para>
|
||||
/// </summary>
|
||||
[Collection(PostgresCollection.Name)]
|
||||
public sealed class PostgresReadTests
|
||||
{
|
||||
private readonly PostgresFixture _pg;
|
||||
|
||||
/// <summary>Initializes a new instance of the <see cref="PostgresReadTests"/> class.</summary>
|
||||
/// <param name="pg">The seeded live-server fixture (collection-scoped).</param>
|
||||
public PostgresReadTests(PostgresFixture pg) => _pg = pg;
|
||||
|
||||
// ---- lifecycle: liveness + catalog load ----
|
||||
|
||||
/// <summary>
|
||||
/// Initialize's liveness check (<c>SELECT 1</c>) and its catalog load both succeed, and the driver
|
||||
/// reports Healthy with the endpoint described credential-free.
|
||||
/// <para><b>The catalog load is the interesting half, and it is asserted indirectly but
|
||||
/// unambiguously.</b> <c>SqlCatalogLoader</c> throws when the connecting principal sees zero
|
||||
/// schemas, and a tag whose table did not resolve is dropped from the polled set and publishes
|
||||
/// <c>BadNodeIdUnknown</c>. So a Good read (below) is only reachable when
|
||||
/// <c>PostgresDialect.ListSchemasSql</c> returned the fixture schema for a role that merely holds
|
||||
/// <c>USAGE</c> + <c>SELECT</c> on it — the provisioning that <c>information_schema.schemata</c>
|
||||
/// would have answered empty for.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task InitializeAsync_realPostgres_reportsHealthyAndDescribesTheEndpoint()
|
||||
{
|
||||
SkipUnlessLive();
|
||||
|
||||
await using var driver = await StartAsync(KeyValue("Sql/Line1/Speed", PostgresFixture.PresentKey));
|
||||
|
||||
var health = driver.GetHealth();
|
||||
health.State.ShouldBe(DriverState.Healthy);
|
||||
health.LastSuccessfulRead.ShouldNotBeNull();
|
||||
|
||||
// The endpoint description is what every log line and the Admin UI show. It must name the
|
||||
// database and must not carry the credential that reached the provider.
|
||||
driver.Endpoint.ShouldContain(PostgresFixture.FixtureDatabase);
|
||||
driver.Endpoint.ShouldNotContain("password", Case.Insensitive);
|
||||
|
||||
driver.GetHostStatuses().ShouldHaveSingleItem().State.ShouldBe(HostState.Running);
|
||||
}
|
||||
|
||||
// ---- key-value model ----
|
||||
|
||||
/// <summary>A seeded key-value row round-trips as a Good snapshot with its source timestamp.</summary>
|
||||
[Fact]
|
||||
public async Task ReadAsync_realPostgres_roundTripsSeededKeyValue()
|
||||
{
|
||||
SkipUnlessLive();
|
||||
|
||||
await using var driver = await StartAsync(KeyValue("Sql/Line1/Speed", PostgresFixture.PresentKey));
|
||||
|
||||
var snapshots = await driver.ReadAsync(["Sql/Line1/Speed"], TestContext.Current.CancellationToken);
|
||||
|
||||
var snapshot = snapshots.ShouldHaveSingleItem();
|
||||
snapshot.StatusCode.ShouldBe(SqlStatusCodes.Good);
|
||||
Convert.ToDouble(snapshot.Value, CultureInfo.InvariantCulture).ShouldBe(PostgresFixture.PresentValue);
|
||||
// `timestamp without time zone` comes back Unspecified; the reader stamps it UTC rather than
|
||||
// reinterpreting it through the host's zone — the behaviour this asserts against a real column type.
|
||||
snapshot.SourceTimestampUtc.ShouldBe(PostgresFixture.PresentKeyTimestampUtc);
|
||||
}
|
||||
|
||||
// ---- wide-row model: the Postgres-specific row-limit syntax ----
|
||||
|
||||
/// <summary>
|
||||
/// The <c>topByTimestamp</c> selector resolves to the newest row.
|
||||
/// <para><b>This is the Postgres-specific leg.</b> The planner spells the row limit through the
|
||||
/// dialect's <c>SingleRowLimitSuffix</c> — a trailing <c>LIMIT 1</c> — where the SQL Server suite
|
||||
/// exercises a leading <c>SELECT TOP 1</c>. The seed makes the newest row neither the
|
||||
/// first-inserted nor the lowest-keyed one, so losing either the limit or the
|
||||
/// <c>ORDER BY … DESC</c> yields a different, wrong value rather than a coincidentally-right one.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task ReadAsync_realPostgres_topByTimestampSelectsTheNewestRow()
|
||||
{
|
||||
SkipUnlessLive();
|
||||
|
||||
await using var driver = await StartAsync(WideRowTop("Sql/Newest/OvenTemp", "oven_temp"));
|
||||
|
||||
var snapshot = (await driver.ReadAsync(["Sql/Newest/OvenTemp"], TestContext.Current.CancellationToken))
|
||||
.ShouldHaveSingleItem();
|
||||
|
||||
snapshot.StatusCode.ShouldBe(SqlStatusCodes.Good);
|
||||
Convert.ToDouble(snapshot.Value, CultureInfo.InvariantCulture)
|
||||
.ShouldBe(PostgresFixture.NewestStationOvenTemp);
|
||||
}
|
||||
|
||||
// ---- catalog case-folding (design §8.1 gate, against a real information_schema) ----
|
||||
|
||||
/// <summary>
|
||||
/// An operator who authors <c>SQLPOLL.TAG_VALUES</c> against a catalog holding
|
||||
/// <c>sqlpoll.tag_values</c> still reads. <b>Pinned as accepted, not rejected</b> — that is what
|
||||
/// <c>SqlCatalog.TryMatch</c> actually does: an exact <em>ordinal</em> hit wins, and failing that a
|
||||
/// <b>unique</b> case-insensitive hit is accepted and the catalog's own spelling substituted before
|
||||
/// anything is quoted into SQL.
|
||||
/// <para><b>Why this matters more on Postgres than it looks.</b> Postgres folds an unquoted
|
||||
/// identifier to <em>lower</em> case, and <c>PostgresDialect.QuoteIdentifier</c> emits a
|
||||
/// double-quoted — i.e. case-<em>sensitive</em> — name. Without the gate's substitution, the
|
||||
/// authored <c>"TAG_VALUES"</c> would reach the server as a quoted identifier naming an object that
|
||||
/// does not exist, and the tag would fail at query time instead of resolving. So this leg is not
|
||||
/// cosmetic tolerance; it is the only thing making mixed-case authoring work at all.</para>
|
||||
/// <para>The gate refuses only an <em>ambiguous</em> fold — two catalog columns differing solely in
|
||||
/// case — which cannot be produced from this seed and is pinned offline in the unit suites.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task CatalogGate_realPostgres_foldsAnUpperCasedAuthoredNameOntoTheLowerCaseCatalogSpelling()
|
||||
{
|
||||
SkipUnlessLive();
|
||||
|
||||
var upper = Tag("Sql/Line1/Speed", new JsonObject
|
||||
{
|
||||
["driver"] = "Sql",
|
||||
["model"] = "KeyValue",
|
||||
["table"] = PostgresFixture.Qualified(PostgresFixture.KeyValueTable).ToUpperInvariant(),
|
||||
["keyColumn"] = PostgresFixture.KeyColumn.ToUpperInvariant(),
|
||||
["keyValue"] = PostgresFixture.PresentKey,
|
||||
["valueColumn"] = PostgresFixture.ValueColumn.ToUpperInvariant(),
|
||||
["timestampColumn"] = PostgresFixture.TimestampColumn.ToUpperInvariant(),
|
||||
});
|
||||
|
||||
await using var driver = await StartAsync(upper);
|
||||
|
||||
var snapshot = (await driver.ReadAsync(["Sql/Line1/Speed"], TestContext.Current.CancellationToken))
|
||||
.ShouldHaveSingleItem();
|
||||
|
||||
SqlStatusCodes.IsGood(snapshot.StatusCode).ShouldBeTrue();
|
||||
Convert.ToDouble(snapshot.Value, CultureInfo.InvariantCulture).ShouldBe(PostgresFixture.PresentValue);
|
||||
}
|
||||
|
||||
// ---- browse session: the AdminUI's schema → table → column walk ----
|
||||
|
||||
/// <summary>
|
||||
/// The AdminUI picker's walk — <c>RootAsync</c> (schemas) → <c>ExpandAsync</c> (tables) →
|
||||
/// <c>ExpandAsync</c> (columns) → <c>AttributesAsync</c> (the side panel) — sees the seeded table
|
||||
/// over a real database, and the leaf's mapped driver type is the one
|
||||
/// <c>PostgresDialect.MapColumnType</c> promises for <c>double precision</c>.
|
||||
/// <para>Driven through <see cref="SqlDriverBrowser"/> rather than the internal session, because
|
||||
/// that is the seam the AdminUI actually calls: it also proves the provider gate admits
|
||||
/// <c>Postgres</c> and that the dialect's <em>quoted</em> catalog aliases
|
||||
/// (<c>AS "TABLE_NAME"</c>) survive Postgres' lower-casing of unquoted output columns — the
|
||||
/// browse session reads every catalog column by name, so an unquoted alias would fold to
|
||||
/// <c>table_name</c> and the walk would throw on <c>GetOrdinal</c> rather than return an empty
|
||||
/// list.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task Browse_realPostgres_walksSchemaToTableToColumnAndTypesTheLeaf()
|
||||
{
|
||||
SkipUnlessLive();
|
||||
|
||||
var config = new JsonObject
|
||||
{
|
||||
["provider"] = nameof(SqlProvider.Postgres),
|
||||
["connectionString"] = _pg.ConnectionString,
|
||||
}.ToJsonString();
|
||||
|
||||
await using var session = await new SqlDriverBrowser()
|
||||
.OpenAsync(config, TestContext.Current.CancellationToken);
|
||||
|
||||
var schemas = await session.RootAsync(TestContext.Current.CancellationToken);
|
||||
var schema = schemas.ShouldHaveSingleItem(
|
||||
"the fixture login can SELECT in exactly one schema, so exactly one is browsable");
|
||||
schema.DisplayName.ShouldBe(PostgresFixture.Schema);
|
||||
|
||||
var tables = await session.ExpandAsync(schema.NodeId, TestContext.Current.CancellationToken);
|
||||
// Asserted on the NAMES rather than with a predicate so a miss prints the list the catalog did
|
||||
// return, which is the only useful diagnostic when a browse walk comes back short.
|
||||
tables.Select(t => t.DisplayName).ShouldContain(PostgresFixture.KeyValueTable);
|
||||
var table = tables.First(t => t.DisplayName == PostgresFixture.KeyValueTable);
|
||||
|
||||
var columns = await session.ExpandAsync(table.NodeId, TestContext.Current.CancellationToken);
|
||||
columns.Select(c => c.DisplayName).ShouldBe(
|
||||
[PostgresFixture.KeyColumn, PostgresFixture.ValueColumn, PostgresFixture.TimestampColumn]);
|
||||
columns.ShouldAllBe(c => c.Kind == BrowseNodeKind.Leaf);
|
||||
|
||||
// The side panel is what the browse-commit builds a tag from: the table has to travel with the
|
||||
// column, or the commit falls through to a generic blob the typed editor cannot read.
|
||||
var value = columns.Single(c => c.DisplayName == PostgresFixture.ValueColumn);
|
||||
var attribute = (await session.AttributesAsync(value.NodeId, TestContext.Current.CancellationToken))
|
||||
.ShouldHaveSingleItem();
|
||||
attribute.DriverDataType.ShouldBe(nameof(DriverDataType.Float64)); // double precision
|
||||
|
||||
var address = attribute.AddressFields.ShouldNotBeNull();
|
||||
address["schema"].ShouldBe(PostgresFixture.Schema);
|
||||
address["table"].ShouldBe(PostgresFixture.KeyValueTable);
|
||||
address["columnName"].ShouldBe(PostgresFixture.ValueColumn);
|
||||
}
|
||||
|
||||
// ---- helpers ----
|
||||
|
||||
/// <summary>Skips the calling test when the live-server gate is not configured or not reachable.</summary>
|
||||
private void SkipUnlessLive()
|
||||
{
|
||||
if (_pg.SkipReason is { } reason) Assert.Skip(reason);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Builds and initializes a driver over the seeded database, with no injected factory — which is
|
||||
/// precisely what makes this suite exercise <c>NpgsqlFactory.Instance</c>, the provider the dialect
|
||||
/// ships.
|
||||
/// </summary>
|
||||
private async Task<SqlDriver> StartAsync(params RawTagEntry[] tags)
|
||||
{
|
||||
var options = new SqlDriverOptions
|
||||
{
|
||||
RawTags = tags,
|
||||
CommandTimeout = TimeSpan.FromSeconds(10),
|
||||
OperationTimeout = TimeSpan.FromSeconds(15),
|
||||
};
|
||||
|
||||
var driver = new SqlDriver(
|
||||
options,
|
||||
driverInstanceId: "sql-postgres-integration",
|
||||
dialect: new PostgresDialect(),
|
||||
connectionString: _pg.ConnectionString);
|
||||
|
||||
try
|
||||
{
|
||||
await driver.InitializeAsync("{}", TestContext.Current.CancellationToken);
|
||||
}
|
||||
catch
|
||||
{
|
||||
await driver.DisposeAsync();
|
||||
throw;
|
||||
}
|
||||
|
||||
return driver;
|
||||
}
|
||||
|
||||
/// <summary>A key-value tag over the seeded EAV table.</summary>
|
||||
private static RawTagEntry KeyValue(string rawPath, string key) => Tag(rawPath, new JsonObject
|
||||
{
|
||||
["driver"] = "Sql",
|
||||
["model"] = "KeyValue",
|
||||
["table"] = PostgresFixture.Qualified(PostgresFixture.KeyValueTable),
|
||||
["keyColumn"] = PostgresFixture.KeyColumn,
|
||||
["keyValue"] = key,
|
||||
["valueColumn"] = PostgresFixture.ValueColumn,
|
||||
["timestampColumn"] = PostgresFixture.TimestampColumn,
|
||||
});
|
||||
|
||||
/// <summary>A wide-row tag selected by newest timestamp.</summary>
|
||||
private static RawTagEntry WideRowTop(string rawPath, string column) => Tag(rawPath, new JsonObject
|
||||
{
|
||||
["driver"] = "Sql",
|
||||
["model"] = "WideRow",
|
||||
["table"] = PostgresFixture.Qualified(PostgresFixture.WideRowTable),
|
||||
["columnName"] = column,
|
||||
["timestampColumn"] = PostgresFixture.TimestampColumn,
|
||||
["rowSelector"] = new JsonObject
|
||||
{
|
||||
["topByTimestamp"] = PostgresFixture.TimestampColumn,
|
||||
},
|
||||
});
|
||||
|
||||
/// <summary>
|
||||
/// Wraps an authored <c>TagConfig</c> object as a raw tag entry. Composed as a
|
||||
/// <see cref="JsonObject"/> rather than as an interpolated string literal for the reason
|
||||
/// <see cref="SqlServerReadTests"/> gives: a hand-written literal that loses a brace produces a
|
||||
/// config the parser silently rejects, which surfaces as a plausible-looking driver failure.
|
||||
/// </summary>
|
||||
private static RawTagEntry Tag(string rawPath, JsonObject config) =>
|
||||
new(rawPath, config.ToJsonString(), WriteIdempotent: false);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A real, seeded <b>PostgreSQL</b> database standing in for the source the <c>Sql</c> driver polls —
|
||||
/// the Postgres counterpart of <see cref="SqlPollServerFixture"/>.
|
||||
/// <para><b>Env-gated, and the gate is checked before any socket is touched.</b> This fixture opens
|
||||
/// nothing unless <see cref="EndpointEnvVar"/> and <see cref="PasswordEnvVar"/> are both set; absent,
|
||||
/// it records <see cref="SkipReason"/> and every test calls <c>Assert.Skip</c>. That is what keeps
|
||||
/// <c>dotnet test</c> genuinely green (and instant) on the macOS dev box this is usually run from.</para>
|
||||
/// <para><b>This fixture does not seed — the compose stack does</b>
|
||||
/// (<c>Docker/postgres/docker-compose.yml</c> + <c>seed-pg.sql</c>), and that is deliberate rather
|
||||
/// than a shortcut. The seed's whole point is that the schema is owned by a role the suite is
|
||||
/// <em>not</em>: the connecting principal holds <c>USAGE</c> + <c>SELECT</c> and could not create
|
||||
/// roles, schemas or tables even if asked to. A fixture that seeded itself would have to connect as a
|
||||
/// superuser, and the granted-not-owning provisioning that
|
||||
/// <c>PostgresDialect.ListSchemasSql</c> exists for would never be exercised.</para>
|
||||
/// </summary>
|
||||
public sealed class PostgresFixture : IAsyncLifetime
|
||||
{
|
||||
/// <summary>Server endpoint in <c>host:port</c> form (e.g. <c>10.100.0.35:15432</c>). Absent ⇒ skip.</summary>
|
||||
public const string EndpointEnvVar = "SQL_PG_ENDPOINT";
|
||||
|
||||
/// <summary>The login. Defaults to <see cref="DefaultUser"/>, the user the seed grants.</summary>
|
||||
public const string UserEnvVar = "SQL_PG_USER";
|
||||
|
||||
/// <summary>The password. Required — never defaulted (see <see cref="ResolveConnectionString"/>).</summary>
|
||||
public const string PasswordEnvVar = "SQL_PG_PASSWORD";
|
||||
|
||||
/// <summary>The unprivileged login the seed creates and grants USAGE + SELECT to.</summary>
|
||||
public const string DefaultUser = "otopcua";
|
||||
|
||||
/// <summary>Postgres' default port, used when <see cref="EndpointEnvVar"/> carries no port.</summary>
|
||||
public const int DefaultPort = 5432;
|
||||
|
||||
/// <summary>The database the compose stack creates (<c>POSTGRES_DB</c>) and the seed targets.</summary>
|
||||
public const string FixtureDatabase = "sqlpollfixture";
|
||||
|
||||
/// <summary>
|
||||
/// The schema every seeded object lives in — <b>not</b> <c>public</c>, so every authored
|
||||
/// <c>table</c> is a two-part name and the planner's qualified quoting is exercised, and so the
|
||||
/// seed's drop-and-recreate is bounded to objects this fixture owns.
|
||||
/// </summary>
|
||||
public const string Schema = "sqlpoll";
|
||||
|
||||
/// <summary>The <c>Application Name</c> the driver's connections carry, for server-side attribution.</summary>
|
||||
public const string DriverApplicationName = "OtOpcUa.Sql.ITs.pg";
|
||||
|
||||
/// <summary>Seconds a connect attempt may take before the fixture calls the server unreachable.</summary>
|
||||
private const int ProbeConnectTimeoutSeconds = 5;
|
||||
|
||||
// ---- key-value (EAV) source ----
|
||||
|
||||
/// <summary>The key-value table: <c>tag_name varchar(128), num_value double precision NULL, sample_ts timestamp(3)</c>.</summary>
|
||||
public const string KeyValueTable = "tag_values";
|
||||
|
||||
/// <summary>The key-value table's key column.</summary>
|
||||
public const string KeyColumn = "tag_name";
|
||||
|
||||
/// <summary>The key-value table's value column.</summary>
|
||||
public const string ValueColumn = "num_value";
|
||||
|
||||
/// <summary>The source-timestamp column carried by every seeded table.</summary>
|
||||
public const string TimestampColumn = "sample_ts";
|
||||
|
||||
/// <summary>A key whose row exists and whose value cell holds <see cref="PresentValue"/>.</summary>
|
||||
public const string PresentKey = "Line1.Speed";
|
||||
|
||||
/// <summary>The value seeded for <see cref="PresentKey"/>.</summary>
|
||||
public const double PresentValue = 42.0;
|
||||
|
||||
/// <summary>The UTC source timestamp seeded for <see cref="PresentKey"/>.</summary>
|
||||
public static readonly DateTime PresentKeyTimestampUtc = new(2026, 7, 24, 10, 0, 0, DateTimeKind.Utc);
|
||||
|
||||
// ---- wide-row source ----
|
||||
|
||||
/// <summary>The wide-row table: <c>station_id integer, oven_temp/pressure double precision NULL, sample_ts timestamp(3)</c>.</summary>
|
||||
public const string WideRowTable = "latest_status";
|
||||
|
||||
/// <summary>
|
||||
/// The <c>oven_temp</c> of the row holding the <b>newest</b> <c>sample_ts</c> — what a
|
||||
/// <c>topByTimestamp</c> selector must resolve to. Its row is neither the first inserted nor the
|
||||
/// lowest-keyed, so a plan that lost its <c>ORDER BY … DESC</c> or its <c>LIMIT 1</c> picks a
|
||||
/// different value and the test says so.
|
||||
/// </summary>
|
||||
public const double NewestStationOvenTemp = 210.25;
|
||||
|
||||
/// <summary>Why the suite is skipping, or <see langword="null"/> when the server is reachable.</summary>
|
||||
public string? SkipReason { get; private set; }
|
||||
|
||||
/// <summary>The connection string to hand the code under test. Empty while <see cref="SkipReason"/> is set.</summary>
|
||||
public string ConnectionString { get; private set; } = string.Empty;
|
||||
|
||||
/// <summary>The server the fixture resolved, for skip/diagnostic messages. Never carries credentials.</summary>
|
||||
public string Server { get; private set; } = string.Empty;
|
||||
|
||||
/// <summary>Two-part name of a seeded object, in the form an authored tag's <c>table</c> carries.</summary>
|
||||
/// <param name="table">The bare table or view name.</param>
|
||||
/// <returns>The <c>schema.table</c> name.</returns>
|
||||
public static string Qualified(string table) => $"{Schema}.{table}";
|
||||
|
||||
/// <summary>
|
||||
/// Resolves the gate and probes the server with the dialect's own <c>LivenessSql</c>. A failure to
|
||||
/// connect is the offline case and becomes a <see cref="SkipReason"/>; nothing is created or
|
||||
/// seeded here (the compose stack owns that).
|
||||
/// </summary>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
public async ValueTask InitializeAsync()
|
||||
{
|
||||
if (ResolveConnectionString() is not { } resolved)
|
||||
{
|
||||
SkipReason =
|
||||
$"Set {EndpointEnvVar} (host:port) and {PasswordEnvVar} (and optionally {UserEnvVar}, " +
|
||||
$"default '{DefaultUser}') to run the Sql driver's live PostgreSQL suite. Bring the " +
|
||||
"fixture up from Docker/postgres/docker-compose.yml first. No connection is attempted " +
|
||||
"without these.";
|
||||
return;
|
||||
}
|
||||
|
||||
ConnectionString = resolved;
|
||||
|
||||
var dialect = new PostgresDialect();
|
||||
try
|
||||
{
|
||||
var connection = dialect.Factory.CreateConnection()
|
||||
?? throw new InvalidOperationException("Npgsql returned no connection object.");
|
||||
await using (connection.ConfigureAwait(false))
|
||||
{
|
||||
connection.ConnectionString = ConnectionString;
|
||||
await connection.OpenAsync().ConfigureAwait(false);
|
||||
|
||||
var command = connection.CreateCommand();
|
||||
await using (command.ConfigureAwait(false))
|
||||
{
|
||||
command.CommandText = dialect.LivenessSql;
|
||||
await command.ExecuteScalarAsync().ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
SkipReason =
|
||||
$"PostgreSQL at '{Server}' was not reachable within {ProbeConnectTimeoutSeconds}s " +
|
||||
$"({ex.GetType().Name}: {ex.Message}). Check {EndpointEnvVar}/{UserEnvVar}/" +
|
||||
$"{PasswordEnvVar} and that the fixture stack is up, or leave them unset to skip.";
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Holds no long-lived connection, so there is nothing to tear down.</summary>
|
||||
/// <returns>A completed task.</returns>
|
||||
public ValueTask DisposeAsync() => ValueTask.CompletedTask;
|
||||
|
||||
/// <summary>
|
||||
/// Reads the gate and composes the connection string <b>through the dialect's own provider
|
||||
/// factory</b> (<see cref="DbProviderFactory.CreateConnectionStringBuilder"/>), setting keys via
|
||||
/// the abstract <see cref="DbConnectionStringBuilder"/> indexer.
|
||||
/// <para>That indirection is deliberate: it keeps this project free of a direct Npgsql
|
||||
/// <c>PackageReference</c>, so the suite can only ever exercise the provider version the driver
|
||||
/// actually ships (see the csproj's no-direct-provider-reference note). Every key used here —
|
||||
/// <c>Host</c>, <c>Port</c>, <c>Database</c>, <c>Username</c>, <c>Password</c>, <c>Timeout</c>,
|
||||
/// <c>Application Name</c> — was verified to be accepted through that indexer, so no
|
||||
/// provider-specific property is needed.</para>
|
||||
/// </summary>
|
||||
/// <returns>The connection string, or <see langword="null"/> — touching no socket — when unconfigured.</returns>
|
||||
private string? ResolveConnectionString()
|
||||
{
|
||||
if (Environment.GetEnvironmentVariable(EndpointEnvVar) is not { Length: > 0 } endpoint) return null;
|
||||
|
||||
// A password is required rather than defaulted: guessing one would turn a misconfiguration into a
|
||||
// failed login, which is how accounts get locked out on a server that is not a throwaway.
|
||||
if (Environment.GetEnvironmentVariable(PasswordEnvVar) is not { Length: > 0 } password) return null;
|
||||
|
||||
var user = Environment.GetEnvironmentVariable(UserEnvVar) is { Length: > 0 } named
|
||||
? named
|
||||
: DefaultUser;
|
||||
|
||||
var (host, port) = SplitEndpoint(endpoint, DefaultPort);
|
||||
Server = $"{host}:{port}";
|
||||
|
||||
var builder = new PostgresDialect().Factory.CreateConnectionStringBuilder()
|
||||
?? throw new InvalidOperationException("Npgsql returned no connection-string builder.");
|
||||
builder["Host"] = host;
|
||||
builder["Port"] = port;
|
||||
builder["Database"] = FixtureDatabase;
|
||||
builder["Username"] = user;
|
||||
builder["Password"] = password;
|
||||
builder["Timeout"] = ProbeConnectTimeoutSeconds;
|
||||
builder["Application Name"] = DriverApplicationName;
|
||||
return builder.ConnectionString;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Splits a <c>host:port</c> endpoint, defaulting the port when absent or unparseable. Split on the
|
||||
/// LAST colon so a bracketed IPv6 literal keeps its own colons.
|
||||
/// </summary>
|
||||
/// <param name="endpoint">The authored endpoint.</param>
|
||||
/// <param name="defaultPort">The port to use when none is carried.</param>
|
||||
/// <returns>The host and port.</returns>
|
||||
internal static (string Host, int Port) SplitEndpoint(string endpoint, int defaultPort)
|
||||
{
|
||||
var separator = endpoint.LastIndexOf(':');
|
||||
if (separator <= 0 || separator == endpoint.Length - 1) return (endpoint, defaultPort);
|
||||
|
||||
var host = endpoint[..separator];
|
||||
return int.TryParse(
|
||||
endpoint[(separator + 1)..], NumberStyles.Integer, CultureInfo.InvariantCulture, out var port)
|
||||
? (host, port)
|
||||
: (endpoint, defaultPort);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Collection definition so the gate is resolved once per test session rather than once per test
|
||||
/// class — the same shape as <see cref="SqlPollServerCollection"/>.
|
||||
/// </summary>
|
||||
[CollectionDefinition(Name)]
|
||||
public sealed class PostgresCollection : ICollectionFixture<PostgresFixture>
|
||||
{
|
||||
/// <summary>The collection name test classes reference.</summary>
|
||||
public const string Name = "SqlPostgresServer";
|
||||
}
|
||||
+11
-3
@@ -27,12 +27,20 @@
|
||||
</ItemGroup>
|
||||
|
||||
<!--
|
||||
No Microsoft.Data.SqlClient PackageReference here on purpose: this suite must exercise EXACTLY the
|
||||
provider the driver ships, and it arrives transitively through Driver.Sql. Adding it here would let
|
||||
the two versions drift and the suite would then prove something about a provider nobody deploys.
|
||||
No Microsoft.Data.SqlClient / Npgsql / Oracle.ManagedDataAccess.Core PackageReference here on purpose:
|
||||
this suite must exercise EXACTLY the providers the driver ships, and they arrive transitively through
|
||||
Driver.Sql. Adding one here would let the two versions drift and the suite would then prove something
|
||||
about a provider nobody deploys. The Postgres and Oracle suites therefore never name a provider type:
|
||||
they compose their connection strings through `dialect.Factory.CreateConnectionStringBuilder()` and the
|
||||
abstract DbConnectionStringBuilder indexer.
|
||||
|
||||
Driver.Sql.Browser is referenced for the browse-session walk (schema → table → column) the Postgres and
|
||||
Oracle suites drive through the AdminUI's real seam, SqlDriverBrowser — the only place the dialects'
|
||||
catalog SQL is exercised as the picker actually calls it.
|
||||
-->
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\..\..\src\Drivers\ZB.MOM.WW.OtOpcUa.Driver.Sql\ZB.MOM.WW.OtOpcUa.Driver.Sql.csproj"/>
|
||||
<ProjectReference Include="..\..\..\src\Drivers\ZB.MOM.WW.OtOpcUa.Driver.Sql.Browser\ZB.MOM.WW.OtOpcUa.Driver.Sql.Browser.csproj"/>
|
||||
<ProjectReference Include="..\..\..\src\Drivers\ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts\ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts.csproj"/>
|
||||
</ItemGroup>
|
||||
|
||||
|
||||
@@ -0,0 +1,116 @@
|
||||
using System.Data.Common;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.Sql.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// A <b>test-only</b> dialect that spells parameters the ODP.NET way — <c>:name</c> in the SQL text and a
|
||||
/// <b>bare</b> <c>name</c> as the <see cref="DbParameter.ParameterName"/> — over the SQLite fixture. It is
|
||||
/// the falsifiability control for dialect-owned parameter naming: every marker in this repo was hardcoded
|
||||
/// <c>"@"</c> before, and a planner or loader that still hardcodes it emits <c>@k0</c> against this
|
||||
/// dialect and fails loudly.
|
||||
/// <para><b>Why the two halves must differ.</b> A dialect whose marker and bind name are the same string
|
||||
/// (SQL Server, Npgsql, SQLite) cannot tell a call site that <em>copies</em> the plan's bind name apart
|
||||
/// from one that reuses the marker. Oracle is the provider where they genuinely diverge, so this fake
|
||||
/// reproduces that divergence rather than merely changing the prefix.</para>
|
||||
/// <para><b>It really executes.</b> Everything but the parameter naming (and the catalog SQL's markers)
|
||||
/// delegates to <see cref="SqliteDialect"/>, and Microsoft.Data.Sqlite accepts both a <c>:</c>-prefixed
|
||||
/// marker and a prefix-less parameter name — so a poll or a catalog load driven through this dialect runs
|
||||
/// against the real fixture database rather than being asserted on as text.</para>
|
||||
/// <para>A decorator rather than a subclass: <see cref="SqliteDialect"/> is sealed, and
|
||||
/// <c>new</c>-hiding a member would leave interface dispatch calling the original — the substitution
|
||||
/// would silently not happen and the control would pass for the wrong reason.</para>
|
||||
/// </summary>
|
||||
public sealed class ColonMarkerDialect : ISqlDialect
|
||||
{
|
||||
private static readonly SqliteDialect Inner = new();
|
||||
|
||||
/// <summary>Every command handed to <see cref="ConfigureCommand"/>, kept so its binds can be read back.</summary>
|
||||
private readonly List<DbCommand> _commands = [];
|
||||
|
||||
/// <summary>How many times <see cref="ConfigureCommand"/> has been called on this instance.</summary>
|
||||
/// <remarks>
|
||||
/// Oracle's <c>BindByName</c> is set here, and a command created without it mis-binds by position
|
||||
/// rather than failing — so "was every command configured" has to be observable to be testable.
|
||||
/// </remarks>
|
||||
public int ConfiguredCommands
|
||||
{
|
||||
get { lock (_commands) return _commands.Count; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The <see cref="DbParameter.ParameterName"/> of every parameter bound on every configured command,
|
||||
/// read after the fact.
|
||||
/// <para><b>Why this and not the query's own success.</b> Microsoft.Data.Sqlite resolves a parameter
|
||||
/// whether it is named <c>:k0</c> or bare <c>k0</c>, so a poll that returns the right values proves
|
||||
/// the SQL parsed — not that the caller bound the dialect's bind name. Only the name actually put on
|
||||
/// the parameter distinguishes the two, and on ODP.NET the wrong one is a hard bind failure.</para>
|
||||
/// </summary>
|
||||
public IReadOnlyList<string> BoundParameterNames
|
||||
{
|
||||
get
|
||||
{
|
||||
lock (_commands)
|
||||
return _commands
|
||||
.SelectMany(c => c.Parameters.Cast<DbParameter>())
|
||||
.Select(p => p.ParameterName)
|
||||
.ToList();
|
||||
}
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public SqlProvider Provider => Inner.Provider;
|
||||
|
||||
/// <inheritdoc/>
|
||||
public DbProviderFactory Factory => Inner.Factory;
|
||||
|
||||
/// <inheritdoc/>
|
||||
public string LivenessSql => Inner.LivenessSql;
|
||||
|
||||
/// <inheritdoc/>
|
||||
public string SingleRowLimitPrefix => Inner.SingleRowLimitPrefix;
|
||||
|
||||
/// <inheritdoc/>
|
||||
public string SingleRowLimitSuffix => Inner.SingleRowLimitSuffix;
|
||||
|
||||
/// <inheritdoc/>
|
||||
public string ListSchemasSql => Colonize(Inner.ListSchemasSql);
|
||||
|
||||
/// <inheritdoc/>
|
||||
public string DefaultSchemaSql => Colonize(Inner.DefaultSchemaSql);
|
||||
|
||||
/// <inheritdoc/>
|
||||
public string ListTablesSql => Colonize(Inner.ListTablesSql);
|
||||
|
||||
/// <inheritdoc/>
|
||||
public string ListColumnsSql => Colonize(Inner.ListColumnsSql);
|
||||
|
||||
/// <inheritdoc/>
|
||||
public string ParameterMarker(string baseName) => ":" + baseName;
|
||||
|
||||
/// <summary>The bare name, with no prefix — ODP.NET's convention, and deliberately NOT the marker.</summary>
|
||||
/// <param name="baseName">The planner's/loader's base name.</param>
|
||||
/// <returns>The bind name.</returns>
|
||||
public string ParameterBindName(string baseName) => baseName;
|
||||
|
||||
/// <inheritdoc/>
|
||||
public void ConfigureCommand(DbCommand command)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(command);
|
||||
lock (_commands) _commands.Add(command);
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public string QuoteIdentifier(string ident) => Inner.QuoteIdentifier(ident);
|
||||
|
||||
/// <inheritdoc/>
|
||||
public DriverDataType MapColumnType(string sqlDataType) => Inner.MapColumnType(sqlDataType);
|
||||
|
||||
/// <summary>
|
||||
/// Rewrites the SQLite dialect's <c>@</c> markers as <c>:</c> markers. The catalog SQL is dialect-owned
|
||||
/// text, so a colon-marker dialect must carry colon markers in it — that is precisely the coupling the
|
||||
/// catalog loader's bind names have to stay in step with.
|
||||
/// </summary>
|
||||
private static string Colonize(string sql) => sql.Replace('@', ':');
|
||||
}
|
||||
@@ -0,0 +1,298 @@
|
||||
using Microsoft.Data.Sqlite;
|
||||
using Oracle.ManagedDataAccess.Client;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.Sql.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Golden tests for <see cref="OracleDialect"/>, mirroring <see cref="SqlServerDialectTests"/>: the
|
||||
/// quoting/injection boundary, the exact catalog SQL, the type-family map — plus the two tests that only
|
||||
/// Oracle needs, pinning <c>OracleCommand.BindByName</c>.
|
||||
/// </summary>
|
||||
public class OracleDialectTests
|
||||
{
|
||||
// ---- the load-bearing pair: ODP.NET binds by POSITION unless told otherwise ----
|
||||
|
||||
/// <summary>
|
||||
/// The sharpest correctness edge on the whole provider seam. A real <see cref="OracleCommand"/> — no
|
||||
/// connection needed — must report <c>BindByName == false</c> before
|
||||
/// <see cref="OracleDialect.ConfigureCommand"/> touches it and <c>true</c> afterwards.
|
||||
/// <para><b>The false-by-default half is the falsifiability control.</b> Asserting only the post-state
|
||||
/// would pass identically against an ODP.NET release that had flipped the default — i.e. it would prove
|
||||
/// nothing about whether this dialect's call is load-bearing. Pinning both halves means the day the
|
||||
/// provider default changes, this test says so instead of quietly becoming a tautology.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ConfigureCommand_turnsOnBindByName_whichOdpNetLeavesOffByDefault()
|
||||
{
|
||||
using var command = new OracleCommand();
|
||||
|
||||
command.BindByName.ShouldBeFalse(
|
||||
"ODP.NET binds by position by default — if this ever changes, the dialect's ConfigureCommand " +
|
||||
"is no longer what makes named binding work and this test must be re-reasoned, not deleted.");
|
||||
|
||||
new OracleDialect().ConfigureCommand(command);
|
||||
|
||||
command.BindByName.ShouldBeTrue();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A command from another provider passes through untouched and, crucially, does <b>not</b> throw:
|
||||
/// the dialect can legitimately meet a foreign <c>DbCommand</c> (an instrumented or substituted
|
||||
/// factory in a shared test harness), and an <c>InvalidCastException</c> there would fail a poll for a
|
||||
/// reason that has nothing to do with the database.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ConfigureCommand_leavesAForeignCommandUntouched()
|
||||
{
|
||||
using var command = new SqliteCommand("SELECT 1");
|
||||
|
||||
Should.NotThrow(() => new OracleDialect().ConfigureCommand(command));
|
||||
|
||||
command.CommandText.ShouldBe("SELECT 1");
|
||||
command.Parameters.Count.ShouldBe(0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ParameterMarker_isColonPrefixed_andTheBindNameIsTheSameNameWithoutTheColon()
|
||||
{
|
||||
var d = new OracleDialect();
|
||||
|
||||
// The whole reason ISqlDialect models these as two members: on ODP.NET they are different strings.
|
||||
d.ParameterMarker("k0").ShouldBe(":p_k0");
|
||||
d.ParameterBindName("k0").ShouldBe("p_k0");
|
||||
d.ParameterMarker("schema").ShouldBe(":p_schema");
|
||||
d.ParameterBindName("schema").ShouldBe("p_schema");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// No bind name may be spelled as its bare base name — the <c>p_</c> namespace is what stops one
|
||||
/// colliding with an Oracle reserved word.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <b>This is a regression test for a live-found, provider-fatal defect.</b> The catalog readers bind
|
||||
/// a parameter whose base name is <c>table</c>, and Oracle rejects a bind variable named after a
|
||||
/// reserved word outright: <c>ORA-01745: invalid host/bind variable name</c>. With the un-prefixed
|
||||
/// names this dialect first shipped with, <c>ListColumnsSql</c> could not execute at all — so every
|
||||
/// Oracle driver instance failed its Initialize-time catalog load and rejected every authored tag, and
|
||||
/// every AdminUI browse of a table's columns threw. It was invisible to every offline test (only a
|
||||
/// server parses the SQL) and was caught by <c>OracleReadTests</c> against a real database.
|
||||
/// <para><c>table</c> is asserted explicitly because it is the one base name in use today that is
|
||||
/// actually reserved; the others guard the general rule.</para>
|
||||
/// </remarks>
|
||||
[Theory]
|
||||
[InlineData("table")]
|
||||
[InlineData("schema")]
|
||||
[InlineData("k0")]
|
||||
public void ParameterBindName_neverSurfacesTheBareBaseName_soItCannotBeAReservedWord(string baseName)
|
||||
{
|
||||
var d = new OracleDialect();
|
||||
|
||||
d.ParameterBindName(baseName).ShouldNotBe(baseName);
|
||||
d.ParameterMarker(baseName).ShouldNotBe(":" + baseName);
|
||||
// The two must stay derived from one another, or a statement's marker and its bind drift apart and
|
||||
// ODP.NET silently leaves the parameter unbound.
|
||||
d.ParameterMarker(baseName).ShouldBe(":" + d.ParameterBindName(baseName));
|
||||
}
|
||||
|
||||
// ---- identity ----
|
||||
|
||||
[Fact]
|
||||
public void Dialect_identifiesItselfAsOracle_andExposesTheAbstractFactory()
|
||||
{
|
||||
var d = new OracleDialect();
|
||||
d.Provider.ShouldBe(SqlProvider.Oracle);
|
||||
d.Factory.ShouldNotBeNull();
|
||||
d.Factory.ShouldBeOfType<OracleClientFactory>();
|
||||
}
|
||||
|
||||
// ---- quoting / injection boundary ----
|
||||
|
||||
[Fact]
|
||||
public void QuoteIdentifier_doubleQuotesAndEscapesEmbeddedQuotes()
|
||||
{
|
||||
var d = new OracleDialect();
|
||||
d.QuoteIdentifier("SPEED").ShouldBe("\"SPEED\"");
|
||||
d.QuoteIdentifier("a\"b").ShouldBe("\"a\"\"b\""); // " doubled, per Oracle's quoted-identifier rule
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void QuoteIdentifier_escapesAnIdentifierThatIsNothingButAQuote()
|
||||
=> new OracleDialect().QuoteIdentifier("\"").ShouldBe("\"\"\"\"");
|
||||
|
||||
[Fact]
|
||||
public void QuoteIdentifier_neutralisesAClassicInjectionPayload()
|
||||
{
|
||||
// The only metacharacter that could terminate a quoted identifier early is ", and it is doubled.
|
||||
// The result is a single (nonexistent) identifier, never executable SQL.
|
||||
new OracleDialect().QuoteIdentifier("x\" ; DROP TABLE Users --")
|
||||
.ShouldBe("\"x\"\" ; DROP TABLE Users --\"");
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(null)]
|
||||
[InlineData("")]
|
||||
[InlineData(" ")]
|
||||
[InlineData("\t")]
|
||||
public void QuoteIdentifier_rejectsNullEmptyAndWhitespace(string? ident)
|
||||
=> Should.Throw<ArgumentException>(() => new OracleDialect().QuoteIdentifier(ident!));
|
||||
|
||||
// NUL alone would still pass against a `Contains('\0')` regression, so pin the whole Cc category.
|
||||
[Theory]
|
||||
[InlineData("x\0y")]
|
||||
[InlineData("x\u0001y")] // C0 SOH
|
||||
[InlineData("x\u001By")] // C0 ESC
|
||||
[InlineData("x\u007Fy")] // DEL
|
||||
[InlineData("x\u0085y")] // C1 NEL
|
||||
[InlineData("x\ty")]
|
||||
[InlineData("x\ny")]
|
||||
public void QuoteIdentifier_rejectsEveryControlCharacter_notJustNul(string ident)
|
||||
=> Should.Throw<ArgumentException>(() => new OracleDialect().QuoteIdentifier(ident));
|
||||
|
||||
// Unicode Format (Cf) is a distinct category from Control (Cc): char.IsControl returns false for all of
|
||||
// these. They cannot escape the quotes, but they spoof rendered log/AdminUI text while comparing
|
||||
// byte-different from the real catalog name (Trojan Source, CVE-2021-42574).
|
||||
[Theory]
|
||||
[InlineData("SP\u200BEED")] // zero-width space
|
||||
[InlineData("\u202Ediop.selbat")] // right-to-left override
|
||||
[InlineData("x\u2066y\u2069")] // bidi isolates
|
||||
[InlineData("x\uFEFFy")] // BOM / zero-width no-break space
|
||||
[InlineData("x\u00ADy")] // soft hyphen
|
||||
public void QuoteIdentifier_rejectsUnicodeFormatCharacters(string ident)
|
||||
=> Should.Throw<ArgumentException>(() => new OracleDialect().QuoteIdentifier(ident));
|
||||
|
||||
[Fact]
|
||||
public void QuoteIdentifier_acceptsExactly128Chars_andRejects129()
|
||||
{
|
||||
var d = new OracleDialect();
|
||||
d.QuoteIdentifier(new string('a', 128)).ShouldBe("\"" + new string('a', 128) + "\"");
|
||||
Should.Throw<ArgumentException>(() => d.QuoteIdentifier(new string('a', 129)));
|
||||
}
|
||||
|
||||
// ---- liveness + row limit ----
|
||||
|
||||
[Fact]
|
||||
public void LivenessSql_selectsFromDual()
|
||||
=> new OracleDialect().LivenessSql.ShouldBe("SELECT 1 FROM DUAL");
|
||||
|
||||
[Fact]
|
||||
public void SingleRowLimit_isFetchFirst_inTheSuffixPosition_withItsOwnLeadingSpace()
|
||||
{
|
||||
var d = new OracleDialect();
|
||||
|
||||
// Oracle 12c+ spells the limit at the END of the statement, so the prefix must be empty — a
|
||||
// non-empty one would land between SELECT and the column list and produce invalid SQL.
|
||||
d.SingleRowLimitPrefix.ShouldBe("");
|
||||
d.SingleRowLimitSuffix.ShouldBe(" FETCH FIRST 1 ROWS ONLY");
|
||||
string.Concat("SELECT ", d.SingleRowLimitPrefix, "\"A\" FROM \"T\"", d.SingleRowLimitSuffix)
|
||||
.ShouldBe("SELECT \"A\" FROM \"T\" FETCH FIRST 1 ROWS ONLY");
|
||||
}
|
||||
|
||||
// ---- catalog SQL ----
|
||||
|
||||
[Fact]
|
||||
public void CatalogSql_readsTheAllViews_neverInformationSchema()
|
||||
{
|
||||
var d = new OracleDialect();
|
||||
|
||||
// Oracle has no INFORMATION_SCHEMA at all; the ALL_* views are the portable equivalent.
|
||||
d.ListSchemasSql.ShouldContain("ALL_USERS");
|
||||
d.ListTablesSql.ShouldContain("ALL_TABLES");
|
||||
d.ListTablesSql.ShouldContain("ALL_VIEWS"); // INFORMATION_SCHEMA.TABLES includes views
|
||||
d.ListColumnsSql.ShouldContain("ALL_TAB_COLUMNS");
|
||||
d.DefaultSchemaSql.ShouldBe("SELECT sys_context('userenv','current_schema') FROM dual");
|
||||
|
||||
d.ListSchemasSql.ShouldNotContain("INFORMATION_SCHEMA");
|
||||
d.ListTablesSql.ShouldNotContain("INFORMATION_SCHEMA");
|
||||
d.ListColumnsSql.ShouldNotContain("INFORMATION_SCHEMA");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CatalogSql_isParameterizedWithColonMarkers_matchingParameterMarker()
|
||||
{
|
||||
var d = new OracleDialect();
|
||||
|
||||
d.ListTablesSql.ShouldContain(d.ParameterMarker("schema")); // never string-interpolated
|
||||
d.ListColumnsSql.ShouldContain(d.ParameterMarker("schema"));
|
||||
d.ListColumnsSql.ShouldContain(d.ParameterMarker("table"));
|
||||
|
||||
// A leftover @ marker would bind on SqlClient and silently be a literal here.
|
||||
d.ListTablesSql.ShouldNotContain("@");
|
||||
d.ListColumnsSql.ShouldNotContain("@");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// <c>SqlCatalogLoader</c>/<c>SqlBrowseSession</c> project catalog columns by the
|
||||
/// <c>INFORMATION_SCHEMA</c> names, so every dialect must alias its columns to them or
|
||||
/// <c>GetOrdinal</c> throws at runtime — a failure the SQL text alone would not reveal.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void CatalogSql_aliasesItsColumnsToTheInformationSchemaNamesTheReadersProjectBy()
|
||||
{
|
||||
var d = new OracleDialect();
|
||||
|
||||
d.ListSchemasSql.ShouldContain("TABLE_SCHEMA");
|
||||
d.ListTablesSql.ShouldContain("TABLE_NAME");
|
||||
d.ListTablesSql.ShouldContain("TABLE_TYPE");
|
||||
d.ListColumnsSql.ShouldContain("COLUMN_NAME");
|
||||
d.ListColumnsSql.ShouldContain("DATA_TYPE");
|
||||
|
||||
// SqlBrowseSession compares TABLE_TYPE against the literal "VIEW" to mark a view node.
|
||||
d.ListTablesSql.ShouldContain("'VIEW'");
|
||||
d.ListTablesSql.ShouldContain("'BASE TABLE'");
|
||||
}
|
||||
|
||||
// ---- type map ----
|
||||
|
||||
[Theory]
|
||||
[InlineData("NUMBER", DriverDataType.Float64)]
|
||||
[InlineData("FLOAT", DriverDataType.Float64)]
|
||||
[InlineData("BINARY_DOUBLE", DriverDataType.Float64)]
|
||||
[InlineData("BINARY_FLOAT", DriverDataType.Float32)]
|
||||
[InlineData("INTEGER", DriverDataType.Float64)]
|
||||
[InlineData("VARCHAR2", DriverDataType.String)]
|
||||
[InlineData("NVARCHAR2", DriverDataType.String)]
|
||||
[InlineData("CHAR", DriverDataType.String)]
|
||||
[InlineData("NCHAR", DriverDataType.String)]
|
||||
[InlineData("CLOB", DriverDataType.String)]
|
||||
[InlineData("NCLOB", DriverDataType.String)]
|
||||
[InlineData("DATE", DriverDataType.DateTime)]
|
||||
public void MapColumnType_mapsFamilies(string sql, DriverDataType expected)
|
||||
=> new OracleDialect().MapColumnType(sql).ShouldBe(expected);
|
||||
|
||||
/// <summary>
|
||||
/// <c>ALL_TAB_COLUMNS.DATA_TYPE</c> carries the fractional-seconds precision and the time-zone
|
||||
/// qualifier <em>inside</em> the family name, unlike <c>INFORMATION_SCHEMA</c>. An exact-match table
|
||||
/// would send every one of these to the String fallback.
|
||||
/// </summary>
|
||||
[Theory]
|
||||
[InlineData("TIMESTAMP")]
|
||||
[InlineData("TIMESTAMP(6)")]
|
||||
[InlineData("TIMESTAMP(3)")]
|
||||
[InlineData("TIMESTAMP(6) WITH TIME ZONE")]
|
||||
[InlineData("TIMESTAMP(6) WITH LOCAL TIME ZONE")]
|
||||
public void MapColumnType_matchesTheTimestampFamilyByPrefix(string sql)
|
||||
=> new OracleDialect().MapColumnType(sql).ShouldBe(DriverDataType.DateTime);
|
||||
|
||||
[Theory]
|
||||
[InlineData("number", DriverDataType.Float64)]
|
||||
[InlineData("VarChar2", DriverDataType.String)]
|
||||
[InlineData("timestamp(6)", DriverDataType.DateTime)]
|
||||
public void MapColumnType_isCaseInsensitive(string sql, DriverDataType expected)
|
||||
=> new OracleDialect().MapColumnType(sql).ShouldBe(expected);
|
||||
|
||||
[Theory]
|
||||
[InlineData("RAW")] // binary, like SQL Server's varbinary
|
||||
[InlineData("BLOB")]
|
||||
[InlineData("LONG RAW")]
|
||||
[InlineData("ROWID")]
|
||||
[InlineData("XMLTYPE")]
|
||||
[InlineData("INTERVAL DAY(3) TO SECOND(6)")] // a duration, deliberately NOT a DateTime
|
||||
[InlineData("")]
|
||||
[InlineData(null)]
|
||||
public void MapColumnType_unknownFamilyFallsBackToString_andNeverThrows(string? sql)
|
||||
=> new OracleDialect().MapColumnType(sql!).ShouldBe(DriverDataType.String);
|
||||
}
|
||||
@@ -0,0 +1,229 @@
|
||||
using Microsoft.Data.Sqlite;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Sql.Contracts;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.Sql.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Golden tests for <see cref="PostgresDialect"/>, mirroring <see cref="SqlServerDialectTests"/> rule for
|
||||
/// rule: the same injection boundary (values bound, identifiers quoted), the same rejection discipline,
|
||||
/// and the exact catalog SQL. Where Postgres deliberately differs from T-SQL — double-quote escaping, a
|
||||
/// 63-character identifier ceiling, the end-of-statement <c>LIMIT 1</c>, and <c>bit</c> being a bit string
|
||||
/// rather than a boolean — the divergence is pinned here rather than left to reading.
|
||||
/// </summary>
|
||||
public class PostgresDialectTests
|
||||
{
|
||||
[Fact]
|
||||
public void QuoteIdentifier_doubleQuotesAndEscapesEmbeddedQuotes()
|
||||
{
|
||||
var d = new PostgresDialect();
|
||||
d.QuoteIdentifier("Speed").ShouldBe("\"Speed\"");
|
||||
// " doubled, per the SQL-standard rule Postgres follows.
|
||||
d.QuoteIdentifier("a\"b").ShouldBe("\"a\"\"b\"");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void QuoteIdentifier_rejectsControlCharsAndNul()
|
||||
=> Should.Throw<ArgumentException>(() => new PostgresDialect().QuoteIdentifier("x\0y"));
|
||||
|
||||
// NUL alone would still pass against a `Contains('\0')` regression, so pin the whole Cc category. The
|
||||
// code points are spelled numerically so the offending characters never appear raw in this source file.
|
||||
[Theory]
|
||||
[InlineData(0x0001)] // C0 SOH
|
||||
[InlineData(0x001B)] // C0 ESC
|
||||
[InlineData(0x007F)] // DEL
|
||||
[InlineData(0x0085)] // C1 NEL
|
||||
[InlineData(0x0009)] // TAB
|
||||
[InlineData(0x000A)] // LF
|
||||
public void QuoteIdentifier_rejectsEveryControlCharacter_notJustNul(int codePoint)
|
||||
=> Should.Throw<ArgumentException>(
|
||||
() => new PostgresDialect().QuoteIdentifier("x" + (char)codePoint + "y"));
|
||||
|
||||
// Unicode Format (Cf) is a distinct category from Control (Cc): char.IsControl returns false for all of
|
||||
// these. They cannot escape the quotes, but they spoof rendered log/AdminUI text while comparing
|
||||
// byte-different from the real catalog name (Trojan Source, CVE-2021-42574).
|
||||
[Theory]
|
||||
[InlineData(0x200B)] // zero-width space
|
||||
[InlineData(0x202E)] // right-to-left override
|
||||
[InlineData(0x2066)] // left-to-right isolate
|
||||
[InlineData(0xFEFF)] // BOM / zero-width no-break space
|
||||
[InlineData(0x00AD)] // soft hyphen
|
||||
public void QuoteIdentifier_rejectsUnicodeFormatCharacters(int codePoint)
|
||||
=> Should.Throw<ArgumentException>(
|
||||
() => new PostgresDialect().QuoteIdentifier("Sp" + (char)codePoint + "eed"));
|
||||
|
||||
[Theory]
|
||||
[InlineData(null)]
|
||||
[InlineData("")]
|
||||
[InlineData(" ")]
|
||||
[InlineData("\t")]
|
||||
public void QuoteIdentifier_rejectsNullEmptyAndWhitespace(string? ident)
|
||||
=> Should.Throw<ArgumentException>(() => new PostgresDialect().QuoteIdentifier(ident!));
|
||||
|
||||
[Fact]
|
||||
public void QuoteIdentifier_escapesAnIdentifierThatIsNothingButAQuote()
|
||||
=> new PostgresDialect().QuoteIdentifier("\"").ShouldBe("\"\"\"\""); // the 1-char name "
|
||||
|
||||
// NAMEDATALEN - 1: a longer string cannot name a real Postgres object (the server truncates it), so it
|
||||
// is a config mistake rather than something to quote and send.
|
||||
[Fact]
|
||||
public void QuoteIdentifier_acceptsExactly63Chars_andRejects64()
|
||||
{
|
||||
var d = new PostgresDialect();
|
||||
d.QuoteIdentifier(new string('a', 63)).ShouldBe("\"" + new string('a', 63) + "\"");
|
||||
Should.Throw<ArgumentException>(() => d.QuoteIdentifier(new string('a', 64)));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void QuoteIdentifier_neutralisesAClassicInjectionPayload()
|
||||
{
|
||||
// A hostile "column name" cannot escape the quotes: the only metacharacter that could is ", and it
|
||||
// is doubled. The result is a single (nonexistent) identifier, never executable SQL.
|
||||
new PostgresDialect().QuoteIdentifier("x\" ; DROP TABLE users --")
|
||||
.ShouldBe("\"x\"\" ; DROP TABLE users --\"");
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData("boolean", DriverDataType.Boolean)]
|
||||
[InlineData("smallint", DriverDataType.Int16)]
|
||||
[InlineData("integer", DriverDataType.Int32)]
|
||||
[InlineData("bigint", DriverDataType.Int64)]
|
||||
[InlineData("real", DriverDataType.Float32)]
|
||||
[InlineData("double precision", DriverDataType.Float64)]
|
||||
[InlineData("numeric", DriverDataType.Float64)]
|
||||
[InlineData("text", DriverDataType.String)]
|
||||
[InlineData("character varying", DriverDataType.String)]
|
||||
[InlineData("character", DriverDataType.String)]
|
||||
[InlineData("uuid", DriverDataType.String)]
|
||||
[InlineData("timestamp without time zone", DriverDataType.DateTime)]
|
||||
[InlineData("timestamp with time zone", DriverDataType.DateTime)]
|
||||
[InlineData("date", DriverDataType.DateTime)]
|
||||
public void MapColumnType_mapsFamilies(string sql, DriverDataType expected)
|
||||
=> new PostgresDialect().MapColumnType(sql).ShouldBe(expected);
|
||||
|
||||
[Theory]
|
||||
[InlineData("BOOLEAN", DriverDataType.Boolean)]
|
||||
[InlineData("Double Precision", DriverDataType.Float64)]
|
||||
public void MapColumnType_isCaseInsensitive(string sql, DriverDataType expected)
|
||||
=> new PostgresDialect().MapColumnType(sql).ShouldBe(expected);
|
||||
|
||||
[Theory]
|
||||
[InlineData("bytea")] // binary, exactly as SQL Server's varbinary falls back
|
||||
[InlineData("bit")] // a Postgres BIT STRING, deliberately NOT a boolean
|
||||
[InlineData("bit varying")]
|
||||
[InlineData("time without time zone")] // a time of day, not a point in time (mirrors T-SQL `time`)
|
||||
[InlineData("interval")]
|
||||
[InlineData("json")]
|
||||
[InlineData("ARRAY")]
|
||||
[InlineData("USER-DEFINED")]
|
||||
[InlineData("")]
|
||||
[InlineData(null)]
|
||||
public void MapColumnType_unknownFamilyFallsBackToString_andNeverThrows(string? sql)
|
||||
=> new PostgresDialect().MapColumnType(sql!).ShouldBe(DriverDataType.String);
|
||||
|
||||
[Fact]
|
||||
public void CatalogSql_isInformationSchemaAndParameterized()
|
||||
{
|
||||
var d = new PostgresDialect();
|
||||
d.LivenessSql.ShouldBe("SELECT 1");
|
||||
d.DefaultSchemaSql.ShouldBe("SELECT current_schema()");
|
||||
d.ListTablesSql.ShouldContain("information_schema.tables");
|
||||
d.ListColumnsSql.ShouldContain("information_schema.columns");
|
||||
d.ListTablesSql.ShouldContain("@schema"); // never string-interpolated
|
||||
d.ListColumnsSql.ShouldContain("@schema");
|
||||
d.ListColumnsSql.ShouldContain("@table");
|
||||
}
|
||||
|
||||
// The markers baked into the catalog SQL text and the ones ParameterMarker hands the loader must be the
|
||||
// same string, or the loader binds a name the statement never mentions.
|
||||
[Fact]
|
||||
public void CatalogSql_markersAgreeWithParameterMarker()
|
||||
{
|
||||
var d = new PostgresDialect();
|
||||
d.ListTablesSql.ShouldContain(d.ParameterMarker("schema"));
|
||||
d.ListColumnsSql.ShouldContain(d.ParameterMarker("schema"));
|
||||
d.ListColumnsSql.ShouldContain(d.ParameterMarker("table"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ListSchemasSql_excludesTheSystemSchemas()
|
||||
{
|
||||
var sql = new PostgresDialect().ListSchemasSql;
|
||||
sql.ShouldContain("'pg_catalog'");
|
||||
sql.ShouldContain("'information_schema'");
|
||||
|
||||
// The prefix families are matched with LIKE, where a bare _ is the single-character wildcard — so
|
||||
// they carry an explicit escape. Asserting the escaped spelling is what makes this test able to fail
|
||||
// if someone "tidies" the backslash away and silently widens the exclusion.
|
||||
sql.ShouldContain("'pg\\_toast%' ESCAPE '\\'");
|
||||
sql.ShouldContain("'pg\\_temp%' ESCAPE '\\'");
|
||||
}
|
||||
|
||||
// The loader and the browse session read every catalog column BY ALIAS (DbDataReader.GetOrdinal), and
|
||||
// Postgres folds an unquoted output-column name to lower case. The aliases are therefore quoted, and
|
||||
// this pins the exact ones the consumers ask for.
|
||||
[Fact]
|
||||
public void CatalogSql_projectsTheQuotedUpperCaseAliasesTheConsumersReadByName()
|
||||
{
|
||||
var d = new PostgresDialect();
|
||||
d.ListSchemasSql.ShouldContain("\"TABLE_SCHEMA\"");
|
||||
d.ListTablesSql.ShouldContain("\"TABLE_NAME\"");
|
||||
d.ListTablesSql.ShouldContain("\"TABLE_TYPE\"");
|
||||
d.ListColumnsSql.ShouldContain("\"COLUMN_NAME\"");
|
||||
d.ListColumnsSql.ShouldContain("\"DATA_TYPE\"");
|
||||
d.ListColumnsSql.ShouldContain("\"IS_NULLABLE\"");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SingleRowLimit_isLimit1_inTheSuffixPosition_withItsOwnLeadingSpace()
|
||||
{
|
||||
var d = new PostgresDialect();
|
||||
|
||||
// Postgres spells the limit at the END of the statement, the mirror image of T-SQL's TOP 1. The
|
||||
// planner appends the suffix straight onto the finished statement, so the space belongs to it.
|
||||
d.SingleRowLimitPrefix.ShouldBe("");
|
||||
d.SingleRowLimitSuffix.ShouldBe(" LIMIT 1");
|
||||
string.Concat("SELECT ", d.SingleRowLimitPrefix, "\"a\"", d.SingleRowLimitSuffix)
|
||||
.ShouldBe("SELECT \"a\" LIMIT 1");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Dialect_identifiesItselfAsPostgres_andExposesTheAbstractFactory()
|
||||
{
|
||||
var d = new PostgresDialect();
|
||||
d.Provider.ShouldBe(SqlProvider.Postgres);
|
||||
d.Factory.ShouldBeSameAs(Npgsql.NpgsqlFactory.Instance);
|
||||
// The seam must not leak Npgsql into its signature.
|
||||
typeof(ISqlDialect).GetProperty(nameof(ISqlDialect.Factory))!
|
||||
.PropertyType.ShouldBe(typeof(System.Data.Common.DbProviderFactory));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData("k0")]
|
||||
[InlineData("w")]
|
||||
[InlineData("schema")]
|
||||
public void ParameterMarkerAndBindName_areBothAtPrefixed(string baseName)
|
||||
{
|
||||
var d = new PostgresDialect();
|
||||
d.ParameterMarker(baseName).ShouldBe("@" + baseName);
|
||||
d.ParameterBindName(baseName).ShouldBe("@" + baseName);
|
||||
}
|
||||
|
||||
// Npgsql binds by name out of the box, so ConfigureCommand has nothing to do — and it must tolerate a
|
||||
// command that is not an NpgsqlCommand at all (the driver can be pointed at a substituted factory).
|
||||
[Fact]
|
||||
public void ConfigureCommand_leavesAForeignCommandUntouched()
|
||||
{
|
||||
using var command = new SqliteCommand("SELECT 1");
|
||||
command.Parameters.AddWithValue("@k0", 7);
|
||||
|
||||
Should.NotThrow(() => new PostgresDialect().ConfigureCommand(command));
|
||||
|
||||
command.CommandText.ShouldBe("SELECT 1");
|
||||
command.Parameters.Count.ShouldBe(1);
|
||||
command.Parameters[0].ParameterName.ShouldBe("@k0");
|
||||
command.Parameters[0].Value.ShouldBe(7);
|
||||
}
|
||||
}
|
||||
@@ -227,6 +227,50 @@ public sealed class SqlCatalogGateDriverTests
|
||||
driver.GetHealth().State.ShouldBe(DriverState.Faulted);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The catalog path against a dialect whose markers are <c>:schema</c>/<c>:table</c> and whose bind
|
||||
/// names are the bare <c>schema</c>/<c>table</c> — ODP.NET's shape. The gate still resolves a real
|
||||
/// table and still refuses an unknown column, so the loader bound names the dialect's SQL actually
|
||||
/// carries.
|
||||
/// <para>Behaviourally discriminating, not decorative: a loader still binding the literal
|
||||
/// <c>"@schema"</c> leaves <c>:schema</c> unbound, the catalog query matches nothing, and
|
||||
/// <em>every</em> tag — including the honest one — falls to <c>BadNodeIdUnknown</c>.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task The_catalog_load_binds_the_dialects_bind_names_rather_than_a_hardcoded_marker()
|
||||
{
|
||||
using var fixture = new SqlitePollFixture();
|
||||
var dialect = new ColonMarkerDialect();
|
||||
await using var driver = new SqlDriver(
|
||||
new SqlDriverOptions
|
||||
{
|
||||
RawTags =
|
||||
[
|
||||
KvEntry("Speed", SqlitePollFixture.PresentKey),
|
||||
KvEntry("Bogus", SqlitePollFixture.PresentKey, valueColumn: "no_such_column"),
|
||||
],
|
||||
OperationTimeout = TimeSpan.FromSeconds(15),
|
||||
CommandTimeout = TimeSpan.FromSeconds(10),
|
||||
},
|
||||
DriverInstanceId,
|
||||
dialect,
|
||||
fixture.ConnectionString,
|
||||
factory: fixture.Factory,
|
||||
logger: NullLogger<SqlDriver>.Instance);
|
||||
|
||||
await driver.InitializeAsync(ConfigJson, CancellationToken.None);
|
||||
|
||||
var snapshots = await driver.ReadAsync(["Speed", "Bogus"], CancellationToken.None);
|
||||
SqlStatusCodes.IsGood(snapshots[0].StatusCode).ShouldBeTrue();
|
||||
snapshots[1].StatusCode.ShouldBe(SqlStatusCodes.BadNodeIdUnknown);
|
||||
|
||||
// The catalog queries bound the bare names, and every catalog command went through the hook.
|
||||
dialect.BoundParameterNames.ShouldContain("schema");
|
||||
dialect.BoundParameterNames.ShouldContain("table");
|
||||
dialect.BoundParameterNames.ShouldNotContain(n => n.StartsWith(':'));
|
||||
dialect.ConfiguredCommands.ShouldBeGreaterThan(0);
|
||||
}
|
||||
|
||||
// ---- helpers ----
|
||||
|
||||
/// <summary>
|
||||
@@ -260,6 +304,12 @@ public sealed class SqlCatalogGateDriverTests
|
||||
|
||||
public string ListColumnsSql => Inner.ListColumnsSql;
|
||||
|
||||
public string ParameterMarker(string baseName) => Inner.ParameterMarker(baseName);
|
||||
|
||||
public string ParameterBindName(string baseName) => Inner.ParameterBindName(baseName);
|
||||
|
||||
public void ConfigureCommand(System.Data.Common.DbCommand command) => Inner.ConfigureCommand(command);
|
||||
|
||||
public string QuoteIdentifier(string ident) => Inner.QuoteIdentifier(ident);
|
||||
|
||||
public DriverDataType MapColumnType(string sqlDataType) => Inner.MapColumnType(sqlDataType);
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -185,6 +185,84 @@ public class SqlGroupPlannerTests
|
||||
plan.Parameters.ShouldBe(new object[] { "k0", "k1", "k2" });
|
||||
}
|
||||
|
||||
// ---- dialect-owned parameter markers ----
|
||||
|
||||
/// <summary>
|
||||
/// The falsifiability control for dialect-owned markers: against a <c>:</c>-marker dialect the emitted
|
||||
/// statement must carry <c>:k0</c>, and no <c>@</c> at all. A planner holding the T-SQL prefix in a
|
||||
/// const passes every SQL Server test in this class and fails only here.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void KeyValueMarkers_comeFromTheDialect_ratherThanAHardcodedAtSign()
|
||||
{
|
||||
var plans = SqlGroupPlanner.Plan(
|
||||
[
|
||||
KvTag("A", "TagValues", "tag_name", "Line1.Speed", "num_value", null),
|
||||
KvTag("B", "TagValues", "tag_name", "Line1.Temp", "num_value", null),
|
||||
], new ColonMarkerDialect()).ToList();
|
||||
|
||||
plans[0].SqlText.ShouldEndWith("IN (:k0, :k1)");
|
||||
plans[0].SqlText.ShouldNotContain("@");
|
||||
plans[0].ParameterNames.ShouldBe(new[] { ":k0", ":k1" });
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TheWideRowSelectorMarker_comesFromTheDialect_ratherThanAHardcodedAtSign()
|
||||
{
|
||||
var plans = SqlGroupPlanner.Plan(
|
||||
[WideTag("A", "LatestStatus", "oven_temp", selectorColumn: "station_id", selectorValue: "7")],
|
||||
new ColonMarkerDialect()).ToList();
|
||||
|
||||
plans[0].SqlText.ShouldEndWith("= :w");
|
||||
plans[0].SqlText.ShouldNotContain("@");
|
||||
plans[0].ParameterNames.ShouldBe(new[] { ":w" });
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The bind names ride the plan <em>separately</em> from the markers, because on ODP.NET they are a
|
||||
/// different string. A plan that carried only markers would leave the reader deriving the bind name —
|
||||
/// the convention it is not entitled to know.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ParameterBindNames_areTheDialects_andNeedNotEqualTheMarkers()
|
||||
{
|
||||
var plans = SqlGroupPlanner.Plan(
|
||||
[
|
||||
KvTag("A", "TagValues", "tag_name", "Line1.Speed", "num_value", null),
|
||||
KvTag("B", "TagValues", "tag_name", "Line1.Temp", "num_value", null),
|
||||
], new ColonMarkerDialect()).ToList();
|
||||
|
||||
plans[0].ParameterNames.ShouldBe(new[] { ":k0", ":k1" }); // in the SQL text
|
||||
plans[0].ParameterBindNames.ShouldBe(new[] { "k0", "k1" }); // on the DbParameter
|
||||
plans[0].ParameterBindNames.Count.ShouldBe(plans[0].Parameters.Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TheWideRowSelectorBindName_isTheDialects_andNeedNotEqualTheMarker()
|
||||
{
|
||||
var plans = SqlGroupPlanner.Plan(
|
||||
[WideTag("A", "LatestStatus", "oven_temp", selectorColumn: "station_id", selectorValue: "7")],
|
||||
new ColonMarkerDialect()).ToList();
|
||||
|
||||
plans[0].ParameterNames.ShouldBe(new[] { ":w" });
|
||||
plans[0].ParameterBindNames.ShouldBe(new[] { "w" });
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// On a SqlClient-style dialect the two lists coincide — which is exactly why the colon control above
|
||||
/// exists, and why this one cannot stand in for it.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void OnSqlServer_theBindNamesAreTheMarkers()
|
||||
{
|
||||
var plans = SqlGroupPlanner.Plan(
|
||||
[KvTag("A", "dbo.TagValues", "tag_name", "Line1.Speed", "num_value", null)],
|
||||
new SqlServerDialect()).ToList();
|
||||
|
||||
plans[0].ParameterBindNames.ShouldBe(plans[0].ParameterNames);
|
||||
plans[0].ParameterBindNames.ShouldBe(new[] { "@k0" });
|
||||
}
|
||||
|
||||
// ---- wide row ----
|
||||
|
||||
[Fact]
|
||||
|
||||
@@ -413,6 +413,47 @@ public sealed class SqlPollReaderTests
|
||||
async () => await reader.ReadAsync(["Speed"], CancellationToken.None));
|
||||
}
|
||||
|
||||
// ---- dialect-owned parameter naming ----
|
||||
|
||||
/// <summary>
|
||||
/// Runs a real poll through a dialect whose SQL markers (<c>:k0</c>) and bind names (bare <c>k0</c>)
|
||||
/// <b>differ</b> — ODP.NET's shape — against the SQLite fixture, and asserts <em>both</em> that the
|
||||
/// values arrive and that the names actually put on the parameters are the dialect's bind names.
|
||||
/// <para><b>The name assertion is the load-bearing half.</b> Microsoft.Data.Sqlite happily resolves
|
||||
/// <c>:k0</c> and bare <c>k0</c> alike, so a reader that bound its markers would still return the
|
||||
/// right values here — and pass a values-only test — while failing outright on ODP.NET.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task ReadAsync_bindsTheDialectsBindNames_whichNeedNotBeTheMarkersInTheSql()
|
||||
{
|
||||
using var fixture = new SqlitePollFixture();
|
||||
var dialect = new ColonMarkerDialect();
|
||||
var reader = new SqlPollReader(
|
||||
fixture.Factory, fixture.ConnectionString, dialect,
|
||||
commandTimeout: CommandTimeout, operationTimeout: OperationTimeout,
|
||||
maxConcurrentGroups: 4, nullIsBad: false,
|
||||
resolve: Resolver(
|
||||
KvTag("Speed", SqlitePollFixture.PresentKey),
|
||||
KvTag("Pressure", SqlitePollFixture.SecondPresentKey),
|
||||
WideTag("Oven", "oven_temp", selectorValue: SqlitePollFixture.PresentStation)));
|
||||
|
||||
var snapshots = await reader.ReadAsync(
|
||||
["Speed", "Pressure", "Oven"], CancellationToken.None);
|
||||
|
||||
// The IN list bound both of its distinct values, and the wide-row selector bound its one.
|
||||
snapshots[0].Value.ShouldBe(SqlitePollFixture.PresentValue);
|
||||
snapshots[1].Value.ShouldBe(SqlitePollFixture.SecondPresentValue);
|
||||
snapshots[2].Value.ShouldBe(SqlitePollFixture.PresentStationOvenTemp);
|
||||
snapshots.All(s => SqlStatusCodes.IsGood(s.StatusCode)).ShouldBeTrue();
|
||||
|
||||
// The bind names are the dialect's bare ones, NOT the ":"-prefixed markers in the SQL text.
|
||||
dialect.BoundParameterNames.ShouldBe(new[] { "k0", "k1", "w" }, ignoreOrder: true);
|
||||
|
||||
// Two groups, two commands — and the provider hook ran on each. On Oracle this is BindByName, whose
|
||||
// absence mis-binds an IN list by position instead of failing.
|
||||
dialect.ConfiguredCommands.ShouldBe(2);
|
||||
}
|
||||
|
||||
// ---- connection lifecycle ----
|
||||
|
||||
[Theory]
|
||||
|
||||
@@ -12,6 +12,7 @@ public class SqlQueryPlanImmutabilityTests
|
||||
public void Plan_doesNotAliasTheCallersLists()
|
||||
{
|
||||
var names = new List<string> { "@k0" };
|
||||
var bindNames = new List<string> { "@k0" };
|
||||
var values = new List<object?> { "v" };
|
||||
var members = new List<SqlTagDefinition>
|
||||
{
|
||||
@@ -19,14 +20,17 @@ public class SqlQueryPlanImmutabilityTests
|
||||
};
|
||||
var selected = new List<string> { "k", "c" };
|
||||
|
||||
var plan = new SqlQueryPlan(SqlTagModel.KeyValue, "gk", "SELECT 1", names, values, members, selected);
|
||||
var plan = new SqlQueryPlan(
|
||||
SqlTagModel.KeyValue, "gk", "SELECT 1", names, bindNames, values, members, selected);
|
||||
|
||||
names.Add("@k1");
|
||||
bindNames.Add("@k1");
|
||||
values.Add("other");
|
||||
members.Add(members[0]);
|
||||
selected.Add("extra");
|
||||
|
||||
plan.ParameterNames.Count.ShouldBe(1);
|
||||
plan.ParameterBindNames.Count.ShouldBe(1);
|
||||
plan.Parameters.Count.ShouldBe(1);
|
||||
plan.Members.Count.ShouldBe(1);
|
||||
plan.SelectedColumns.Count.ShouldBe(2);
|
||||
|
||||
@@ -42,6 +42,28 @@ public sealed class SqliteDialect : ISqlDialect
|
||||
/// <inheritdoc/>
|
||||
public DbProviderFactory Factory => SqliteFactory.Instance;
|
||||
|
||||
/// <summary>
|
||||
/// <c>@</c>-prefixed, matching SQL Server — SQLite accepts <c>@</c>, <c>:</c> and <c>$</c> equally, so
|
||||
/// this dialect deliberately keeps the <em>same</em> spelling as the production one. Divergent
|
||||
/// parameter naming is the job of <c>ColonMarkerDialect</c>, which is the control for it; if this
|
||||
/// dialect diverged too, a SQL-Server-shaped assumption would have nothing left holding it in place.
|
||||
/// </summary>
|
||||
/// <param name="baseName">The bare base name.</param>
|
||||
/// <returns>The <c>@</c>-prefixed marker.</returns>
|
||||
public string ParameterMarker(string baseName) => "@" + baseName;
|
||||
|
||||
/// <summary>Identical to the marker — <c>Microsoft.Data.Sqlite</c> matches on the prefixed name.</summary>
|
||||
/// <param name="baseName">The bare base name.</param>
|
||||
/// <returns>The <c>@</c>-prefixed bind name.</returns>
|
||||
public string ParameterBindName(string baseName) => "@" + baseName;
|
||||
|
||||
/// <summary>No-op: <c>SqliteCommand</c> binds by name and needs no per-command setup.</summary>
|
||||
/// <param name="command">The command to configure; untouched here.</param>
|
||||
public void ConfigureCommand(DbCommand command)
|
||||
{
|
||||
// Intentionally empty: see the summary.
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public string LivenessSql => "SELECT 1";
|
||||
|
||||
|
||||
Reference in New Issue
Block a user