internal static QueryTablePacketDTO SerializeHeader(List <BaseColumnModel> columnModelList, bool isArchive)
{
BaseTablePacketDTO baseHeader = SerializeHeader(columnModelList);
QueryTablePacketDTO header = QueryTablePacketDTO.FromBaseTablePacketDTO(baseHeader, isArchive);
return(header);
}
public static ViewDTO GetViewCache(long viewCacheId, bool isSchedulerCall)
{
ViewDTO view;
using (var avrTran = new AvrDbTransaction())
{
DbManagerProxy manager = avrTran.Manager;
DbManager headerCmd = manager.SetSpCommand("spAsViewCacheGetHeader",
manager.Parameter("idfViewCache", viewCacheId),
manager.Parameter("blnSchedulerCall", isSchedulerCall));
lock (m_DbSyncLock)
{
int packetCount;
using (IDataReader reader = headerCmd.ExecuteReader())
{
if (!reader.Read())
{
return(null);
}
BaseTableDTO viewTableDTO = new BaseTableDTO
{
Header =
{
RowCount = (int)reader["intViewColumnCount"],
BinaryBody = new ChunkByteArray((byte[])reader["blbViewSchema"])
}
};
var binaryHeader = (byte[])reader["blbViewHeader"];
view = new ViewDTO(viewTableDTO, binaryHeader);
packetCount = (int)reader["intPacketCount"];
}
for (int packetNumber = 0; packetNumber < packetCount; packetNumber++)
{
DbManager packetCmd = manager.SetSpCommand("spAsViewCacheGetPacket",
manager.Parameter("idfViewCache", viewCacheId),
manager.Parameter("intViewCachePacketNumber", packetNumber));
var packetDTO = new BaseTablePacketDTO();
using (IDataReader packetReader = packetCmd.ExecuteReader())
{
if (!packetReader.Read())
{
return(null);
}
packetDTO.RowCount = (int)packetReader["intTableRowCount"];
packetDTO.BinaryBody = new ChunkByteArray((byte[])packetReader["blbViewCachePacket"]);
}
view.BodyPackets.Add(packetDTO);
}
avrTran.CommitTransaction();
}
}
return(view);
}
internal static QueryTablePacketDTO SerializeBodyPacket
(IDataReader reader, List <BaseColumnModel> columnModels, bool isArchive, int maxPacketRows = 0)
{
BaseTablePacketDTO basePacket = SerializeBodyPacket(reader, columnModels, maxPacketRows);
QueryTablePacketDTO packet = QueryTablePacketDTO.FromBaseTablePacketDTO(basePacket, isArchive);
return(packet);
}
public static BaseTablePacketDTO Zip(BaseTablePacketDTO sourcePacket)
{
var result = new BaseTablePacketDTO
{
RowCount = sourcePacket.RowCount,
BinaryBody = Zip(sourcePacket.BinaryBody),
};
return(result);
}
internal static List <BaseColumnModel> DeserializeHeader(BaseTablePacketDTO header)
{
var result = new List <BaseColumnModel>();
using (Stream stream = new MemoryStream(header.BinaryBody.Length))
{
stream.Write(header.BinaryBody, 0, header.BinaryBody.Length);
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new BinaryReader(stream))
{
for (int i = 0; i < header.RowCount; i++)
{
string name = reader.ReadString();
string caption = reader.ReadString();
Type type = Type.GetType(reader.ReadString());
result.Add(new BaseColumnModel(name, caption, type));
}
}
}
return(result);
}
internal static BaseTablePacketDTO SerializeHeader(List <BaseColumnModel> columnModelList)
{
using (Stream stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream))
{
foreach (BaseColumnModel columnModel in columnModelList)
{
writer.Write(columnModel.Name);
writer.Write(columnModel.Caption);
writer.Write(columnModel.FinalType.ToString());
}
writer.Flush();
var streamLength = (int)stream.Length;
stream.Seek(0, SeekOrigin.Begin);
var header = new BaseTablePacketDTO(columnModelList.Count, streamLength);
int readed = stream.Read(header.BinaryBody, 0, streamLength);
Debug.Assert(streamLength == readed, "not all bytes readed");
return(header);
}
}
}
public static BaseTableDTO SerializeFromTable(DataTable table, int maxPacketRows = 0)
{
var columnModels = new List <BaseColumnModel>();
foreach (DataColumn column in table.Columns)
{
var columnModel = new BaseColumnModel(column.ColumnName, column.Caption, column.DataType);
columnModels.Add(columnModel);
}
DataTableReader reader = table.CreateDataReader();
BaseTablePacketDTO packet = SerializeBodyPacket(reader, columnModels, maxPacketRows);
var result = new BaseTableDTO {
TableName = table.TableName
};
while (packet.RowCount != 0)
{
result.BodyPackets.Add(packet);
packet = SerializeBodyPacket(reader, columnModels, maxPacketRows);
}
result.Header = SerializeHeader(columnModels);
return(result);
}
public static void DeserializeBodyPacket(BaseTablePacketDTO packet, Type[] types, AvrDataTable table)
{
Utils.CheckNotNull(packet, "packet");
DeserializeBodyPacket(packet.RowCount, types, table, packet.StreamCreator);
}
internal static BaseTablePacketDTO SerializeBodyPacket
(IDataReader reader, List <BaseColumnModel> columnModels, int maxPacketRows = 0)
{
if (maxPacketRows <= 0)
{
maxPacketRows = MaxPacketRows;
}
BaseTablePacketDTO packet;
int rowsCount = 0;
var internStringsDict = new Dictionary <int, List <string> >();
for (int i = 0; i < columnModels.Count; i++)
{
internStringsDict[i] = new List <string>();
}
using (Stream stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream))
{
while (rowsCount < maxPacketRows && reader.Read())
{
rowsCount++;
for (int i = 0; i < columnModels.Count; i++)
{
bool hasValue = !reader.IsDBNull(i);
if (hasValue)
{
if (!WriteReaderValueToStream(writer, reader, i, columnModels[i].InitilalType, internStringsDict[i]))
{
// if value is boxed, i.e. has object type. It is usualy when uses sql_variant
object value = reader.GetValue(i);
bool result = false;
if (value != null)
{
result = columnModels[i].TryChangeType(value.GetType())
? UnboxAndWriteObjectToStream(writer, value, columnModels[i].FinalType)
: ParseAndWriteObjectToStream(writer, value.ToString(), columnModels[i].FinalType);
}
if (!result)
{
writer.Write(false);
}
}
}
else
{
writer.Write(false);
}
}
}
stream.Flush();
var streamLength = (int)stream.Length;
packet = new BaseTablePacketDTO(rowsCount, streamLength);
stream.Seek(0, SeekOrigin.Begin);
int readed = stream.Read(packet.BinaryBody, 0, streamLength);
Debug.Assert(streamLength == readed, "not all bytes readed");
}
}
return(packet);
}
