11703026293

Committed 06 Nov 2024 11:55AM UTC coverage: 57.387% (+0.005%) from 57.382%

Build # 11703026293

Build Type

Pull #2006

github

Committed by

web-flow

Commit Message

Bugfix/rdmp 259 delta load off by one issue (#2024)

* fix off by one issue

* update tests

* update changelog

Pull Request Pull Request #2006: Release: 8.4.0

Run Details

11208 of 21044 branches covered (53.26%)

Branch coverage included in aggregate %.

18 of 19 new or added lines in 6 files covered. (94.74%)

23 existing lines in 2 files now uncovered.

31735 of 53787 relevant lines covered (59.0%)

8218.1 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

35.06

/Rdmp.Core/DataLoad/Modules/Attachers/RemoteAttacher.cs

﻿// Copyright (c) The University of Dundee 2024-2024
// This file is part of the Research Data Management Platform (RDMP).
// RDMP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
// RDMP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along with RDMP. If not, see <https://www.gnu.org/licenses/>.
using FAnsi;
using FAnsi.Discovery.QuerySyntax;
using Rdmp.Core.Curation.Data;
using Rdmp.Core.Curation.Data.DataLoad;
using Rdmp.Core.DataFlowPipeline;
using Rdmp.Core.DataLoad.Engine.Attachers;
using Rdmp.Core.DataLoad.Engine.Job;
using Rdmp.Core.ReusableLibraryCode.Checks;
using Rdmp.Core.ReusableLibraryCode.Progress;
using System;
using System.Data;
using System.Linq;

namespace Rdmp.Core.DataLoad.Modules.Attachers;

/// <summary>
/// Root class to facilitate the Table and Database remote attachers.
/// </summary>
public class RemoteAttacher : Attacher, IPluginAttacher
{

    public RemoteAttacher() : base(true) { }
    [DemandsInitialization("How far back to pull data from")]
    public AttacherHistoricalDurations HistoricalFetchDuration { get; set; }

    [DemandsInitialization("Which column in the remote table can be used to perform time-based data selection")]
    public string RemoteTableDateColumn { get; set; }

    private readonly string RemoteTableDateFormat = "yyyy-MM-dd HH:mm:ss.fff";

    [DemandsInitialization("Earliest date when using a custom fetch duration")]
    public DateTime CustomFetchDurationStartDate { get; set; }

    [DemandsInitialization("Latest date when using a custom fetch duration")]
    public DateTime CustomFetchDurationEndDate { get; set; }

    [DemandsInitialization("The Current Start Date for procedural fetching of historical data")]
    public DateTime DeltaReadingStartDate { get; set; }
    [DemandsInitialization("How many days the procedural fetching should look back ")]
    public int DeltaReadingLookBackDays { get; set; } = 0;
    [DemandsInitialization("How many days the procedural fetching should look forward ")]
    public int DeltaReadingLookForwardDays { get; set; } = 0;

    [DemandsInitialization("If you only want to progress the procedural load to the most recent date seen in the procedural load, not the date + X days, then tick this box")]
    public bool SetDeltaReadingToLatestSeenDatePostLoad { get; set; } = false;

    [DemandsInitialization("Internal Value")]
    public DateTime? MostRecentlySeenDate { get; set; }



    private static string GetCorrectDateAddForDatabaseType(DatabaseType dbType, string addType, string amount)
    {
        switch (dbType)
        {
            case DatabaseType.PostgreSql:
                return $"cast((NOW() + interval '{amount} {addType}S') as Date)";
            case DatabaseType.Oracle:
                if (addType == "DAY") return $"DateAdd(DATE(),,{amount})";
                if (addType == "WEEK") return $"DateAdd(DATE(),,{amount} *7)";
                if (addType == "MONTH") return $"DateAdd(DATE(),,,{amount})";
                if (addType == "YEAR") return $"DateAdd(DATE(),,,,{amount})";
                return $"DateAdd(DATE(),,{amount})";
            case DatabaseType.MicrosoftSQLServer:
                return $"DATEADD({addType}, {amount}, GETDATE())";
            case DatabaseType.MySql:
                return $"DATE_ADD(CURDATE(), INTERVAL {amount} {addType})";
            default:
                throw new InvalidOperationException("Unknown Database Type");
        }
    }

    private string ConvertDateString(DatabaseType dbType, string dateString)
    {
        switch (dbType)
        {
            case DatabaseType.PostgreSql:
                return $"'{dateString}'";
            case DatabaseType.Oracle:
                return $"TO_DATE('{dateString}')";
            case DatabaseType.MicrosoftSQLServer:
                return $"convert(Date,'{dateString}')";
            case DatabaseType.MySql:
                return $"convert('{dateString}',Date)";
            default:
                return $"convert(Date,'{dateString}')";
        }

    }

    public string SqlHistoricalDataFilter(ILoadMetadata loadMetadata, DatabaseType dbType)
    {
        const string dateConvert = "Date";

        switch (HistoricalFetchDuration)
        {
            case AttacherHistoricalDurations.Past24Hours:
                return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) > {GetCorrectDateAddForDatabaseType(dbType, "DAY", "-1")}";
            case AttacherHistoricalDurations.Past7Days:
                return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) > {GetCorrectDateAddForDatabaseType(dbType, "WEEK", "-1")}";
            case AttacherHistoricalDurations.PastMonth:
                return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) > {GetCorrectDateAddForDatabaseType(dbType, "MONTH", "-1")}";
            case AttacherHistoricalDurations.PastYear:
                return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) > {GetCorrectDateAddForDatabaseType(dbType, "YEAR", "-1")}";
            case AttacherHistoricalDurations.SinceLastUse:
                return loadMetadata.LastLoadTime is not null ? $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) > {ConvertDateString(dbType, loadMetadata.LastLoadTime.GetValueOrDefault().ToString(RemoteTableDateFormat))}" : "";
            case AttacherHistoricalDurations.Custom:
                if (CustomFetchDurationStartDate == DateTime.MinValue && CustomFetchDurationEndDate != DateTime.MinValue)
                {
                    //end only
                    return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) <= {ConvertDateString(dbType, CustomFetchDurationEndDate.ToString(RemoteTableDateFormat))}";
                }

                if (CustomFetchDurationStartDate != DateTime.MinValue && CustomFetchDurationEndDate == DateTime.MinValue)
                {
                    //start only
                    return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) >= {ConvertDateString(dbType, CustomFetchDurationStartDate.ToString(RemoteTableDateFormat))}";
                }

                if (CustomFetchDurationStartDate == DateTime.MinValue && CustomFetchDurationEndDate == DateTime.MinValue)
                {
                    //No Dates
                    return "";
                }

                return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) >= {ConvertDateString(dbType, CustomFetchDurationStartDate.ToString(RemoteTableDateFormat))} AND CAST({RemoteTableDateColumn} as {dateConvert}) <= {ConvertDateString(dbType, CustomFetchDurationEndDate.ToString(RemoteTableDateFormat))}";
            case AttacherHistoricalDurations.DeltaReading:
                if (DeltaReadingStartDate == DateTime.MinValue) return "";
                var startDate = DeltaReadingStartDate.AddDays(-DeltaReadingLookBackDays);
                var endDate = DeltaReadingStartDate.AddDays(DeltaReadingLookForwardDays);
                return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) >= {ConvertDateString(dbType, startDate.ToString(RemoteTableDateFormat))} AND CAST({RemoteTableDateColumn} as {dateConvert}) < {ConvertDateString(dbType, endDate.ToString(RemoteTableDateFormat))}";
            default:
                return "";
        }
    }



    private bool IsThisRemoteAttacher(IProcessTask task)
    {
        if (task.ProcessTaskType != ProcessTaskType.Attacher) return false;
        try
        {
            if (HistoricalFetchDuration.ToString() != task.ProcessTaskArguments.First(static arg => arg.Name == "HistoricalFetchDuration").Value) return false;
            if (RemoteTableDateColumn.ToString() != task.ProcessTaskArguments.First(static arg => arg.Name == "RemoteTableDateColumn").Value) return false;

            if (CustomFetchDurationStartDate == DateTime.MinValue && task.ProcessTaskArguments.First(static arg => arg.Name == "CustomFetchDurationStartDate").Value != null) return false;
            if (CustomFetchDurationStartDate != DateTime.MinValue && task.ProcessTaskArguments.First(static arg => arg.Name == "CustomFetchDurationStartDate").Value == null) return false;
            if (CustomFetchDurationStartDate != DateTime.MinValue && DateTime.Parse(task.ProcessTaskArguments.First(static arg => arg.Name == "CustomFetchDurationStartDate").Value) != CustomFetchDurationStartDate) return false;

            if (CustomFetchDurationEndDate == DateTime.MinValue && task.ProcessTaskArguments.First(static arg => arg.Name == "CustomFetchDurationStartDate").Value != null) return false;
            if (CustomFetchDurationEndDate != DateTime.MinValue && task.ProcessTaskArguments.First(static arg => arg.Name == "CustomFetchDurationEndDate").Value == null) return false;
            if (CustomFetchDurationEndDate != DateTime.MinValue && DateTime.Parse(task.ProcessTaskArguments.First(static arg => arg.Name == "CustomFetchDurationEndDate").Value) != CustomFetchDurationEndDate) return false;

            if (DeltaReadingStartDate == DateTime.MinValue && task.ProcessTaskArguments.First(static arg => arg.Name == "DeltaReadingStartDate").Value != null) return false;
            if (DeltaReadingStartDate != DateTime.MinValue && task.ProcessTaskArguments.First(static arg => arg.Name == "DeltaReadingStartDate").Value == null) return false;
            if (DeltaReadingStartDate != DateTime.MinValue && DateTime.Parse(task.ProcessTaskArguments.First(static arg => arg.Name == "DeltaReadingStartDate").Value) != DeltaReadingStartDate) return false;

            if (DeltaReadingLookBackDays.ToString() != task.ProcessTaskArguments.First(static arg => arg.Name == "DeltaReadingLookBackDays").Value) return false;
            if (DeltaReadingLookForwardDays.ToString() != task.ProcessTaskArguments.First(static arg => arg.Name == "DeltaReadingLookForwardDays").Value) return false;
            if (SetDeltaReadingToLatestSeenDatePostLoad.ToString() != task.ProcessTaskArguments.First(static arg => arg.Name == "SetDeltaReadingToLatestSeenDatePostLoad").Value) return false;
        }
        catch (Exception)
        {
            return false;
        }

        return true;
    }

    public void FindMostRecentDateInLoadedData(IQuerySyntaxHelper syntaxFrom, DatabaseType dbType, string table, IDataLoadJob job)
    {
        var maxDateSql = $"SELECT MAX({RemoteTableDateColumn}) FROM {syntaxFrom.EnsureWrapped(table)} {SqlHistoricalDataFilter(job.LoadMetadata, dbType)}";

        using var con = _dbInfo.Server.GetConnection();
        using var dt = new DataTable();
        using var cmd = _dbInfo.Server.GetCommand(maxDateSql, con);
        cmd.CommandTimeout = 30000;
        using var da = _dbInfo.Server.GetDataAdapter(cmd);
        da.Fill(dt);
        MostRecentlySeenDate = dt.Rows.Count > 0 && dt.Rows[0].ItemArray[0].ToString() != "" ? DateTime.Parse(dt.Rows[0].ItemArray[0].ToString()) : null;
        foreach (var task in job.LoadMetadata.ProcessTasks.Where(IsThisRemoteAttacher).OfType<ProcessTask>())
        {
            task.SetArgumentValue("MostRecentlySeenDate", MostRecentlySeenDate);
            task.SaveToDatabase();
        }
    }

    public override ExitCodeType Attach(IDataLoadJob job, GracefulCancellationToken cancellationToken)
    {
        throw new NotImplementedException();
    }

    public override void Check(ICheckNotifier notifier)
    {
        throw new NotImplementedException();
    }

    public override void LoadCompletedSoDispose(ExitCodeType exitCode, IDataLoadEventListener postLoadEventListener)
    {
    }
}

