public BinaryX20(FieldPredicate isSerializableField, PropertyPredicate isSerializableProperty)
{
_Logic = new X20Logic(isSerializableField, isSerializableProperty);
_Serializers = new List <BaseSerializer>()
{
PrimitiveSerializer.Instance,
new V2Serializer(),
new V3Serializer(),
new V4Serializer(),
new BoundsSerializer(),
new LayerMaskSerializer(),
new RectSerializer(),
new ArraySerializer(),
new DictionarySerializer(),
new EnumSerializer(),
new CollectionSerializer(),
new TypeSerializer(),
new ReflectiveSerializer(),
};
_Ctx = new SerializationContext(this);
_Marker = new ReferenceMarker();
_CachedSerializers = new Dictionary <Type, BaseSerializer>();
SetMode(1);
}
public X20Logic(FieldPredicate isSerializableField, PropertyPredicate isSerializableProperty)
{
_IsSerializableField = isSerializableField;
_IsSerializableProperty = isSerializableProperty;
CachedGetSerializableMembers = new Func<Type, MemberInfo[]>(type =>
{
var members = X20Reflection.CachedGetMembers(type);
var serializableMembers = members.Where(IsSerializableMember).ToArray();
return serializableMembers;
}).Memoize();
}
public X20Logic(FieldPredicate isSerializableField, PropertyPredicate isSerializableProperty)
{
_IsSerializableField = isSerializableField;
_IsSerializableProperty = isSerializableProperty;
CachedGetSerializableMembers = new Func <Type, MemberInfo[]>(type =>
{
var members = X20Reflection.CachedGetMembers(type);
var serializableMembers = members.Where(IsSerializableMember).ToArray();
return(serializableMembers);
}).Memoize();
}
public void GetSql()
{
var predicate = new PropertyPredicate <TestEntity, TestEntity>()
{
PropertyName = "Id",
PropertyName2 = "Name",
Operator = Operator.Eq
};
var dictionary = new Dictionary <string, object>();
var sql = predicate.GetSql(SqlHelper.GetSqlGenerator(), dictionary);
Assert.Equal("(Id = Name)", sql);
}
/// <summary>
/// Creates a predicate which represents a standard comparison clause,
/// of the form [FieldName1] [Operator] [FieldName2].
/// </summary>
/// <typeparam name="TModel">The type of the entity for the left operand.</typeparam>
/// <typeparam name="TModel2">The type of the entity for the right operand.</typeparam>
/// <typeparam name="TFieldType">The data type of the property.</typeparam>
/// <param name="left">An expression that returns the [FieldName1] operand.</param>
/// <param name="op">One of the <see cref="Operator"/> values.</param>
/// <param name="right">An expression that returns the [FieldName2] operand.</param>
/// <param name="not"><see langword="true"/> to invert the comparison operator.</param>
/// <returns>An <see cref="IPredicate"/> instance representing the predicate.</returns>
public static IPredicate PropertyComparison <TModel, TModel2, TFieldType>(Expression <Func <TModel, TFieldType> > left, Operator op, Expression <Func <TModel2, TFieldType> > right, bool not = false)
where TModel : class
where TModel2 : class
{
var predicate = new PropertyPredicate <TModel, TModel2>
{
PropertyName = left.GetProperty().Name,
Operator = op,
PropertyName2 = right.GetProperty().Name
};
return(predicate);
}
/// <summary>
/// Creates a predicate which represents a standard comparison clause,
/// of the form [FieldName1] [Operator] [FieldName2].
/// </summary>
/// <typeparam name="TModel">The type of the entity for the left operand.</typeparam>
/// <typeparam name="TModel2">The type of the entity for the right operand.</typeparam>
/// <typeparam name="TFieldType">The data type of the property.</typeparam>
/// <param name="left">The [FieldName1] operand.</param>
/// <param name="op">One of the <see cref="Operator"/> values.</param>
/// <param name="right">The [FieldName2] operand.</param>
/// <param name="not"><see langword="true"/> to invert the comparison operator.</param>
/// <returns>An <see cref="IPredicate"/> instance representing the predicate.</returns>
public static IPredicate PropertyComparison <TModel, TModel2, TFieldType>(string left, Operator op, string right, bool not = false)
where TModel : class
where TModel2 : class
{
var predicate = new PropertyPredicate <TModel, TModel2>
{
Not = not,
PropertyName = left,
Operator = op,
PropertyName2 = right
};
return(predicate);
}
public void LeWithNot_ReturnsProperSql()
{
var pred = new PropertyPredicate <PredicateTestEntity, PredicateTestEntity2>
{
PropertyName = "Id",
PropertyName2 = "Key",
Not = true,
Operator = Operator.Le
};
Dictionary <string, object> parameters = new Dictionary <string, object>();
string result = pred.GetSql(parameters);
Assert.AreEqual("([PredicateTestEntity].[Id] > [PredicateTestEntity2].[Key])", result);
Assert.AreEqual(0, parameters.Count);
}
public override ISqlFragment Visit(PropertyPredicate e)
{
Check.NotNull(e, "e");
SqlBuilder result;
var instanceSql = e.Instance.Accept(this);
var VariableReferenceExpression = e.Instance as VariableReferencePredicate;
if (VariableReferenceExpression != null)
{
isVarRefSingle = false;
}
var joinSymbol = instanceSql as JoinSymbol;
if (joinSymbol != null)
{
if (joinSymbol.IsNestedJoin)
{
return(new SymbolPair(joinSymbol, joinSymbol.NameToExtent[e.Property.Name]));
}
else
{
return(joinSymbol.NameToExtent[e.Property.Name]);
}
}
var symbolPair = instanceSql as SymbolPair;
if (symbolPair != null)
{
var columnJoinSymbol = symbolPair.Column as JoinSymbol;
if (columnJoinSymbol != null)
{
symbolPair.Column = columnJoinSymbol.NameToExtent[e.Property.Name];
return(symbolPair);
}
else
{
if (symbolPair.Column.Columns.ContainsKey(e.Property.Name))
{
result = new SqlBuilder();
result.Append(symbolPair.Source);
result.Append(".");
var columnSymbol = symbolPair.Column.Columns[e.Property.Name];
optionalColumnUsageManager.MarkAsUsed(columnSymbol);
result.Append(columnSymbol);
return(result);
}
}
}
result = new SqlBuilder();
result.Append(instanceSql);
result.Append(".");
var symbol = instanceSql as Symbol;
Symbol colSymbol;
if (symbol != null && symbol.OutputColumns.TryGetValue(e.Property.Name, out colSymbol))
{
optionalColumnUsageManager.MarkAsUsed(colSymbol);
if (symbol.OutputColumnsRenamed)
{
result.Append(colSymbol);
}
else
{
result.Append(QuoteIdentifier(e.Property.Name));
}
}
else
{
result.Append(QuoteIdentifier(e.Property.Name));
}
return(result);
}
public void Lt_ReturnsProperSql()
{
var pred = new PropertyPredicate<PredicateTestEntity, PredicateTestEntity2>
{
PropertyName = "Id",
PropertyName2 = "Key",
Not = false,
Operator = Operator.Lt
};
Dictionary<string, object> parameters = new Dictionary<string, object>();
string result = pred.GetSql(parameters);
Assert.AreEqual("([PredicateTestEntity].[Id] < [PredicateTestEntity2].[Key])", result);
Assert.AreEqual(0, parameters.Count);
}
