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); }