public static QueryTableModel SerializeFromCommand
(DbManager command, long queryId, string lang, bool isArchive, int maxPacketRows = 0)
{
if (maxPacketRows <= 0)
{
maxPacketRows = MaxPacketRows;
}
using (IDataReader reader = command.ExecuteReader())
{
if (reader == null)
{
throw new CustomSerializationException(string.Format("Could not get DataReader from command {0}",
command.Command.CommandText));
}
List <BaseColumnModel> columnModels = GetSchemaColumnModels(reader.GetSchemaTable());
var result = new QueryTableModel(queryId, lang)
{
UseArchivedData = isArchive
};
QueryTablePacketDTO packet = SerializeBodyPacket(reader, columnModels, isArchive, maxPacketRows);
while (packet.RowCount != 0)
{
result.BodyPackets.Add(packet);
packet = SerializeBodyPacket(reader, columnModels, isArchive, maxPacketRows);
}
// note : header should be serialized afer body because of possible columnModels change inside SerializeBodyPacket
result.Header = SerializeHeader(columnModels, isArchive);
return(result);
}
}
public static long SaveQueryCacheWithoutTransaction(QueryTableModel zippedTable)
{
lock (m_DbSyncLock)
{
using (DbManagerProxy manager = DbManagerFactory.Factory[DatabaseType.Avr].Create())
{
DbManager headerCommand = manager.SetSpCommand("spAsQueryCachePostHeader",
manager.Parameter("idfQuery", zippedTable.QueryId),
manager.Parameter("strLanguage", zippedTable.Language),
manager.Parameter("intQueryColumnCount", zippedTable.Header.RowCount),
manager.Parameter("blbQuerySchema", zippedTable.Header.BinaryBody.ToArray()),
manager.Parameter("blnUseArchivedData", zippedTable.UseArchivedData)
);
var queryCasheId = (long)headerCommand.ExecuteScalar();
for (int i = 0; i < zippedTable.BodyPackets.Count; i++)
{
DbManager command = manager.SetSpCommand("spAsQueryCachePostPacket",
manager.Parameter("idfQueryCache", queryCasheId),
manager.Parameter("intQueryCachePacketNumber", i),
manager.Parameter("intPacketRowCount", zippedTable.BodyPackets[i].RowCount),
manager.Parameter("blbQueryCachePacket", zippedTable.BodyPackets[i].BinaryBody.ToArray()),
manager.Parameter("blnArchivedData", zippedTable.BodyPackets[i].IsArchive)
);
command.ExecuteNonQuery();
}
return(queryCasheId);
}
}
}
private static void TestInternalSaveTable(QueryTableModel source)
{
QueryTableModel actualTable = GetTestTableModel();
AvrDbHelper.InvalidateQueryCache(actualTable.QueryId, "en");
Assert.IsFalse(AvrDbHelper.GetQueryCacheId(source.QueryId, "en", false).HasValue);
AvrDbHelper.SaveQueryCache(source);
// manager.CommitTransaction();
long?id = AvrDbHelper.GetQueryCacheId(source.QueryId, "en", false);
Assert.IsTrue(id.HasValue);
QueryTableHeaderDTO resultHeader = AvrDbHelper.GetQueryCacheHeader(id.Value, false, false);
Assert.IsNotNull(resultHeader);
Assert.IsNotNull(resultHeader.BinaryHeader);
Assert.AreEqual(id.Value, resultHeader.QueryCacheId);
Assert.AreEqual(source.BodyPackets.Count, resultHeader.PacketCount);
Assert.AreEqual(source.Header.RowCount, resultHeader.BinaryHeader.RowCount);
AssertAreArrayEqual(source.Header.BinaryBody, resultHeader.BinaryHeader.BinaryBody);
for (int i = 0; i < resultHeader.PacketCount; i++)
{
QueryTablePacketDTO resultPacket = AvrDbHelper.GetQueryCachePacket(id.Value, i);
Assert.IsNotNull(resultPacket);
Assert.IsNotNull(resultPacket.BinaryBody);
QueryTablePacketDTO sourcePacket = source.BodyPackets[i];
Assert.IsNotNull(sourcePacket);
Assert.IsNotNull(sourcePacket.BinaryBody);
Assert.AreEqual(sourcePacket.RowCount, resultPacket.RowCount);
AssertAreArrayEqual(sourcePacket.BinaryBody, resultPacket.BinaryBody);
}
}
private static QueryTableModel GetTestTableModel(bool isArchive = false)
{
var source = new QueryTableModel(123, "en")
{
UseArchivedData = isArchive,
Header = new QueryTablePacketDTO
{
RowCount = 1,
BinaryBody = new ChunkByteArray(new byte[] { 1, 2, 3 }),
IsArchive = isArchive,
},
BodyPackets = new List <QueryTablePacketDTO>
{
new QueryTablePacketDTO
{
RowCount = 2,
BinaryBody = new ChunkByteArray(new byte[] { 4, 5, 6, 7, 8, 9 })
},
new QueryTablePacketDTO
{
RowCount = 3,
BinaryBody = new ChunkByteArray(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 10 }),
IsArchive = isArchive
},
},
};
return(source);
}
public void TestRefreshedCacheOnUserCallAfterDaysTable()
{
QueryTableModel actualTable = GetTestTableModel();
AvrDbHelper.InvalidateQueryCache(actualTable.QueryId, "en");
Assert.IsFalse(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false).HasValue);
AvrDbHelper.SaveQueryCache(actualTable);
long?id = AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false);
Assert.IsTrue(id.HasValue);
id = AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false, 0, true);
Assert.IsTrue(id.HasValue);
id = AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false, 0);
Assert.IsFalse(id.HasValue);
id = AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false, 1);
Assert.IsTrue(id.HasValue);
UpdateQueryRefreshDate(id, -6);
id = AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false);
Assert.IsTrue(id.HasValue);
UpdateQueryRefreshDate(id, -8);
id = AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false);
Assert.IsFalse(id.HasValue);
}
private static QueryTableHeaderModel GetQueryTableHeaderModel()
{
QueryTableModel tableModel = AvrDbHelper.GetQueryResult(49539640000000, "en", false);
var zippedHeader = new QueryTableHeaderDTO(tableModel.Header, 1, tableModel.BodyPackets.Count);
var original = new QueryTableHeaderModel(zippedHeader);
return(original);
}
public static long SaveQueryCache(QueryTableModel zippedTable)
{
using (var avrTran = new AvrDbTransaction())
{
long id = SaveQueryCacheWithoutTransaction(zippedTable);
avrTran.CommitTransaction();
return(id);
}
}
private static void TestInternalSaveDeleteTable(QueryTableModel source)
{
AvrDbHelper.InvalidateQueryCache(source.QueryId, "en");
Assert.IsFalse(AvrDbHelper.GetQueryCacheId(source.QueryId, "en", false).HasValue);
AvrDbHelper.SaveQueryCache(source);
// manager.CommitTransaction();
long?id = AvrDbHelper.GetQueryCacheId(source.QueryId, "en", false);
Assert.IsTrue(id.HasValue);
long queryCacheId = id.Value;
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCacheHeader(queryCacheId, false, false).BinaryHeader.BinaryBody.Length);
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCachePacket(queryCacheId, 0).BinaryBody.Length);
AvrDbHelper.InvalidateQueryCache(source.QueryId, "en");
Assert.IsNull(AvrDbHelper.GetQueryCacheId(source.QueryId, "en", false));
Assert.IsNotNull(AvrDbHelper.GetQueryCacheId(source.QueryId, "en", false, 7, true));
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCacheHeader(queryCacheId, false, false).BinaryHeader.BinaryBody.Length);
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCachePacket(queryCacheId, 0).BinaryBody.Length);
AvrDbHelper.DeleteQueryCache(source.QueryId, "en", true);
Assert.IsNull(AvrDbHelper.GetQueryCacheId(source.QueryId, "en", false));
Assert.IsNotNull(AvrDbHelper.GetQueryCacheId(source.QueryId, "en", false, 7, true));
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCacheHeader(queryCacheId, false, false).BinaryHeader.BinaryBody.Length);
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCachePacket(queryCacheId, 0).BinaryBody.Length);
AvrDbHelper.SaveQueryCache(source);
AvrDbHelper.InvalidateQueryCache(source.QueryId, "en");
AvrDbHelper.DeleteQueryCache(source.QueryId, "en", true);
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCacheHeader(queryCacheId, false, false).BinaryHeader.BinaryBody.Length);
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCachePacket(queryCacheId, 0).BinaryBody.Length);
Assert.IsNull(AvrDbHelper.GetQueryCacheId(source.QueryId, "en", false));
long?id2 = AvrDbHelper.GetQueryCacheId(source.QueryId, "en", false, 7, true);
Assert.IsTrue(id2.HasValue);
long queryCacheId2 = id2.Value;
UpdateDateCacheRequest(source.QueryId);
AvrDbHelper.DeleteQueryCache(source.QueryId, "en", true);
Assert.AreEqual(0, AvrDbHelper.GetQueryCacheHeader(queryCacheId, false, false).BinaryHeader.BinaryBody.Length);
Assert.AreEqual(0, AvrDbHelper.GetQueryCachePacket(queryCacheId, 0).BinaryBody.Length);
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCacheHeader(queryCacheId2, false, false).BinaryHeader.BinaryBody.Length);
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCachePacket(queryCacheId2, 0).BinaryBody.Length);
UpdateDateCacheRequest(source.QueryId);
AvrDbHelper.DeleteQueryCache(source.QueryId, "en", false);
Assert.IsNull(AvrDbHelper.GetQueryCacheId(source.QueryId, "en", false, 7, true));
Assert.AreEqual(0, AvrDbHelper.GetQueryCacheHeader(queryCacheId2, false, false).BinaryHeader.BinaryBody.Length);
Assert.AreEqual(0, AvrDbHelper.GetQueryCachePacket(queryCacheId2, 0).BinaryBody.Length);
}
public static QueryTableModel Unzip(QueryTableModel sourceTable)
{
var result = new QueryTableModel(sourceTable.QueryId, sourceTable.Language)
{
Header = Unzip(sourceTable.Header),
BodyPackets = sourceTable.BodyPackets.Select(Unzip).ToList(),
UseArchivedData = sourceTable.UseArchivedData
};
return(result);
}
public void TableCompressTest()
{
var source = new QueryTableModel(123, "en")
{
Header = new QueryTablePacketDTO
{
RowCount = 1,
BinaryBody = new ChunkByteArray(new byte[] { 1, 2, 3 }),
IsArchive = true
},
BodyPackets = new List <QueryTablePacketDTO>
{
new QueryTablePacketDTO
{
RowCount = 2,
BinaryBody = new ChunkByteArray(new byte[] { 4, 5, 6, 7, 8, 9 }),
IsArchive = false
},
new QueryTablePacketDTO
{
RowCount = 3,
BinaryBody = new ChunkByteArray(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 10 }),
IsArchive = true
},
}
};
QueryTableModel zip = BinaryCompressor.Zip(source);
QueryTableModel result = BinaryCompressor.Unzip(zip);
Assert.AreEqual(source.Header.RowCount, result.Header.RowCount);
Assert.AreEqual(source.Language, result.Language);
Assert.AreEqual(source.QueryId, result.QueryId);
Assert.AreEqual(source.Header.BinaryBody.Length, result.Header.BinaryBody.Length);
for (int i = 0; i < source.Header.BinaryBody.Length; i++)
{
Assert.AreEqual(source.Header.BinaryBody[i], result.Header.BinaryBody[i]);
}
Assert.AreEqual(source.BodyPackets.Count, result.BodyPackets.Count);
for (int i = 0; i < source.BodyPackets.Count; i++)
{
var sourcePacket = source.BodyPackets[i];
var resultPacket = result.BodyPackets[i];
Assert.AreEqual(sourcePacket.BinaryBody.Length, resultPacket.BinaryBody.Length);
for (int j = 0; j < sourcePacket.BinaryBody.Length; j++)
{
Assert.AreEqual(sourcePacket.BinaryBody[j], resultPacket.BinaryBody[j]);
}
}
}
public void TestViewCache()
{
QueryTableModel actualTable = GetTestTableModel();
AvrDbHelper.InvalidateQueryCache(actualTable.QueryId, "en");
Assert.IsFalse(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false).HasValue);
AvrDbHelper.SaveQueryCache(actualTable);
long?queryCacheId = AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false);
Assert.IsTrue(queryCacheId.HasValue);
ViewDTO sourceView = GetCachedView();
var viewCacheId = AvrDbHelper.SaveViewCache(queryCacheId.Value, 1, sourceView);
long?loadedViewCasheId = AvrDbHelper.GetViewCacheId(queryCacheId.Value, 11);
Assert.IsFalse(loadedViewCasheId.HasValue);
loadedViewCasheId = AvrDbHelper.GetViewCacheId(queryCacheId.Value, 1);
Assert.IsTrue(loadedViewCasheId.HasValue);
Assert.AreEqual(viewCacheId, loadedViewCasheId);
var loadedView = AvrDbHelper.GetViewCache(viewCacheId, false);
Assert.IsNotNull(loadedView);
AvrDbHelper.InvalidateQueryCache(actualTable.QueryId);
Assert.IsFalse(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false).HasValue);
loadedViewCasheId = AvrDbHelper.GetViewCacheId(queryCacheId.Value, 1);
Assert.IsFalse(loadedViewCasheId.HasValue);
loadedView = AvrDbHelper.GetViewCache(viewCacheId, false);
Assert.IsNotNull(loadedView);
AssertAreArrayEqual(sourceView.BinaryViewHeader, loadedView.BinaryViewHeader);
AssertAreArrayEqual(sourceView.Header.BinaryBody, loadedView.Header.BinaryBody);
Assert.AreEqual(sourceView.BodyPackets.Count, loadedView.BodyPackets.Count);
for (int i = 0; i < loadedView.BodyPackets.Count; i++)
{
AssertAreArrayEqual(sourceView.BodyPackets[i].BinaryBody, loadedView.BodyPackets[i].BinaryBody);
}
AvrDbHelper.SaveViewCache(queryCacheId.Value, 1, sourceView);
loadedViewCasheId = AvrDbHelper.GetViewCacheId(queryCacheId.Value, 1);
Assert.IsTrue(loadedViewCasheId.HasValue);
AvrDbHelper.InvalidateViewCache(1);
loadedViewCasheId = AvrDbHelper.GetViewCacheId(queryCacheId.Value, 1);
Assert.IsFalse(loadedViewCasheId.HasValue);
}
public void TableEmptyCompressTest()
{
var source = new QueryTableModel(123, "en");
QueryTableModel zip = BinaryCompressor.Zip(source);
QueryTableModel result = BinaryCompressor.Unzip(zip);
Assert.AreEqual(0, result.Header.RowCount);
Assert.AreEqual(source.Header.RowCount, result.Header.RowCount);
Assert.AreEqual(source.Language, result.Language);
Assert.AreEqual(source.QueryId, result.QueryId);
Assert.AreEqual(source.UseArchivedData, result.UseArchivedData);
Assert.AreEqual(source.Header.BinaryBody.Length, result.Header.BinaryBody.Length);
Assert.AreEqual(0, result.Header.BinaryBody.Length);
}
public static QueryTableModel GetQueryResult(long queryId, string lang, bool isArchive)
{
string queryString;
QueryTableModel zippedTable;
var watch = new Stopwatch();
watch.Start();
m_Trace.Trace(TraceTitle, "Executing actual query '{0}' for lang '{1}'", queryId, lang);
using (DbManagerProxy manager = DbManagerFactory.Factory.Create())
{
queryString = QueryHelper.GetQueryText(manager, queryId, false);
QueryTableModel serializedTable = QueryHelper.GetInnerQueryResult(manager, queryString, lang,
c => BinarySerializer.SerializeFromCommand(c, queryId, lang, false));
zippedTable = BinaryCompressor.Zip(serializedTable);
}
if (isArchive)
{
m_Trace.Trace(TraceTitle, "Executing archive query '{0}' for lang '{1}'", queryId, lang);
using (DbManagerProxy archiveManager = DbManagerFactory.Factory[DatabaseType.Archive].Create())
{
using (DbManagerProxy manager = DbManagerFactory.Factory.Create())
{
QueryHelper.DropAndCreateArchiveQuery(manager, archiveManager, queryId);
}
QueryTableModel serializedArchiveTable = QueryHelper.GetInnerQueryResult(archiveManager, queryString, lang,
c => BinarySerializer.SerializeFromCommand(c, queryId, lang, true));
QueryTableModel zippedArchiveTable = BinaryCompressor.Zip(serializedArchiveTable);
zippedTable.UseArchivedData = true;
foreach (QueryTablePacketDTO packet in zippedArchiveTable.BodyPackets)
{
packet.IsArchive = true;
zippedTable.BodyPackets.Add(packet);
}
}
}
m_Trace.Trace(TraceTitle, "Executing query '{0}' for lang '{1}' finished, duration={2},", queryId, lang, watch.Elapsed);
return(zippedTable);
}
public void TestExecuteArchiveQuery()
{
QueryTableModel tableModel = AvrDbHelper.GetQueryResult(49539640000000, "en", true);
Assert.IsNotNull(tableModel);
IList <QueryTablePacketDTO> packets = tableModel.BodyPackets;
Assert.IsNotNull(packets);
Assert.IsNotNull(tableModel.Header);
Assert.AreEqual("en", tableModel.Language);
Assert.AreEqual(49539640000000, tableModel.QueryId);
Assert.IsTrue(packets.Count >= 1 * 2);
Assert.IsTrue(packets.Any(p => p.IsArchive));
Assert.IsTrue(packets.Any(p => !p.IsArchive));
var zippedHeader = new QueryTableHeaderDTO(tableModel.Header, 1, packets.Count);
var headerModel = new QueryTableHeaderModel(zippedHeader);
Assert.AreEqual(m_FieldCount, headerModel.ColumnCount);
}
public void TestGetQueryHeader()
{
QueryTableModel actualTable = GetTestTableModel();
AvrDbHelper.InvalidateQueryCache(actualTable.QueryId, "en");
Assert.IsFalse(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false).HasValue);
AvrDbHelper.SaveQueryCache(actualTable);
long?id = AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false);
Assert.IsTrue(id.HasValue);
AvrDbHelper.GetQueryCacheHeader(id.Value, true, false);
var requestDate = GetDateUserQueryCacheRequest(id);
Assert.AreEqual(DBNull.Value, requestDate);
AvrDbHelper.GetQueryCacheHeader(id.Value, false, false);
requestDate = GetDateUserQueryCacheRequest(id);
Assert.AreNotEqual(DBNull.Value, requestDate);
}
public void TestSaveDeleteFullArchiveTable()
{
QueryTableModel actualTable = GetTestTableModel();
AvrDbHelper.InvalidateQueryCache(actualTable.QueryId, "en");
Assert.IsFalse(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false).HasValue);
AvrDbHelper.SaveQueryCache(actualTable);
Assert.IsNotNull(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false));
Assert.IsNull(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", true));
QueryTableModel archiveTable = GetTestTableModel(true);
AvrDbHelper.SaveQueryCache(archiveTable);
long?actualId = AvrDbHelper.GetQueryCacheId(archiveTable.QueryId, "en", false);
long?archiveId = AvrDbHelper.GetQueryCacheId(archiveTable.QueryId, "en", false);
Assert.IsTrue(actualId.HasValue);
Assert.IsTrue(archiveId.HasValue);
QueryTableHeaderDTO archiveHeader = AvrDbHelper.GetQueryCacheHeader(archiveId.Value, false, true);
QueryTableHeaderDTO actualHeader = AvrDbHelper.GetQueryCacheHeader(actualId.Value, false, false);
Assert.AreEqual(archiveHeader.BinaryHeader.BinaryBody.Length, actualHeader.BinaryHeader.BinaryBody.Length);
Assert.AreEqual(1, actualHeader.PacketCount);
Assert.AreEqual(2, archiveHeader.PacketCount);
Assert.IsFalse(AvrDbHelper.GetQueryCachePacket(archiveId.Value, 0).IsArchive);
Assert.IsTrue(AvrDbHelper.GetQueryCachePacket(archiveId.Value, 1).IsArchive);
AvrDbHelper.InvalidateQueryCache(actualTable.QueryId, "en");
Assert.IsNull(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false));
Assert.IsNull(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", true));
Assert.IsNotNull(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false, 7, true));
Assert.IsNotNull(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", true, 7, true));
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCacheHeader(archiveId.Value, false, false).BinaryHeader.BinaryBody.Length);
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCacheHeader(archiveId.Value, false, true).BinaryHeader.BinaryBody.Length);
Assert.AreNotEqual(0, AvrDbHelper.GetQueryCachePacket(archiveId.Value, 0).BinaryBody.Length);
}
public void TestGetUserQueryRefershDateHeader()
{
QueryTableModel table = GetTestTableModel();
AvrDbHelper.SaveQueryCache(table);
var queryId = table.QueryId;
long?id = AvrDbHelper.GetQueryCacheId(queryId, "en", false);
Assert.IsTrue(id.HasValue);
using (var avrTran = new AvrDbTransaction())
{
DbManagerProxy manager = avrTran.Manager;
DbManager command = manager.SetCommand(
@" update QueryCache
set datUserQueryCacheRequest = NULL
where [idfQuery] = @idflQuery",
manager.Parameter("idflQuery", queryId)
);
command.ExecuteNonQuery();
avrTran.CommitTransaction();
}
var date = AvrDbHelper.GetsQueryCacheUserRequestDate(queryId);
Assert.IsFalse(date.HasValue);
AvrDbHelper.GetQueryCacheHeader(id.Value, true, false);
date = AvrDbHelper.GetsQueryCacheUserRequestDate(queryId);
Assert.IsFalse(date.HasValue);
AvrDbHelper.GetQueryCacheHeader(id.Value, false, false);
date = AvrDbHelper.GetsQueryCacheUserRequestDate(queryId);
Assert.IsTrue(date.HasValue);
}
/// <summary>
/// Converts to query to SelectModel
/// </summary>
/// <param name="query">query to be converted</param>
/// <returns>Converted to SelectModel query</returns>
public SelectModel ToSelectModel(QueryTableModel query, bool processExternals = true)
{
var tableAlias = TablesAlias[query.Id];
return(new SelectModel
{
TableName = $"{query.TableSchema}.{query.TableName}",
TableId = query.Id,
TableAlias = tableAlias,
SelectedColumns = query.SelectedColumns
.Select(column => $"{tableAlias}.{column.ColumnName} as {column.Alias}")
.ToList(),
Functions = query.Functions
.Select(function => $"{function.Function}({tableAlias}.{function.ColumnAlias}) as {function.Alias}")
.ToList(),
Joins = ParseJoins(query.Joins, query.Id),
GroupBys = query.GroupByColumns
.Select(columnName => $"{tableAlias}.{columnName}")
.ToList(),
OrderBys = query.Sortings
.Select(sorting => $"{sorting.OrderByAlias} {sorting.Direction}")
.ToList()
});
}
private QueryTableHeaderDTO GetInternalCachedQueryTableHeader(long queryId, bool isSchedulerCall, string lang, bool isArchive)
{
try
{
string queryName = AvrDbHelper.GetQueryNameForLog(queryId);
Stopwatch watch = TraceMethodCall(queryId, queryName, lang, isArchive);
EidssAvrServiceInitializer.CheckAndInitEidssCore();
var cacheKey = new QueryCacheKey(queryId, lang, isArchive);
long?id = AvrDbHelper.GetQueryCacheId(cacheKey, RefreshedCacheOnUserCallAfterDays);
if (!id.HasValue)
{
bool needExecute;
lock (m_CacheSyncLock)
{
needExecute = !m_QueryCacheList.Contains(cacheKey);
if (needExecute)
{
m_QueryCacheList.Add(cacheKey);
if (!m_QueryCacheSyncLock.ContainsKey(cacheKey))
{
m_QueryCacheSyncLock.Add(cacheKey, new object());
}
if (!m_QueryCacheErrors.ContainsKey(cacheKey))
{
m_QueryCacheErrors.Add(cacheKey, false);
}
}
}
lock (m_QueryCacheSyncLock[cacheKey])
{
try
{
if (needExecute)
{
try
{
id = AvrDbHelper.GetQueryCacheId(cacheKey, RefreshedCacheOnUserCallAfterDays);
if (!id.HasValue)
{
QueryTableModel tableModel = AvrDbHelper.GetQueryResult(queryId, lang, isArchive);
id = AvrDbHelper.SaveQueryCache(tableModel);
}
}
finally
{
lock (m_CacheSyncLock)
{
m_QueryCacheErrors[cacheKey] = !id.HasValue;
m_QueryCacheList.Remove(cacheKey);
}
}
}
else
{
while (true)
{
lock (m_CacheSyncLock)
{
if (!m_QueryCacheList.Contains(cacheKey))
{
break;
}
}
Monitor.Wait(m_QueryCacheSyncLock[cacheKey]);
}
lock (m_CacheSyncLock)
{
if (m_QueryCacheErrors[cacheKey])
{
string message = EidssMessages.Get("msgCouldNotGetQueryCacheHeaderGeneral",
"Could not get header of query cashe table. For detail see previous exception logged");
throw new AvrDataException(message);
}
}
id = AvrDbHelper.GetQueryCacheId(cacheKey, RefreshedCacheOnUserCallAfterDays, true);
}
}
finally
{
Monitor.PulseAll(m_QueryCacheSyncLock[cacheKey]);
}
}
}
if (!id.HasValue)
{
string msg = EidssMessages.Get("msgCouldNotGetQueryCacheId", "Could not get query cashe ID. See log for more details.");
throw new AvrDataException(msg);
}
QueryTableHeaderDTO header = AvrDbHelper.GetQueryCacheHeader(id.Value, isSchedulerCall, isArchive);
TraceMethodCallFinished(watch, queryId, queryName, lang, isArchive);
return(header);
}
catch (Exception ex)
{
m_Trace.TraceMethodException(ex, Utils.GetCurrentMethodName(), m_TraceTitle, queryId, lang);
string format = EidssMessages.Get("msgCouldNotGetQueryCacheHeader",
"Could not get header of query cashe table. Query ID={0}, Language={1}");
throw new AvrDataException(String.Format(format, queryId, lang), ex);
}
}
public void TestSaveDeleteFullTable()
{
QueryTableModel source = GetTestTableModel();
TestInternalSaveDeleteTable(source);
}
