f5c30ed0ef
v2-ci / unit-tests (push) Has been cancelled
Item 2: a tag's optional `write` block picks the statement the driver builds from its own catalog-validated identifiers (no authored SQL; values always bound): - Update (default, unchanged back-compat UPDATE ... WHERE key; 0 rows = BadNoData) - Insert (key+value[+stamp]; append for a WideRow topByTimestamp tag) - Upsert: SQL Server MERGE WITH (HOLDLOCK), PostgreSQL INSERT ... ON CONFLICT, MySQL ON DUPLICATE KEY UPDATE (1-or-2 rows), Oracle MERGE from DUAL - Procedure: named stored procedure resolved against the routine catalog by the catalog gate (INFORMATION_SCHEMA.ROUTINES / ALL_PROCEDURES), value/key/timestamp params by name (MySQL positional) - stampTimestamp sets the tag's timestamp column to the write time (UTC) Odbc serves Update/Insert only (shared SqlWriteSupport table). Constraint failures map to BadEntryExists (unique) / BadOutOfRange (other integrity, data exception); everything else, permission denied included, stays BadCommunicationError. WriteIdempotent stays false. The parser refuses malformed blocks (strict keys/enums/param charset); DraftValidator emits blocking SqlWriteBlockInvalid / SqlWriteModeUnsupported from the driver's own parse; the AdminUI editor surfaces the same message. Items 1 + 4 (docs/drivers/Sql.md): ODBC stays the ANSI SQL:2008 profile (native providers for SQL Server/MySQL, DB2 unsupported) with an ops note on driver manager + vendor driver on every Odbc and AdminUI host; read-only drivers require a SELECT-only login, writable drivers a login limited to their write targets. Tests: SqlWriteModeTests (parse, every dialect's SQL, gate, status map, SQLite end-to-end), DraftValidatorSqlWriteBlockTests, AdminUI round-trip; live SqlWriteModesLiveTests on SQL Server, PostgreSQL, MySQL, Oracle (seeds gain write_targets + set_target) and an Odbc write leg. Claude-Session: https://claude.ai/code/session_01GT67AEHd2Acv1YPwGfXEoV
168 lines
8.9 KiB
C#
168 lines
8.9 KiB
C#
namespace ZB.MOM.WW.OtOpcUa.Driver.Sql;
|
|
|
|
/// <summary>
|
|
/// An immutable snapshot of the parts of a database's catalog the authored tags actually name — the
|
|
/// allow-list design §8.1 requires identifiers to come from.
|
|
/// <para><b>This type holds catalog strings only.</b> Every name in it was read back out of
|
|
/// <see cref="ISqlDialect.ListSchemasSql"/> / <see cref="ISqlDialect.ListTablesSql"/> /
|
|
/// <see cref="ISqlDialect.ListColumnsSql"/>; nothing an operator typed is ever stored here. That is what
|
|
/// lets <see cref="SqlCatalogGate"/> hand the planner catalog spellings rather than authored ones, so the
|
|
/// identifier text in an emitted query is a string the database gave us.</para>
|
|
/// <para><b>Deliberately partial.</b> Only the schemas/tables the authored tags name are loaded — a
|
|
/// driver polling three tables must not enumerate a warehouse's ten thousand. A name absent from this
|
|
/// snapshot therefore means "not found <em>when we looked</em>", which is exactly the question the gate
|
|
/// asks.</para>
|
|
/// </summary>
|
|
public sealed class SqlCatalog
|
|
{
|
|
private readonly IReadOnlyList<string> _schemas;
|
|
|
|
/// <summary>Canonical schema → canonical table names in it.</summary>
|
|
private readonly IReadOnlyDictionary<string, IReadOnlyList<string>> _tablesBySchema;
|
|
|
|
/// <summary>Canonical <c>schema.table</c> → that relation's canonical column names.</summary>
|
|
private readonly IReadOnlyDictionary<string, IReadOnlyList<string>> _columnsByTable;
|
|
|
|
/// <summary>Stored procedures per canonical schema — loaded only for schemas a Procedure-mode tag names (lmxopcua#781).</summary>
|
|
private readonly IReadOnlyDictionary<string, IReadOnlyList<string>> _routinesBySchema;
|
|
|
|
/// <summary>Constructs a catalog snapshot.</summary>
|
|
/// <param name="defaultSchema">The schema an unqualified object name resolves to for this connection.</param>
|
|
/// <param name="schemas">Every schema the connection can see.</param>
|
|
/// <param name="tablesBySchema">Canonical schema → its tables/views.</param>
|
|
/// <param name="columnsByTable">Canonical <c>schema.table</c> → its columns.</param>
|
|
/// <param name="routinesBySchema">Canonical schema → its stored procedures; null ⇒ none loaded.</param>
|
|
internal SqlCatalog(
|
|
string defaultSchema,
|
|
IReadOnlyList<string> schemas,
|
|
IReadOnlyDictionary<string, IReadOnlyList<string>> tablesBySchema,
|
|
IReadOnlyDictionary<string, IReadOnlyList<string>> columnsByTable,
|
|
IReadOnlyDictionary<string, IReadOnlyList<string>>? routinesBySchema = null)
|
|
{
|
|
_routinesBySchema = routinesBySchema ?? new Dictionary<string, IReadOnlyList<string>>(StringComparer.Ordinal);
|
|
DefaultSchema = defaultSchema;
|
|
_schemas = schemas;
|
|
_tablesBySchema = tablesBySchema;
|
|
_columnsByTable = columnsByTable;
|
|
}
|
|
|
|
/// <summary>
|
|
/// A catalog that resolves nothing — used when no authored tag needs one (a driver serving only named
|
|
/// queries), so Initialize does not issue catalog queries whose answer nothing reads.
|
|
/// </summary>
|
|
internal static SqlCatalog Empty { get; } = new(
|
|
string.Empty, [],
|
|
new Dictionary<string, IReadOnlyList<string>>(StringComparer.Ordinal),
|
|
new Dictionary<string, IReadOnlyList<string>>(StringComparer.Ordinal));
|
|
|
|
/// <summary>The schema an unqualified authored object name is resolved in.</summary>
|
|
public string DefaultSchema { get; }
|
|
|
|
/// <summary>Resolves an authored schema name to the catalog's own spelling.</summary>
|
|
/// <param name="authored">The authored schema, or null/blank for the default schema.</param>
|
|
/// <param name="canonical">The catalog's spelling, when resolved.</param>
|
|
/// <returns><see langword="true"/> when the schema exists (or the default schema is used).</returns>
|
|
public bool TryResolveSchema(string? authored, out string canonical)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(authored))
|
|
{
|
|
canonical = DefaultSchema;
|
|
return true;
|
|
}
|
|
|
|
return TryMatch(_schemas, authored, out canonical);
|
|
}
|
|
|
|
/// <summary>Resolves an authored table/view name within a canonical schema.</summary>
|
|
/// <param name="canonicalSchema">The schema, already resolved through <see cref="TryResolveSchema"/>.</param>
|
|
/// <param name="authored">The authored table or view name.</param>
|
|
/// <param name="canonical">The catalog's spelling, when resolved.</param>
|
|
/// <returns><see langword="true"/> when the relation exists in that schema.</returns>
|
|
public bool TryResolveTable(string canonicalSchema, string authored, out string canonical)
|
|
{
|
|
canonical = string.Empty;
|
|
return _tablesBySchema.TryGetValue(canonicalSchema, out var tables)
|
|
&& TryMatch(tables, authored, out canonical);
|
|
}
|
|
|
|
/// <summary>Resolves an authored column name within a canonical relation.</summary>
|
|
/// <param name="canonicalSchema">The resolved schema.</param>
|
|
/// <param name="canonicalTable">The resolved table or view.</param>
|
|
/// <param name="authored">The authored column name.</param>
|
|
/// <param name="canonical">The catalog's spelling, when resolved.</param>
|
|
/// <returns><see langword="true"/> when the column exists on that relation.</returns>
|
|
public bool TryResolveColumn(
|
|
string canonicalSchema, string canonicalTable, string authored, out string canonical)
|
|
{
|
|
canonical = string.Empty;
|
|
return _columnsByTable.TryGetValue(QualifiedKey(canonicalSchema, canonicalTable), out var columns)
|
|
&& TryMatch(columns, authored, out canonical);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resolves an authored procedure name in a canonical schema to the catalog's spelling, by the same
|
|
/// exact-then-unique-case-insensitive rule as tables and columns.
|
|
/// </summary>
|
|
/// <param name="canonicalSchema">The schema, as <see cref="TryResolveSchema"/> returned it.</param>
|
|
/// <param name="authored">The authored procedure name.</param>
|
|
/// <param name="canonical">The catalog spelling, when this returns true.</param>
|
|
/// <returns>True when exactly one procedure matches.</returns>
|
|
public bool TryResolveRoutine(string canonicalSchema, string authored, out string canonical)
|
|
{
|
|
canonical = string.Empty;
|
|
return _routinesBySchema.TryGetValue(canonicalSchema, out var routines)
|
|
&& TryMatch(routines, authored, out canonical);
|
|
}
|
|
|
|
/// <summary>The dictionary key for a canonical relation.</summary>
|
|
/// <param name="schema">The canonical schema.</param>
|
|
/// <param name="table">The canonical table.</param>
|
|
/// <returns>The composite key.</returns>
|
|
internal static string QualifiedKey(string schema, string table) => schema + "." + table;
|
|
|
|
/// <summary>
|
|
/// Matches an authored name against catalog spellings: an exact (ordinal) hit wins, otherwise a
|
|
/// <b>unique</b> case-insensitive hit is accepted and its catalog spelling returned.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para><b>Why case-insensitive at all.</b> SQL Server's default collation is case-insensitive, so
|
|
/// <c>num_value</c> and <c>NUM_VALUE</c> genuinely name the same column and both work today. Matching
|
|
/// ordinally would reject configurations that have always been valid — a gate that breaks working
|
|
/// deployments is not defence in depth.</para>
|
|
/// <para><b>Why exact-first, and why ambiguity fails.</b> On a case-<em>sensitive</em> collation a
|
|
/// relation may legitimately carry both <c>Value</c> and <c>value</c>. Preferring the exact match keeps
|
|
/// such a config resolving to what the operator wrote, and refusing to choose between two
|
|
/// case-insensitive candidates is the only safe answer — silently picking one would publish a different
|
|
/// column's data under the operator's node, which is worse than rejecting the tag.</para>
|
|
/// </remarks>
|
|
/// <param name="candidates">The catalog spellings to match against.</param>
|
|
/// <param name="authored">The authored name.</param>
|
|
/// <param name="canonical">The catalog's spelling, when matched.</param>
|
|
/// <returns><see langword="true"/> on an unambiguous match.</returns>
|
|
internal static bool TryMatch(IReadOnlyList<string> candidates, string authored, out string canonical)
|
|
{
|
|
foreach (var candidate in candidates)
|
|
{
|
|
if (!string.Equals(candidate, authored, StringComparison.Ordinal)) continue;
|
|
canonical = candidate;
|
|
return true;
|
|
}
|
|
|
|
canonical = string.Empty;
|
|
var matches = 0;
|
|
foreach (var candidate in candidates)
|
|
{
|
|
if (!string.Equals(candidate, authored, StringComparison.OrdinalIgnoreCase)) continue;
|
|
if (++matches > 1)
|
|
{
|
|
canonical = string.Empty;
|
|
return false;
|
|
}
|
|
|
|
canonical = candidate;
|
|
}
|
|
|
|
return matches == 1;
|
|
}
|
|
}
|