1	// Copyright (c) The University of Dundee 2024-2024
2	// This file is part of the Research Data Management Platform (RDMP).
3	// RDMP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
4	// RDMP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
5	// You should have received a copy of the GNU General Public License along with RDMP. If not, see <https://www.gnu.org/licenses/>.
6	using FAnsi;
7	using FAnsi.Discovery.QuerySyntax;
8	using Rdmp.Core.Curation.Data;
9	using Rdmp.Core.Curation.Data.DataLoad;
10	using Rdmp.Core.DataFlowPipeline;
11	using Rdmp.Core.DataLoad.Engine.Attachers;
12	using Rdmp.Core.DataLoad.Engine.Job;
13	using Rdmp.Core.ReusableLibraryCode.Checks;
14	using Rdmp.Core.ReusableLibraryCode.Progress;
15	using System;
16	using System.Data;
17	using System.Linq;
18
19	namespace Rdmp.Core.DataLoad.Modules.Attachers;
20
21	/// <summary>
22	/// Root class to facilitate the Table and Database remote attachers.
23	/// </summary>
24	public class RemoteAttacher : Attacher, IPluginAttacher
25	{
26
27	public RemoteAttacher() : base(true) { }	352✔
28	[DemandsInitialization("How far back to pull data from")]
29	public AttacherHistoricalDurations HistoricalFetchDuration { get; set; }	368✔
30
31	[DemandsInitialization("Which column in the remote table can be used to perform time-based data selection")]
32	public string RemoteTableDateColumn { get; set; }	368✔
33
34	private readonly string RemoteTableDateFormat = "yyyy-MM-dd HH:mm:ss.fff";	176✔
35
36	[DemandsInitialization("Earliest date when using a custom fetch duration")]
37	public DateTime CustomFetchDurationStartDate { get; set; }	130✔
38
39	[DemandsInitialization("Latest date when using a custom fetch duration")]
40	public DateTime CustomFetchDurationEndDate { get; set; }	82✔
41
42	[DemandsInitialization("The Current Start Date for procedural fetching of historical data")]
43	public DateTime DeltaReadingStartDate { get; set; }	118✔
44	[DemandsInitialization("How many days the procedural fetching should look back ")]
45	public int DeltaReadingLookBackDays { get; set; } = 0;	54✔
46	[DemandsInitialization("How many days the procedural fetching should look forward ")]
47	public int DeltaReadingLookForwardDays { get; set; } = 0;	54✔
48
49	[DemandsInitialization("If you only want to progress the procedural load to the most recent date seen in the procedural load, not the date + X days, then tick this box")]
50	public bool SetDeltaReadingToLatestSeenDatePostLoad { get; set; } = false;	118✔
51
52	[DemandsInitialization("Internal Value")]
UNCOV 53	public DateTime? MostRecentlySeenDate { get; set; }	×
54
55
56
57	private static string GetCorrectDateAddForDatabaseType(DatabaseType dbType, string addType, string amount)
58	{
59	switch (dbType)
60	{
61	case DatabaseType.PostgreSql:
UNCOV 62	return $"cast((NOW() + interval '{amount} {addType}S') as Date)";	×
63	case DatabaseType.Oracle:
UNCOV 64	if (addType == "DAY") return $"DateAdd(DATE(),,{amount})";	×
65	if (addType == "WEEK") return $"DateAdd(DATE(),,{amount} *7)";	×
UNCOV 66	if (addType == "MONTH") return $"DateAdd(DATE(),,,{amount})";	×
67	if (addType == "YEAR") return $"DateAdd(DATE(),,,,{amount})";	×
68	return $"DateAdd(DATE(),,{amount})";	×
69	case DatabaseType.MicrosoftSQLServer:
70	return $"DATEADD({addType}, {amount}, GETDATE())";	46✔
71	case DatabaseType.MySql:
72	return $"DATE_ADD(CURDATE(), INTERVAL {amount} {addType})";	40✔
73	default:
UNCOV 74	throw new InvalidOperationException("Unknown Database Type");	×
75	}
76	}
77
78	private string ConvertDateString(DatabaseType dbType, string dateString)
79	{
80	switch (dbType)
81	{
82	case DatabaseType.PostgreSql:
UNCOV 83	return $"'{dateString}'";	×
84	case DatabaseType.Oracle:
UNCOV 85	return $"TO_DATE('{dateString}')";	×
86	case DatabaseType.MicrosoftSQLServer:
87	return $"convert(Date,'{dateString}')";	64✔
88	case DatabaseType.MySql:
89	return $"convert('{dateString}',Date)";	42✔
90	default:
UNCOV 91	return $"convert(Date,'{dateString}')";	×
92	}
93
94	}
95
96	public string SqlHistoricalDataFilter(ILoadMetadata loadMetadata, DatabaseType dbType)
97	{
98	const string dateConvert = "Date";
99
100	switch (HistoricalFetchDuration)	176✔
101	{
102	case AttacherHistoricalDurations.Past24Hours:
103	return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) > {GetCorrectDateAddForDatabaseType(dbType, "DAY", "-1")}";	22✔
104	case AttacherHistoricalDurations.Past7Days:
105	return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) > {GetCorrectDateAddForDatabaseType(dbType, "WEEK", "-1")}";	22✔
106	case AttacherHistoricalDurations.PastMonth:
107	return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) > {GetCorrectDateAddForDatabaseType(dbType, "MONTH", "-1")}";	22✔
108	case AttacherHistoricalDurations.PastYear:
109	return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) > {GetCorrectDateAddForDatabaseType(dbType, "YEAR", "-1")}";	20✔
110	case AttacherHistoricalDurations.SinceLastUse:
111	return loadMetadata.LastLoadTime is not null ? $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) > {ConvertDateString(dbType, loadMetadata.LastLoadTime.GetValueOrDefault().ToString(RemoteTableDateFormat))}" : "";	8✔
112	case AttacherHistoricalDurations.Custom:
113	if (CustomFetchDurationStartDate == DateTime.MinValue && CustomFetchDurationEndDate != DateTime.MinValue)	28✔
114	{
115	//end only
116	return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) <= {ConvertDateString(dbType, CustomFetchDurationEndDate.ToString(RemoteTableDateFormat))}";	2✔
117	}
118
119	if (CustomFetchDurationStartDate != DateTime.MinValue && CustomFetchDurationEndDate == DateTime.MinValue)	26✔
120	{
121	//start only
122	return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) >= {ConvertDateString(dbType, CustomFetchDurationStartDate.ToString(RemoteTableDateFormat))}";	2✔
123	}
124
125	if (CustomFetchDurationStartDate == DateTime.MinValue && CustomFetchDurationEndDate == DateTime.MinValue)	24✔
126	{
127	//No Dates
128	return "";	2✔
129	}
130
131	return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) >= {ConvertDateString(dbType, CustomFetchDurationStartDate.ToString(RemoteTableDateFormat))} AND CAST({RemoteTableDateColumn} as {dateConvert}) <= {ConvertDateString(dbType, CustomFetchDurationEndDate.ToString(RemoteTableDateFormat))}";	22✔
132	case AttacherHistoricalDurations.DeltaReading:
133	if (DeltaReadingStartDate == DateTime.MinValue) return "";	30✔
134	var startDate = DeltaReadingStartDate.AddDays(-DeltaReadingLookBackDays);	26✔
135	var endDate = DeltaReadingStartDate.AddDays(DeltaReadingLookForwardDays);	26✔
136	return $" WHERE CAST({RemoteTableDateColumn} as {dateConvert}) >= {ConvertDateString(dbType, startDate.ToString(RemoteTableDateFormat))} AND CAST({RemoteTableDateColumn} as {dateConvert}) < {ConvertDateString(dbType, endDate.ToString(RemoteTableDateFormat))}";	26✔
137	default:
138	return "";	26✔
139	}
140	}
141
142
143
144	private bool IsThisRemoteAttacher(IProcessTask task)
145	{
UNCOV 146	if (task.ProcessTaskType != ProcessTaskType.Attacher) return false;	×
147	try
148	{
149	if (HistoricalFetchDuration.ToString() != task.ProcessTaskArguments.First(static arg => arg.Name == "HistoricalFetchDuration").Value) return false;	×
UNCOV 150	if (RemoteTableDateColumn.ToString() != task.ProcessTaskArguments.First(static arg => arg.Name == "RemoteTableDateColumn").Value) return false;	×
151
152	if (CustomFetchDurationStartDate == DateTime.MinValue && task.ProcessTaskArguments.First(static arg => arg.Name == "CustomFetchDurationStartDate").Value != null) return false;	×
153	if (CustomFetchDurationStartDate != DateTime.MinValue && task.ProcessTaskArguments.First(static arg => arg.Name == "CustomFetchDurationStartDate").Value == null) return false;	×
UNCOV 154	if (CustomFetchDurationStartDate != DateTime.MinValue && DateTime.Parse(task.ProcessTaskArguments.First(static arg => arg.Name == "CustomFetchDurationStartDate").Value) != CustomFetchDurationStartDate) return false;	×
155
156	if (CustomFetchDurationEndDate == DateTime.MinValue && task.ProcessTaskArguments.First(static arg => arg.Name == "CustomFetchDurationStartDate").Value != null) return false;	×
157	if (CustomFetchDurationEndDate != DateTime.MinValue && task.ProcessTaskArguments.First(static arg => arg.Name == "CustomFetchDurationEndDate").Value == null) return false;	×
UNCOV 158	if (CustomFetchDurationEndDate != DateTime.MinValue && DateTime.Parse(task.ProcessTaskArguments.First(static arg => arg.Name == "CustomFetchDurationEndDate").Value) != CustomFetchDurationEndDate) return false;	×
159
160	if (DeltaReadingStartDate == DateTime.MinValue && task.ProcessTaskArguments.First(static arg => arg.Name == "DeltaReadingStartDate").Value != null) return false;	×
161	if (DeltaReadingStartDate != DateTime.MinValue && task.ProcessTaskArguments.First(static arg => arg.Name == "DeltaReadingStartDate").Value == null) return false;	×
UNCOV 162	if (DeltaReadingStartDate != DateTime.MinValue && DateTime.Parse(task.ProcessTaskArguments.First(static arg => arg.Name == "DeltaReadingStartDate").Value) != DeltaReadingStartDate) return false;	×
163
164	if (DeltaReadingLookBackDays.ToString() != task.ProcessTaskArguments.First(static arg => arg.Name == "DeltaReadingLookBackDays").Value) return false;	×
165	if (DeltaReadingLookForwardDays.ToString() != task.ProcessTaskArguments.First(static arg => arg.Name == "DeltaReadingLookForwardDays").Value) return false;	×
UNCOV 166	if (SetDeltaReadingToLatestSeenDatePostLoad.ToString() != task.ProcessTaskArguments.First(static arg => arg.Name == "SetDeltaReadingToLatestSeenDatePostLoad").Value) return false;	×
167	}	×
168	catch (Exception)	×
169	{
170	return false;	×
171	}
172
173	return true;	×
UNCOV 174	}	×
175
176	public void FindMostRecentDateInLoadedData(IQuerySyntaxHelper syntaxFrom, DatabaseType dbType, string table, IDataLoadJob job)
177	{
UNCOV 178	var maxDateSql = $"SELECT MAX({RemoteTableDateColumn}) FROM {syntaxFrom.EnsureWrapped(table)} {SqlHistoricalDataFilter(job.LoadMetadata, dbType)}";	×
179
UNCOV 180	using var con = _dbInfo.Server.GetConnection();	×
181	using var dt = new DataTable();	×
182	using var cmd = _dbInfo.Server.GetCommand(maxDateSql, con);	×
183	cmd.CommandTimeout = 30000;	×
184	using var da = _dbInfo.Server.GetDataAdapter(cmd);	×
185	da.Fill(dt);	×
186	MostRecentlySeenDate = dt.Rows.Count > 0 && dt.Rows[0].ItemArray[0].ToString() != "" ? DateTime.Parse(dt.Rows[0].ItemArray[0].ToString()) : null;	×
187	foreach (var task in job.LoadMetadata.ProcessTasks.Where(IsThisRemoteAttacher).OfType<ProcessTask>())	×
188	{
189	task.SetArgumentValue("MostRecentlySeenDate", MostRecentlySeenDate);	×
190	task.SaveToDatabase();	×
191	}
192	}	×
193
194	public override ExitCodeType Attach(IDataLoadJob job, GracefulCancellationToken cancellationToken)
195	{
UNCOV 196	throw new NotImplementedException();	×
197	}
198
199	public override void Check(ICheckNotifier notifier)
200	{
UNCOV 201	throw new NotImplementedException();	×
202	}
203
204	public override void LoadCompletedSoDispose(ExitCodeType exitCode, IDataLoadEventListener postLoadEventListener)
205	{
206	}	80✔
207	}

HicServices / RDMP / 11703026293

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous