/// <summary>
/// Recupera os registros serializados no leitor informado.
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public static IEnumerable <Record> GetRecords(Colosoft.Serialization.IO.CompactReader reader)
{
var hasDescriptor = reader.ReadByte() == 1;
if (hasDescriptor)
{
var descriptor = new Record.RecordDescriptor();
((Colosoft.Serialization.ICompactSerializable)descriptor).Deserialize(reader);
while (reader.ReadByte() == 1)
{
var r = new Record(descriptor);
((Colosoft.Serialization.ICompactSerializable)r).Deserialize(reader);
yield return(r);
}
}
}
/// <summary>
/// Compara a instancia com um descritor.
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool Equals(Record.RecordDescriptor other)
{
if (other.Count == _properties.Count)
{
var comparer = StringComparer.InvariantCultureIgnoreCase;
foreach (var field in other)
{
if (!_properties.Exists(f => comparer.Equals(f.FieldName, field.Name)))
{
return(false);
}
}
return(true);
}
return(false);
}
/// <summary>
/// Construtor usado na deserialização dos dados.
/// </summary>
/// <param name="info"></param>
/// <param name="context"></param>
private QueryResult(SerializationInfo info, StreamingContext context)
{
_descriptor = info.GetValue("Descriptor", typeof(Record.RecordDescriptor)) as Record.RecordDescriptor;
var count = info.GetInt32("C");
var records = new List <Record>();
for (var i = 0; i < count; i++)
{
var values = new object[_descriptor.Count];
for (var j = 0; j < _descriptor.Count; j++)
{
values[j] = info.GetValue(string.Format("{0}_{1}", i, j), _descriptor[j].Type);
}
records.Add(_descriptor.CreateRecord(values));
}
_records = records;
}
/// <summary>
/// Cria uma instancia com o registros encontrados e as subconsultas.
/// </summary>
/// <param name="descriptor"></param>
/// <param name="records"></param>
/// <param name="info">Informações da consulta.</param>
/// <param name="executer">Ponteiro para o método responsável por executar um consulta com base no QueryInfo</param>
public QueryResult(Record.RecordDescriptor descriptor, IEnumerable <Record> records, QueryInfo info, Func <QueryInfo, IQueryResult> executer) : this(descriptor, records)
{
_queryInfo = info;
_executer = executer;
var referenceParameters = new List <ReferenceParameter>();
if (info != null && info.NestedQueries != null)
{
foreach (var query in info.NestedQueries)
{
if (query.Parameters != null)
{
foreach (var parameter in query.Parameters)
{
if (parameter.Value is ReferenceParameter)
{
var refParameter = (ReferenceParameter)parameter.Value;
if (!referenceParameters.Exists(f => StringComparer.InvariantCultureIgnoreCase.Equals(f.ColumnName, refParameter.ColumnName)))
{
referenceParameters.Add(refParameter);
}
}
}
}
if (query.ExecutePredicate != null && query.ExecutePredicate.RequiredFields != null)
{
foreach (var requiredField in query.ExecutePredicate.RequiredFields)
{
var columnName = requiredField.Name;
if (string.IsNullOrEmpty(columnName) && requiredField.Index >= 0 && requiredField.Index < descriptor.Count)
{
columnName = descriptor[requiredField.Index].Name;
}
if (!string.IsNullOrEmpty(columnName) && !referenceParameters.Exists(f => StringComparer.InvariantCultureIgnoreCase.Equals(f.ColumnName, columnName)))
{
referenceParameters.Add(new ReferenceParameter(columnName));
}
}
}
}
}
_referenceParameters = referenceParameters.ToArray();
}
/// <summary>
/// Formata a mensagem do erro.
/// </summary>
/// <param name="fieldName"></param>
/// <param name="descriptor"></param>
/// <param name="queryResult">Resulta da consulta associada.</param>
/// <returns></returns>
private static string FormatMessage(string fieldName, Record.RecordDescriptor descriptor, IQueryResult queryResult)
{
QueryCommand command = null;
if (queryResult is IQueryCommandContainer)
{
command = ((IQueryCommandContainer)queryResult).Command;
}
var fieldsAvailables = string.Join("; ", descriptor.Select(f => f.Name).ToArray());
if (command != null)
{
return(ResourceMessageFormatter.Create(() => Properties.Resources.RecordFieldNotFoundExceptionWithQueryCommand_Message, fieldName, fieldsAvailables, command.ToString()).Format());
}
else
{
return(ResourceMessageFormatter.Create(() => Properties.Resources.RecordFieldNotFoundException_Message, fieldName, fieldsAvailables).Format());
}
}
/// <summary>
/// Recupera o esquema que será usado para converter os dados do registro.
/// </summary>
/// <param name="descriptor"></param>
/// <returns></returns>
private TypeBindRecordDescriptorSchema GetRecordSchema(Record.RecordDescriptor descriptor)
{
lock (_schemas)
{
if (_schemas.Count > 0)
{
foreach (var i in _schemas)
{
if (i.Equals(descriptor))
{
return(i);
}
}
}
var schema = new TypeBindRecordDescriptorSchema(this, descriptor);
_schemas.Add(schema);
return(schema);
}
}
/// <summary>
/// Valida o resultado da consulta.
/// </summary>
/// <param name="queryResult"></param>
/// <returns></returns>
public static ValidationQueryResult Validate(this IQueryResult queryResult)
{
QueryInfo queryInfo = null;
Record.RecordDescriptor descriptor = null;
if (queryResult is IQueryResultExt)
{
queryInfo = ((IQueryResultExt)queryResult).QueryInfo;
}
if (queryInfo == null)
{
return(new ValidationQueryResult(ValidationQueryResult.ValidationError.None, null));
}
descriptor = queryResult.Descriptor;
if (descriptor != null && queryInfo.Projection != null && queryInfo.Projection.Count > 0)
{
var projection = queryInfo.Projection;
var isMatch = (descriptor.Count == projection.Count);
if (isMatch)
{
for (var i = 0; i < projection.Count; i++)
{
var fieldName = GetFieldName(projection[i]);
if (string.IsNullOrEmpty(fieldName))
{
continue;
}
if (!StringComparer.InvariantCultureIgnoreCase.Equals(fieldName, descriptor[i].Name))
{
isMatch = false;
break;
}
}
}
if (!isMatch)
{
var message = ResourceMessageFormatter.Create(() => Properties.Resources.ValidationQueryResult_NotMatchFields, string.Join("; ", projection.Select(f => GetFieldName(f)).ToArray()), string.Join("; ", descriptor.Select(f => f.Name).ToArray()));
return(new ValidationQueryResult(ValidationQueryResult.ValidationError.InvalidFields, message));
}
}
return(new ValidationQueryResult(ValidationQueryResult.ValidationError.None, null));
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="typeBindStrategy">Instancia da estratégia de vinculação associada.</param>
/// <param name="descriptor"></param>
public TypeBindRecordDescriptorSchema(TypeBindStrategy typeBindStrategy, Record.RecordDescriptor descriptor)
{
_properties = new List <Property>();
var typeProperties = typeBindStrategy.Type.GetProperties(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
var stringComparer = StringComparer.InvariantCultureIgnoreCase;
foreach (var field in descriptor)
{
var prop = typeProperties.Where(f => f.CanWrite && stringComparer.Equals(f.Name, field.Name)).FirstOrDefault();
if (prop != null)
{
if (_properties.Exists(f => stringComparer.Equals(f.FieldName, field.Name)))
{
throw new TypeBindStrategyException(ResourceMessageFormatter.Create(() => Properties.Resources.TypeBindStrategy_DuplicateFieldName, field.Name, typeBindStrategy.Type.FullName, string.Join(", ", descriptor.Select(f => f.Name).ToArray())).Format());
}
var converter = System.ComponentModel.TypeDescriptor.GetConverter(prop.PropertyType);
_properties.Add(new Property(field.Name, prop, converter));
}
}
}
/// <summary>
/// Deserializa os dados na instancia.
/// </summary>
/// <param name="reader"></param>
void Colosoft.Serialization.ICompactSerializable.Deserialize(Colosoft.Serialization.IO.CompactReader reader)
{
var hasDescriptor = reader.ReadByte() == 1;
if (hasDescriptor)
{
_descriptor = new Record.RecordDescriptor();
((Colosoft.Serialization.ICompactSerializable)_descriptor).Deserialize(reader);
var records = new List <Record>();
while (reader.ReadByte() == 1)
{
var r = new Record(_descriptor);
((Colosoft.Serialization.ICompactSerializable)r).Deserialize(reader);
records.Add(r);
}
_records = records;
}
else
{
_records = new Record[0];
}
}
void System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
reader.ReadStartElement();
var records = new List <Record>();
while (reader.NodeType != XmlNodeType.EndElement)
{
if (!reader.IsEmptyElement && reader.LocalName == "Descriptor")
{
reader.MoveToElement();
_descriptor = new Record.RecordDescriptor();
((System.Xml.Serialization.IXmlSerializable)_descriptor).ReadXml(reader);
}
else if (!reader.IsEmptyElement && reader.LocalName == "Records")
{
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.LocalName == "Record")
{
var record = new Record(_descriptor);
((IXmlSerializable)record).ReadXml(reader);
records.Add(record);
}
else
{
reader.Skip();
}
}
reader.ReadEndElement();
}
else
{
reader.Skip();
}
}
reader.ReadEndElement();
_records = records;
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="descriptor">Instancia do descritor do resultado.</param>
/// <param name="records"></param>
public QueryResult(Record.RecordDescriptor descriptor, IEnumerable <Record> records)
{
_descriptor = descriptor;
_records = records;
}
/// <summary>
/// Formata a mensagem do erro.
/// </summary>
/// <param name="descriptor"></param>
/// <returns></returns>
private static string FormatMessage(Record.RecordDescriptor descriptor)
{
return(ResourceMessageFormatter.Create(() => Properties.Resources.InvalidRecordChecksumException_Message, string.Join("; ", descriptor.Select(f => f.Name).ToArray())).Format());
}
/// <summary>
/// Cria a instancia com as informações do campo não encontrado.
/// </summary>
/// <param name="fieldName"></param>
/// <param name="descriptor"></param>
/// <param name="queryResult">Resultado da consulta associada.</param>
public RecordFieldNotFoundException(string fieldName, Record.RecordDescriptor descriptor, IQueryResult queryResult) : base(FormatMessage(fieldName, descriptor, queryResult))
{
}
/// <summary>
/// Cria uma sessão de estratégia de vinculação para o descritor informado.
/// </summary>
/// <param name="recordDescriptor">Descritor dos registros para fazer a vinculação.</param>
/// <returns></returns>
public IQueryResultBindStrategySession CreateSession(Record.RecordDescriptor recordDescriptor)
{
return(new TypeBindStrategySession(GetRecordSchema(recordDescriptor)));
}
/// <summary>
/// Cria uma sessão de vinculação.
/// </summary>
/// <param name="recordDescriptor"></param>
/// <returns></returns>
IQueryResultBindStrategySession IQueryResultBindStrategy.CreateSession(Record.RecordDescriptor recordDescriptor)
{
throw new NotSupportedException();
}
/// <summary>
/// Construtor vazio.
/// </summary>
public QueryResult()
{
_descriptor = new Record.RecordDescriptor("Empty", new Record.Field[0]);
_records = new Record[0];
}
/// <summary>
/// Cria a instancia com as informações do campo não encontrado.
/// </summary>
/// <param name="descriptor"></param>
public InvalidRecordChecksumException(Record.RecordDescriptor descriptor) : base(FormatMessage(descriptor))
{
}
