public void Not(Action <IHqlExpressionFactory> expression)
{
expression(this);
var a = Criterion;
Criterion = HqlRestrictions.Not(a);
}
public void Or(Action <IHqlExpressionFactory> lhs, Action <IHqlExpressionFactory> rhs)
{
lhs(this);
var a = Criterion;
rhs(this);
var b = Criterion;
Criterion = HqlRestrictions.Or(a, b);
}
public void Disjunction(Action <IHqlExpressionFactory> expression, params Action <IHqlExpressionFactory>[] otherExpressions)
{
var junction = HqlRestrictions.Disjunction();
foreach (var exp in Enumerable.Empty <Action <IHqlExpressionFactory> >().Union(new[] { expression }).Union(otherExpressions))
{
exp(this);
junction.Add(Criterion);
}
Criterion = junction;
}
public void InSubquery(string propertyName, string subquery, Dictionary <string, object> parameters)
{
string subqueryWithParameters = "";
Regex re = new Regex(@"(?<![^\s]):[^\s]+");
subqueryWithParameters = re.Replace(subquery, x => {
object param;
if (parameters.TryGetValue(x.ToString().TrimStart(':'), out param))
{
var typeCode = Type.GetTypeCode(param.GetType());
switch (typeCode)
{
case TypeCode.String:
case TypeCode.DateTime:
return(HqlRestrictions.FormatValue(param));
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.Decimal:
case TypeCode.Double:
return(FormatNumber(param));
default:
return("");
}
}
return("");
});
Criterion = InSubquery(propertyName, subqueryWithParameters);
}
public void Between(string propertyName, object lo, object hi)
{
Criterion = HqlRestrictions.Between(propertyName, lo, hi);
}
public static IHqlCriterion And(IHqlCriterion lhs, IHqlCriterion rhs)
{
return(new CompositeHqlCriterion("and")
.Add(lhs)
.Add(rhs));
}
public CompositeHqlCriterion Add(IHqlCriterion criterion)
{
Criterions.Add(criterion);
return(this);
}
public void IsNotNull(string propertyName)
{
Criterion = HqlRestrictions.IsNotNull(propertyName);
}
public void IsEmpty(string propertyName)
{
Criterion = HqlRestrictions.IsEmpty(propertyName);
}
public void InG <T>(string propertyName, ICollection <T> values)
{
Criterion = HqlRestrictions.InG(propertyName, values);
}
public void LeProperty(string propertyName, string otherPropertyName)
{
Criterion = HqlRestrictions.LeProperty(propertyName, otherPropertyName);
}
public void AllEq(IDictionary propertyNameValues)
{
Criterion = HqlRestrictions.AllEq(propertyNameValues);
}
public void Eq(string propertyName, object value)
{
Criterion = HqlRestrictions.Eq(propertyName, value);
}
public void Ge(string propertyName, object value)
{
Criterion = HqlRestrictions.Ge(propertyName, value);
}
public void InsensitiveLike(string propertyName, string value, HqlMatchMode matchMode)
{
Criterion = HqlRestrictions.InsensitiveLike(propertyName, value, matchMode);
}
public NotExpression(IHqlCriterion criterion)
{
Criterion = criterion;
}
public static IHqlCriterion Or(IHqlCriterion lhs, IHqlCriterion rhs)
{
return(new CompositeHqlCriterion("or")
.Add(lhs)
.Add(rhs));
}
public static IHqlCriterion Not(IHqlCriterion expression)
{
return(new NotExpression(expression));
}
public void NaturalId()
{
Criterion = HqlRestrictions.NaturalId();
}
public void In(string propertyName, object[] values)
{
Criterion = HqlRestrictions.In(propertyName, values);
}
