using System.Data; using Microsoft.Data.SqlClient; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging.Abstractions; using ZB.MOM.WW.OtOpcUa.Core.AlarmHistorian; using ZB.MOM.WW.OtOpcUa.Core.Abstractions; using ZB.MOM.WW.OtOpcUa.Driver.Historian.Sql.Common; namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.SqlServer; /// /// over the SQL Event table. Insert-if-absent keyed by a deterministic /// , so the store-and-forward drain's at-least-once redelivery (and both /// pair nodes writing the same event) converge on one row. A batch is written in multi-row statements of /// events ( — one round trip per chunk, a poison event isolated by /// re-sending its chunk event by event). Outcomes: Ack on insert or already-present; /// RetryPlease on transient SQL / schema-bootstrap / unclassified SQL errors and on cancellation; PermanentFail only /// for data errors (truncation, conversion, null, range, constraint); unknown/non-SQL exceptions retry. Never throws. /// internal sealed class SqlServerAlarmHistorianWriter : IAlarmHistorianWriter { // 2628/8152 string truncation, 515 null into NOT NULL, 547 constraint (non-dup-key), 245/8114 conversion, 220/8115 overflow, 242/241 datetime range. private static readonly int[] DataErrorNumbers = [2628, 8152, 515, 547, 245, 8114, 220, 8115, 242, 241]; private readonly SqlHistorianConnection _conn; private readonly SqlServerSchemaBootstrapper _bootstrap; private readonly ILogger _log; /// Creates the writer. /// Connection helper. /// Schema bootstrapper. /// Optional logger. public SqlServerAlarmHistorianWriter(SqlHistorianConnection conn, SqlServerSchemaBootstrapper bootstrap, ILogger? log = null) { _conn = conn; _bootstrap = bootstrap; _log = log ?? NullLogger.Instance; } /// public async Task> WriteBatchAsync(IReadOnlyList batch, CancellationToken cancellationToken) { ArgumentNullException.ThrowIfNull(batch); if (batch.Count == 0) return []; var outcomes = new HistorianWriteOutcome[batch.Count]; try { await _bootstrap.EnsureAsync(cancellationToken).ConfigureAwait(false); } catch (Exception ex) { _log.LogWarning("SQL alarm historian bootstrap failed ({Exception}); will retry.", ex.GetType().Name); Array.Fill(outcomes, HistorianWriteOutcome.RetryPlease); return outcomes; } // One statement per chunk (AlarmBatchWrite): a multi-row insert-if-absent over a VALUES set, so a drain batch costs // ceil(n / ChunkRows) round trips instead of n. A chunk's data error (or a duplicate-key race with the peer node) is // re-sent event by event, where a duplicate key means "already there" (Ack) and a data error dead-letters only // its own event. Duplicate event ids WITHIN the batch are written once and share that write's outcome (two rows // with one id in one statement would violate the key). var representative = new Dictionary(StringComparer.Ordinal); var ids = new string[batch.Count]; var slots = new HistorianWriteOutcome?[batch.Count]; for (var i = 0; i < batch.Count; i++) { ids[i] = AlarmEventIds.ComputeEventId(batch[i]); if (!representative.TryAdd(ids[i], i)) slots[i] = HistorianWriteOutcome.Ack; // not sent; takes its twin's outcome below } var written = await AlarmBatchWrite.RunAsync(slots, ChunkRows, (indexes, ct) => WriteChunkAsync(batch, ids, indexes, ct), ClassifyChunk, (ex, outcome) => _log.LogWarning("SQL alarm event write failed ({Exception}); outcome {Outcome}.", ex.GetType().Name, outcome), cancellationToken).ConfigureAwait(false); for (var i = 0; i < batch.Count; i++) outcomes[i] = written[representative[ids[i]]]; return outcomes; } /// Events per statement: 11 parameters each, under SQL Server's 2,100-parameter limit. internal const int ChunkRows = 150; private long _statements; /// Statements sent so far (lifetime) — test/diagnostic. internal long Statements => Interlocked.Read(ref _statements); // A duplicate key on a MULTI-row statement is a race with another writer for one of its events: isolate (re-send // per event, where it is an Ack). A single row never reaches here with one (WriteChunkAsync treats it as present). private static HistorianWriteOutcome ClassifyChunk(Exception ex) => SqlHistorianConnection.IsDuplicateKey(ex) ? HistorianWriteOutcome.PermanentFail : Classify(ex); private async Task WriteChunkAsync(IReadOnlyList batch, string[] ids, IReadOnlyList indexes, CancellationToken ct) { // String parameters are NVARCHAR(MAX) on purpose: a sized parameter silently truncates client-side, which would // hide an over-long value; the server-side 8152 is what classifies it PermanentFail. var values = new System.Text.StringBuilder(); for (var k = 0; k < indexes.Count; k++) { if (k > 0) values.Append(','); values.Append("(@id").Append(k).Append(",@src").Append(k).Append(",@aid").Append(k).Append(",@an").Append(k) .Append(",@at").Append(k).Append(",@sev").Append(k).Append(",@ek").Append(k).Append(",@msg").Append(k) .Append(",@usr").Append(k).Append(",@cmt").Append(k).Append(",@t").Append(k).Append(')'); } var sql = "INSERT INTO " + _conn.Q("Event") + " (EventId, SourceName, AlarmId, AlarmName, AlarmTypeName, Severity, EventKind, Message, UserName, Comment, EventTimeUtc, ReceivedTimeUtc) " + "SELECT v.EventId, v.SourceName, v.AlarmId, v.AlarmName, v.AlarmTypeName, v.Severity, v.EventKind, v.Message, v.UserName, v.Comment, v.EventTimeUtc, SYSUTCDATETIME() " + "FROM (VALUES " + values + ") v (EventId, SourceName, AlarmId, AlarmName, AlarmTypeName, Severity, EventKind, Message, UserName, Comment, EventTimeUtc) " + "WHERE NOT EXISTS (SELECT 1 FROM " + _conn.Q("Event") + " x WITH (UPDLOCK, HOLDLOCK) WHERE x.EventId = v.EventId)"; try { await using var conn = await _conn.OpenAsync(ct).ConfigureAwait(false); await using var cmd = _conn.CreateCommand(conn, sql); for (var k = 0; k < indexes.Count; k++) { var e = batch[indexes[k]]; cmd.Parameters.Add(new SqlParameter("@id" + k, SqlDbType.NVarChar, 64) { Value = ids[indexes[k]] }); cmd.Parameters.Add(new SqlParameter("@src" + k, SqlDbType.NVarChar, -1) { Value = e.EquipmentPath ?? "" }); cmd.Parameters.Add(new SqlParameter("@aid" + k, SqlDbType.NVarChar, -1) { Value = e.AlarmId ?? "" }); cmd.Parameters.Add(new SqlParameter("@an" + k, SqlDbType.NVarChar, -1) { Value = e.AlarmName ?? "" }); cmd.Parameters.Add(new SqlParameter("@at" + k, SqlDbType.NVarChar, -1) { Value = e.AlarmTypeName ?? "" }); cmd.Parameters.Add(new SqlParameter("@sev" + k, SqlDbType.Int) { Value = AlarmEventIds.ToNumericSeverity(e.Severity) }); cmd.Parameters.Add(new SqlParameter("@ek" + k, SqlDbType.NVarChar, -1) { Value = e.EventKind ?? "" }); cmd.Parameters.Add(new SqlParameter("@msg" + k, SqlDbType.NVarChar, -1) { Value = (object?)e.Message ?? DBNull.Value }); cmd.Parameters.Add(new SqlParameter("@usr" + k, SqlDbType.NVarChar, -1) { Value = (object?)e.User ?? DBNull.Value }); cmd.Parameters.Add(new SqlParameter("@cmt" + k, SqlDbType.NVarChar, -1) { Value = (object?)e.Comment ?? DBNull.Value }); SqlHistorianConnection.AddDateTime2(cmd, "@t" + k, e.TimestampUtc); } Interlocked.Increment(ref _statements); await cmd.ExecuteNonQueryAsync(ct).ConfigureAwait(false); } // Single-row statement: a duplicate-key error means the row IS there (a concurrent writer won). catch (SqlException ex) when (indexes.Count == 1 && SqlHistorianConnection.IsDuplicateKey(ex)) { } } /// Classifies a write failure. Only a data error SQL Server will reject forever dead-letters; anything unknown or non-SQL retries (never lose alarm history). /// The exception raised by the write. /// The write outcome the retry queue should act on. internal static HistorianWriteOutcome Classify(Exception ex) { if (SqlHistorianConnection.IsTransient(ex)) return HistorianWriteOutcome.RetryPlease; if (ex is SqlException sql && sql.Errors.Cast().Any(x => Array.IndexOf(DataErrorNumbers, x.Number) >= 0)) return HistorianWriteOutcome.PermanentFail; return HistorianWriteOutcome.RetryPlease; } }