lmxopcua/tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Historian.SqlServer.IntegrationTests/SqlServerConformanceBackend.cs

using Microsoft.Data.SqlClient;
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
using ZB.MOM.WW.OtOpcUa.Driver.Historian.Conformance;
using ZB.MOM.WW.OtOpcUa.Driver.Historian.Sql.Common;

namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.SqlServer.IntegrationTests;

/// <summary>
///     The SQL Server historian as a conformance backend: a fresh unique schema per instance (inside the fixture's
///     throwaway database), seeded by plain INSERTs through <see cref="ReadTestDb"/>.
/// </summary>
internal sealed class SqlServerConformanceBackend : IConformanceBackend
{
    private readonly ReadTestDb _db;

    private SqlServerConformanceBackend(ReadTestDb db) => _db = db;

    /// <summary>Creates a backend over a fresh schema; skips the calling test when the gate is closed.</summary>
    public static async Task<IConformanceBackend> CreateAsync(SqlHistorianFixture fx) =>
        new SqlServerConformanceBackend(await ReadTestDb.CreateAsync(fx));

    /// <inheritdoc/>
    public long ResolutionTicks => 1;

    /// <inheritdoc/>
    public IHistorianDataSource CreateDataSource(TimeProvider? clock = null) => _db.Source(clock);

    /// <inheritdoc/>
    public IHistorianDataSource CreateDataSource(int maxTimeWeightedRawRows, int maxRawValuesPerRead = 0) =>
        _db.Source(null, maxTimeWeightedRawRows, maxRawValuesPerRead);

    /// <inheritdoc/>
    public IHistorianValueWriter CreateValueWriter(Func<DateTime>? utcNow = null) =>
        new SqlServerHistorianValueWriter(_db.Conn, _db.Boot, new SqlServerTagCatalog(_db.Conn, _db.Boot), utcNow: utcNow);

    /// <inheritdoc/>
    public IHistorianDataUpdater CreateUpdater() =>
        new SqlServerHistorianDataUpdater(_db.Conn, _db.Boot, new SqlServerTagCatalog(_db.Conn, _db.Boot));

    /// <inheritdoc/>
    public async Task SeedAsync(string tag, params (DateTime T, HistorianValue V, uint Status)[] samples) =>
        await _db.SeedAsync(tag, samples);

    /// <inheritdoc/>
    public async Task SeedEventsAsync(params (DateTime T, string Id, string Source)[] events)
    {
        await using var c = await _db.Conn.OpenAsync(CancellationToken.None);
        foreach (var (t, id, source) in events)
        {
            await using var cmd = _db.Conn.CreateCommand(c,
                $"INSERT {_db.Conn.Q("Event")} (EventId, SourceName, AlarmId, AlarmName, AlarmTypeName, Severity, EventKind, Message, " +
                "UserName, Comment, EventTimeUtc, ReceivedTimeUtc) VALUES (@id, @src, 'a', 'n', 'T', 500, 'Activated', NULL, NULL, NULL, @t, @t)");
            cmd.Parameters.AddWithValue("@id", id);
            cmd.Parameters.AddWithValue("@src", source);
            SqlHistorianConnection.AddDateTime2(cmd, "@t", t);
            await cmd.ExecuteNonQueryAsync();
        }
    }

    /// <inheritdoc/>
    public async Task<IReadOnlyList<(DateTime T, HistorianValue V, uint Status)>> ReadBackAsync(string tag)
    {
        await using var c = await _db.Conn.OpenAsync(CancellationToken.None);
        await using var cmd = _db.Conn.CreateCommand(c,
            $"SELECT s.SourceTimeUtc, s.ValueKind, s.NumValue, s.IntValue, s.StrValue, s.StatusCode FROM {_db.Conn.Q("Sample")} s " +
            $"JOIN {_db.Conn.Q("Tag")} t ON t.TagId = s.TagId WHERE t.Name = @n ORDER BY s.SourceTimeUtc");
        cmd.Parameters.Add(new SqlParameter("@n", System.Data.SqlDbType.NVarChar, -1) { Value = tag });
        var list = new List<(DateTime, HistorianValue, uint)>();
        await using var r = await cmd.ExecuteReaderAsync();
        while (await r.ReadAsync())
        {
            var v = SampleColumnMapper.FromColumns(r.GetByte(1), r.IsDBNull(2) ? null : r.GetDouble(2),
                r.IsDBNull(3) ? null : r.GetInt64(3), r.IsDBNull(4) ? null : r.GetString(4));
            list.Add((SqlHistorianConnection.GetUtc(r, 0), v, SampleColumnMapper.FromDbStatus(r.GetInt32(5))));
        }
        return list;
    }

    /// <inheritdoc/>
    public async Task<bool> TagExistsAsync(string tag) => await ScalarTagAsync("COUNT(*)", tag) is > 0;

    /// <inheritdoc/>
    public async Task<DriverDataType?> TagDataTypeAsync(string tag) =>
        await ScalarTagAsync("MAX(CONVERT(bigint, DataType))", tag) is { } v ? (DriverDataType)(byte)v : null; // MAX over no row is NULL

    private async Task<long?> ScalarTagAsync(string expr, string tag)
    {
        await using var c = await _db.Conn.OpenAsync(CancellationToken.None);
        await using var cmd = _db.Conn.CreateCommand(c, $"SELECT {expr} FROM {_db.Conn.Q("Tag")} WHERE Name = @n");
        cmd.Parameters.Add(new SqlParameter("@n", System.Data.SqlDbType.NVarChar, -1) { Value = tag });
        var o = await cmd.ExecuteScalarAsync();
        return o is null or DBNull ? null : Convert.ToInt64(o);
    }

    /// <inheritdoc/>
    public ValueTask DisposeAsync() => ValueTask.CompletedTask; // the fixture drops the whole database
}