private static BaseExpression ConvertToBaseExpression(ExpressionMetadata filterMetadataLeftExpression)
{
var dataValueType = DataValueTypeUtilities.ConvertTypeToDataValueType(filterMetadataLeftExpression.Parameter.Type);
var value = GetQueryValue(filterMetadataLeftExpression.Parameter.Value, dataValueType);
return(ConvertToBaseExpression(dataValueType, value));
}
Expression Visit(
Expression node,
ExpressionMetadata parentMeta)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
_metadata.TryGetValue(node.NodeType, out var meta);
if (meta.Weight > parentMeta.Weight ||
meta.Weight == parentMeta.Weight && meta.LeftAssociative == parentMeta.LeftAssociative)
{
Visit(node);
}
else
{
_writer.Write('(');
Visit(node);
_writer.Write(')');
}
return(node);
}
private static ColumnExpression ConvertToColumnExpression(ExpressionMetadata filterMetadataLeftExpression)
{
return(new ColumnExpression()
{
ExpressionType = EntitySchemaQueryExpressionType.SchemaColumn,
ColumnPath = filterMetadataLeftExpression.Parameter.ColumnPath
});
}
private static Filter GenerateSingleColumnFilter(ExpressionMetadata filterMetadata)
{
if (filterMetadata.Parameter?.Type == typeof(bool))
{
return(GenerateBooleanSingleColumnFilter(filterMetadata));
}
throw new NotImplementedException();
}
protected override Expression VisitTypeBinary(
TypeBinaryExpression node)
{
ExpressionMetadata meta = _metadata[node.NodeType];
Visit(node.Expression, node);
_writer.Write("{0}{1}", meta.Operator, GetTypeName(node.TypeOperand));
return(node);
}
private static Filter GenerateBooleanSingleColumnFilter(ExpressionMetadata filterMetadata)
{
var left = ConvertExpression(filterMetadata);
var right = ConvertToBaseExpression(DataValueType.Boolean, true);
return(new Filter()
{
FilterType = FilterType.CompareFilter,
LeftExpression = left,
ComparisonType = FilterComparisonType.Equal,
RightExpression = right
});
}
private static T GenerateFilterGroup <T>(ExpressionMetadata filterMetadata) where T : Filter, new()
{
var filters = new Dictionary <string, Filter>();
filterMetadata.Items.ForEach(fm => {
filters.Add(Guid.NewGuid().ToString(), GenerateFilter(fm));
});
return(new T()
{
FilterType = FilterType.FilterGroup,
LogicalOperation = filterMetadata.LogicalOperation,
Items = filters
});
}
internal static Filter GenerateFilter(ExpressionMetadata filterMetadata)
{
switch (filterMetadata.NodeType)
{
case ExpressionMetadataNodeType.Comparison:
return(GenerateComparisonFilter(filterMetadata));
case ExpressionMetadataNodeType.Group:
return(GenerateFilterGroup <Filter>(filterMetadata));
case ExpressionMetadataNodeType.Column:
return(GenerateSingleColumnFilter(filterMetadata));
default:
throw new NotImplementedException();
}
}
private static Filter GenerateComparisonFilter(ExpressionMetadata filterMetadata)
{
var rightExpressions = filterMetadata.RightExpressions.Select(ConvertExpression).ToList();
var filter = new Filter()
{
FilterType = rightExpressions.Count > 1 ? FilterType.InFilter : FilterType.CompareFilter,
LeftExpression = ConvertExpression(filterMetadata.LeftExpression),
ComparisonType = filterMetadata.ComparisonType,
IsNull = filterMetadata.ComparisonType == FilterComparisonType.IsNull,
RightExpression = rightExpressions.Count == 1 ? rightExpressions.First() : null,
RightExpressions = rightExpressions.Count > 1 ? rightExpressions.ToArray() : null
};
if (filterMetadata.ComparisonType == FilterComparisonType.IsNull || filterMetadata.ComparisonType == FilterComparisonType.IsNotNull)
{
filter.FilterType = FilterType.IsNullFilter;
}
return(filter);
}
private static BaseExpression ConvertExpression(ExpressionMetadata filterMetadataLeftExpression)
{
return(filterMetadataLeftExpression.NodeType == ExpressionMetadataNodeType.Column
? ConvertToColumnExpression(filterMetadataLeftExpression)
: ConvertToBaseExpression(filterMetadataLeftExpression));
}
