/// <summary>
/// Builds the execute stored procedure operation.
/// </summary>
/// <param name="streamName">Name of the stream.</param>
/// <param name="configType">The serialization configuration type identifiers.</param>
/// <param name="serializationKind">The <see cref="SerializationKind"/>.</param>
/// <param name="serializationFormat">The <see cref="SerializationFormat"/>.</param>
/// <param name="compressionKind">The <see cref="CompressionKind"/>.</param>
/// <param name="unregisteredTypeEncounteredStrategy">The <see cref="UnregisteredTypeEncounteredStrategy"/>.</param>
/// <returns>Operation to execute stored procedure.</returns>
public static ExecuteStoredProcedureOp BuildExecuteStoredProcedureOp(
string streamName,
IdentifiedType configType,
SerializationKind serializationKind,
SerializationFormat serializationFormat,
CompressionKind compressionKind,
UnregisteredTypeEncounteredStrategy unregisteredTypeEncounteredStrategy)
{
var sprocName = Invariant($"[{streamName}].[{nameof(GetIdAddIfNecessarySerializerRepresentation)}]");
var parameters = new List <ParameterDefinitionBase>()
{
new InputParameterDefinition <int>(nameof(InputParamName.ConfigTypeWithoutVersionId), Tables.TypeWithoutVersion.Id.SqlDataType, configType.IdWithoutVersion),
new InputParameterDefinition <int>(nameof(InputParamName.ConfigTypeWithVersionId), Tables.TypeWithVersion.Id.SqlDataType, configType.IdWithVersion),
new InputParameterDefinition <string>(nameof(InputParamName.SerializationKind), Tables.SerializerRepresentation.SerializationKind.SqlDataType, serializationKind.ToString()),
new InputParameterDefinition <string>(nameof(InputParamName.SerializationFormat), Tables.SerializerRepresentation.SerializationFormat.SqlDataType, serializationFormat.ToString()),
new InputParameterDefinition <string>(nameof(InputParamName.CompressionKind), Tables.SerializerRepresentation.CompressionKind.SqlDataType, compressionKind.ToString()),
new InputParameterDefinition <string>(nameof(InputParamName.UnregisteredTypeEncounteredStrategy), Tables.SerializerRepresentation.SerializationKind.SqlDataType, unregisteredTypeEncounteredStrategy.ToString()),
new OutputParameterDefinition <int>(nameof(OutputParamName.Id), Tables.SerializerRepresentation.Id.SqlDataType),
};
var result = new ExecuteStoredProcedureOp(sprocName, parameters);
return(result);
}
public SerializerRepresentation DeepCloneWithSerializationKind(SerializationKind serializationKind)
{
var result = new SerializerRepresentation(
serializationKind,
this.SerializationConfigType?.DeepClone(),
this.CompressionKind.DeepClone(),
this.Metadata?.DeepClone());
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializationDescription"/> class.
/// </summary>
/// <param name="serializationKind">The <see cref="SerializationKind" /> to serialize into.</param>
/// <param name="serializationFormat">The <see cref="SerializationFormat" /> to serialize into.</param>
/// <param name="compressionKind">Optional <see cref="CompressionKind" /> to use; DEFAULT is None.</param>
/// <param name="configurationTypeRepresentation">Optional configuration to use; DEFAULT is null.</param>
/// <param name="metadata">Optional metadata to put, especially useful for customer serializer factory; DEFAULT is empty.</param>
public SerializationDescription(SerializationKind serializationKind, SerializationFormat serializationFormat, TypeRepresentation configurationTypeRepresentation = null, CompressionKind compressionKind = CompressionKind.None, IReadOnlyDictionary <string, string> metadata = null)
{
new { serializationKind }.Must().NotBeEqualTo(SerializationKind.Invalid);
new { serializationFormat }.Must().NotBeEqualTo(SerializationFormat.Invalid);
new { compressionKind }.Must().NotBeEqualTo(CompressionKind.Invalid);
this.SerializationKind = serializationKind;
this.SerializationFormat = serializationFormat;
this.ConfigurationTypeRepresentation = configurationTypeRepresentation;
this.CompressionKind = compressionKind;
this.Metadata = metadata ?? new Dictionary <string, string>();
}
private void LoadAttributes(FieldInfo info, GR2Writer writer)
{
var attrs = info.GetCustomAttributes(typeof(SerializationAttribute), true);
if (attrs.Length > 0)
{
SerializationAttribute serialization = attrs[0] as SerializationAttribute;
if (serialization.Section != SectionType.Invalid)
{
PreferredSection = serialization.Section;
}
DataArea = serialization.DataArea;
if (serialization.Type != MemberType.Invalid)
{
Type = serialization.Type;
}
if (serialization.TypeSelector != null)
{
TypeSelector = Activator.CreateInstance(serialization.TypeSelector) as VariantTypeSelector;
}
if (serialization.SectionSelector != null)
{
SectionSelector = Activator.CreateInstance(serialization.SectionSelector) as SectionSelector;
}
if (serialization.Serializer != null)
{
Serializer = Activator.CreateInstance(serialization.Serializer) as NodeSerializer;
}
if (writer != null && serialization.Prototype != null)
{
WriteDefinition = writer.LookupStructDefinition(serialization.Prototype);
}
if (serialization.Name != null)
{
GrannyName = serialization.Name;
}
Prototype = serialization.Prototype;
SerializationKind = serialization.Kind;
ArraySize = serialization.ArraySize;
MinVersion = serialization.MinVersion;
MaxVersion = serialization.MaxVersion;
}
}
/// <summary>
/// Gets the serializer representation from identifier (first by cache and then by database).
/// </summary>
/// <param name="sqlServerLocator">The resource locator.</param>
/// <param name="serializerRepresentationId">The serializer representation identifier.</param>
/// <returns>IdentifiedSerializerRepresentation.</returns>
public IdentifiedSerializerRepresentation GetSerializerRepresentationFromId(
SqlServerLocator sqlServerLocator,
int serializerRepresentationId)
{
var found = this.serializerRepresentationIdToIdentifiedSerializerMap.TryGetValue(serializerRepresentationId, out var result);
if (found)
{
return(result);
}
else
{
var storedProcOp = StreamSchema.Sprocs.GetSerializerRepresentationFromId.BuildExecuteStoredProcedureOp(
this.Name,
serializerRepresentationId);
var sqlProtocol = this.BuildSqlOperationsProtocol(sqlServerLocator);
var sprocResult = sqlProtocol.Execute(storedProcOp);
SerializationKind serializationKind = sprocResult
.OutputParameters[nameof(StreamSchema
.Sprocs.GetSerializerRepresentationFromId.OutputParamName
.SerializationKind)]
.GetValueOfType <SerializationKind>();
int configTypeWithVersionId = sprocResult
.OutputParameters[nameof(StreamSchema
.Sprocs.GetSerializerRepresentationFromId.OutputParamName
.ConfigTypeWithVersionId)]
.GetValueOfType <int>();
CompressionKind compressionKind = sprocResult
.OutputParameters[nameof(StreamSchema
.Sprocs.GetSerializerRepresentationFromId.OutputParamName
.CompressionKind)]
.GetValueOfType <CompressionKind>();
SerializationFormat serializationFormat = sprocResult
.OutputParameters[nameof(StreamSchema
.Sprocs.GetSerializerRepresentationFromId.OutputParamName
.SerializationFormat)]
.GetValueOfType <SerializationFormat>();
var configType = this.GetTypeById(sqlServerLocator, configTypeWithVersionId, true);
var rep = new SerializerRepresentation(serializationKind, configType.WithVersion, compressionKind);
var item = new IdentifiedSerializerRepresentation(serializerRepresentationId, rep, serializationFormat);
this.serializerRepresentationIdToIdentifiedSerializerMap.TryAdd(item.Id, item);
this.serializerRepresentationToIdentifiedSerializerMap.TryAdd(item.SerializerRepresentation, item);
var newFound = this.serializerRepresentationIdToIdentifiedSerializerMap.TryGetValue(serializerRepresentationId, out var newResult);
newFound.MustForOp("failedToFindSerializationRepresentationAfterAdding").BeTrue();
return(newResult);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializerRepresentation"/> class.
/// </summary>
/// <param name="serializationKind">The <see cref="SerializationKind" /> to serialize into.</param>
/// <param name="compressionKind">Optional <see cref="CompressionKind" /> to use; DEFAULT is None.</param>
/// <param name="serializationConfigType">Optional representation of the type of the serialization configuration to use; DEFAULT is null.</param>
/// <param name="metadata">Optional metadata to put, especially useful for custom serializer factory; DEFAULT is empty.</param>
public SerializerRepresentation(
SerializationKind serializationKind,
TypeRepresentation serializationConfigType = null,
CompressionKind compressionKind = CompressionKind.None,
IReadOnlyDictionary <string, string> metadata = null)
{
if (serializationKind == SerializationKind.Invalid)
{
throw new ArgumentOutOfRangeException(Invariant($"'{nameof(serializationKind)}' == '{SerializationKind.Invalid}'"), (Exception)null);
}
if (compressionKind == CompressionKind.Invalid)
{
throw new ArgumentOutOfRangeException(Invariant($"'{nameof(compressionKind)}' == '{CompressionKind.Invalid}'"), (Exception)null);
}
this.SerializationKind = serializationKind;
this.SerializationConfigType = serializationConfigType;
this.CompressionKind = compressionKind;
this.Metadata = metadata ?? new Dictionary <string, string>();
}
// Constructors
/// <summary>
/// Initializes a new instance of this class.
/// </summary>
/// <param name="serializationKind">Default <see cref="SerializationKind"/>.</param>
public SerializationContext(SerializationKind serializationKind)
{
serializationKindGetter = (entity => serializationKind);
}
public PropertyHeaderDefinition(string name, PropertyInfo propertyInfo, SerializationKind serializationKind) : base(propertyInfo)
{
Name = name;
SerializationKind = serializationKind;
}
