public void Serialize(BinaryWriter output, FastAccessList <object> referenceTracking = null)
{
output.Write(Count);
foreach (var server in this)
{
output.Write(server.Key);
output.Write(server.Value.Count);
foreach (var database in server.Value)
{
output.Write(database.Key);
output.Write(database.Value.Count);
foreach (var schema in database.Value)
{
var nbRows = schema.Value.Count;
output.Write(schema.Key);
output.Write(nbRows);
foreach (var table in schema.Value)
{
if (referenceTracking == null)
{
table.Serialize(output);
}
else
{
var id = referenceTracking.TryAdd(table);
output.Write(id);
}
}
}
}
}
}
public static ExecutionPlan Deserialize(BinaryReader input, FastAccessList <object> referenceTracking)
{
var ep = new ExecutionPlan();
var nbVars = input.ReadInt32();
for (var i = 0; i < nbVars; i++)
{
var id = input.ReadInt32();
ep.Variables.Add((SqlVariable)referenceTracking[id]);
}
var nbInsertSteps = input.ReadInt32();
for (var i = 0; i < nbInsertSteps; i++)
{
var step = InsertStep.Deserialize(input, referenceTracking);
ep.InsertSteps.Add(step);
}
var nbUpdateSteps = input.ReadInt32();
for (var i = 0; i < nbUpdateSteps; i++)
{
var step = UpdateStep.Deserialize(input);
ep.UpdateSteps.Add(step);
}
return(ep);
}
public void Save(Stream ostream)
{
var referenceTracking = new FastAccessList <object>();
var refStream = new MemoryStream();
_executionPlanByServer.Serialize(refStream, referenceTracking);
_metadata.Serialize(refStream, referenceTracking);
////Compression
//using (var lzStream = new LZ4Stream(ostream, LZ4StreamMode.Compress))
//using (var bstream = new BinaryWriter(lzStream, Encoding.UTF8, true))
//{
// bstream.Write(FormatVersion);
// bstream.Write(Description ?? "");
// SerializeReferenceTracking(bstream, referenceTracking);
// SerializeConnections(bstream, _connections);
// refStream.WriteTo(lzStream);
//}
//Compression
using (var bstream = new BinaryWriter(ostream, Encoding.UTF8, true))
{
bstream.Write(FormatVersion);
bstream.Write(Description ?? "");
SerializeReferenceTracking(bstream, referenceTracking);
SerializeConnections(bstream, _connections);
refStream.WriteTo(ostream);
}
}
private static FastAccessList <object> DeserializeReferenceTracking(BinaryReader input)
{
var bf = SerializationHelper.DefaultFormatter;
var referenceTracking = new FastAccessList <object>();
var nbRef = input.ReadInt32();
for (var i = 0; i < nbRef; i++)
{
var tag = input.ReadInt32();
var type = SerializationHelper.TagToType[tag];
if (type == typeof(SqlVariable))
{
referenceTracking.Add(SqlVariable.Deserialize(input));
}
else if (type == typeof(TableMetadata))
{
referenceTracking.Add(TableMetadata.Deserialize(input));
}
else
{
referenceTracking.Add(bf.Deserialize(input.BaseStream));
}
}
return(referenceTracking);
}
public void Serialize(BinaryWriter output, FastAccessList <object> referenceTracking = null)
{
output.Write(ConfigFileHash);
if (ServerMap != null)
{
output.Write(ServerMap.Count);
foreach (var sm in ServerMap)
{
sm.Key.Serialize(output);
sm.Value.Serialize(output);
}
}
else
{
output.Write(0);
}
output.Write(ConnectionStrings.Count);
foreach (var cs in ConnectionStrings)
{
cs.Serialize(output);
}
Metadatas.Serialize(output, referenceTracking);
output.Flush();
}
private static void SerializeReferenceTracking(BinaryWriter output, FastAccessList <object> referenceTracking)
{
var bf = SerializationHelper.DefaultFormatter;
output.Write(referenceTracking.Length);
for (int i = 0; i < referenceTracking.Length; i++)
{
var data = referenceTracking[i];
var type = data.GetType();
var tag = SerializationHelper.TypeToTag[type];
output.Write(tag);
if (type == typeof(SqlVariable))
{
((SqlVariable)data).Serialize(output);
}
else if (type == typeof(TableMetadata))
{
((TableMetadata)data).Serialize(output);
}
else
{
bf.Serialize(output.BaseStream, data);
}
}
}
public void Serialize(BinaryWriter output, FastAccessList <object> referenceTracking)
{
output.Write(Count);
foreach (var srv in this)
{
output.Write(srv.Key);
srv.Value.Serialize(output, referenceTracking);
}
}
public static MetadataContainer Deserialize(BinaryReader input, FastAccessList <object> referenceTracking = null)
{
var config = new MetadataContainer {
ConfigFileHash = input.ReadString()
};
DeserializeBody(input, config, referenceTracking);
return(config);
}
public static ExecutionContext Deserialize(BinaryReader input, FastAccessList <object> referenceTracking = null)
{
var config = new ExecutionContext {
ExecutionContextCacheHash = input.ReadString()
};
//DeserializeBody(input, config, referenceTracking);
return(config);
}
public static ExecutionPlanByServer Deserialize(BinaryReader input, FastAccessList <object> referenceTracking)
{
var epBySrv = new ExecutionPlanByServer();
var nbSrv = input.ReadInt32();
for (var i = 0; i < nbSrv; i++)
{
var key = input.ReadString();
var value = ExecutionPlan.Deserialize(input, referenceTracking);
epBySrv.Add(key, value);
}
return(epBySrv);
}
public static InsertStep Deserialize(BinaryReader input, FastAccessList <object> referenceTracking)
{
var bf = SerializationHelper.DefaultFormatter;
var step = new InsertStep();
step.StepId = input.ReadInt32();
step.Depth = input.ReadInt32();
step.SourceTable = TableIdentifier.Deserialize(input);
step.DestinationTable = TableIdentifier.Deserialize(input);
//Variable
var nbVars = input.ReadInt32();
for (int i = 0; i < nbVars; i++)
{
var id = input.ReadInt32();
step.Variables.Add((SqlVariable)referenceTracking[id]);
}
//TableSchema
var tsId = input.ReadInt32();
step.TableSchema = (TableMetadata)referenceTracking[tsId];
//Datarow
var nbRows = input.ReadInt32();
step.Datarow = new object[nbRows];
for (var i = 0; i < nbRows; i++)
{
var tag = input.ReadInt32();
var type = SerializationHelper.TagToType[tag];
if (type == typeof(SqlVariable))
{
var id = input.ReadInt32();
step.Datarow[i] = referenceTracking[id];
}
else
{
step.Datarow[i] = bf.Deserialize(input.BaseStream);
}
}
return(step);
}
private static void DeserializeBody(BinaryReader input,
ref Metadatas metadatas,
FastAccessList <object> referenceTracking = null)
{
//var nbServerMap = input.ReadInt32();
//for (var i = 0; i < nbServerMap; i++)
//{
// var src = SehemaIdentifier.Deserialize(input);
// var dst = SehemaIdentifier.Deserialize(input);
// config.Map.Add(src, dst);
//}
//var nbConnection = input.ReadInt32();
//for (var i = 0; i < nbConnection; i++)
// config.ConnectionStrings.Add(SqlConnection.Deserialize(input));
metadatas = Metadatas.Deserialize(input, referenceTracking);
}
public static AppMetadata Deserialize(BinaryReader stream, FastAccessList <object> referenceTracking = null)
{
var cTables = new AppMetadata();
var nbServers = stream.ReadInt32();
for (var n = 0; n < nbServers; n++)
{
var serverId = stream.ReadInt16();
cTables.Add(serverId, new ServerMetadata());
var nbDatabases = stream.ReadInt32();
for (var j = 0; j < nbDatabases; j++)
{
var database = stream.ReadString();
cTables[serverId].Add(database, new DatabaseMetadata());
var nbSchemas = stream.ReadInt32();
for (var k = 0; k < nbSchemas; k++)
{
var schemaMetadata = new SchemaMetadata();
var schema = stream.ReadString();
var nbTablesFrom = stream.ReadInt32();
for (var l = 0; l < nbTablesFrom; l++)
{
TableMetadata table = null;
if (referenceTracking == null)
{
table = TableMetadata.Deserialize(stream);
}
else
{
var id = stream.ReadInt32();
table = (TableMetadata)referenceTracking[id];
}
schemaMetadata.Add(table);
}
cTables[serverId][database].Add(schema, schemaMetadata);
}
}
}
return(cTables);
}
public void Serialize(BinaryWriter output, FastAccessList <object> referenceTracking)
{
var bf = SerializationHelper.DefaultFormatter;
output.Write(StepId);
output.Write(Depth);
SourceTable.Serialize(output);
DestinationTable.Serialize(output);
//Variable
output.Write(Variables.Count);
foreach (var v in Variables)
{
var vId = referenceTracking.TryAdd(v);
output.Write(vId);
}
//TableSchema
var tsId = referenceTracking.TryAdd(TableSchema);
output.Write(tsId);
//Datarow
output.Write(Datarow.Length);
for (var i = 0; i < Datarow.Length; i++)
{
var data = Datarow[i];
var type = data.GetType();
var tag = SerializationHelper.TypeToTag[type];
output.Write(tag);
if (type == typeof(SqlVariable))
{
var svId = referenceTracking.TryAdd(data);
output.Write(svId);
}
else
{
bf.Serialize(output.BaseStream, data);
}
}
}
public void Serialize(BinaryWriter output, FastAccessList <object> referenceTracking)
{
output.Write(Variables.Count);
foreach (var v in Variables)
{
var id = referenceTracking.TryAdd(v);
output.Write(id);
}
output.Write(InsertSteps.Count);
foreach (var step in InsertSteps)
{
step.Serialize(output, referenceTracking);
}
output.Write(UpdateSteps.Count);
foreach (var step in UpdateSteps)
{
step.Serialize(output);
}
}
private static MetadataContainer DeserializeBody(BinaryReader input, MetadataContainer config,
FastAccessList <object> referenceTracking = null)
{
var nbServerMap = input.ReadInt32();
for (var i = 0; i < nbServerMap; i++)
{
var src = ServerIdentifier.Deserialize(input);
var dst = ServerIdentifier.Deserialize(input);
config.ServerMap.Add(src, dst);
}
var nbConnection = input.ReadInt32();
for (var i = 0; i < nbConnection; i++)
{
config.ConnectionStrings.Add(SqlConnection.Deserialize(input));
}
config.Metadatas = AppMetadata.Deserialize(input, referenceTracking);
return(config);
}
public void Serialize(BinaryWriter output, FastAccessList <object> referenceTracking = null)
{
output.Write(ExecutionContextCacheHash);
//if (Map != null)
//{
// output.Write(Map.Count);
// foreach (var sm in Map)
// {
// sm.Key.Serialize(output);
// sm.Value.Serialize(output);
// }
//}
//else
// output.Write(0);
//output.Write(ConnectionStrings.Count);
//foreach (var cs in ConnectionStrings)
// cs.Serialize(output);
ConnectionsContext.Metadatas.Serialize(output, referenceTracking);
output.Flush();
}
public void Serialize(Stream output, FastAccessList <object> referenceTracking)
{
using (var bw = new BinaryWriter(output, Encoding.UTF8, true))
Serialize(bw, referenceTracking);
}
public void Serialize(Stream output, FastAccessList <object> referenceTracking = null)
{
Serialize(new BinaryWriter(output, Encoding.UTF8, true), referenceTracking);
}
public static ExecutionContext Deserialize(Stream input, FastAccessList <object> referenceTracking = null)
{
return(Deserialize(new BinaryReader(input, Encoding.UTF8, true)));
}
public static MetadataContainer Deserialize(Stream input, FastAccessList <object> referenceTracking = null)
{
return(Deserialize(new BinaryReader(input, Encoding.UTF8, true)));
}
public static AppMetadata Deserialize(Stream stream, FastAccessList <object> referenceTracking = null)
{
return(Deserialize(new BinaryReader(stream, Encoding.UTF8, true), referenceTracking));
}
