/// <summary>
/// 将表达式翻译为相应的连接条件
/// </summary>
/// <param name="binary">表达式</param>
/// <param name="relationType">关系类型</param>
private void GetJoin(BinaryExpression binary, PredicateType predicateType, JoinRelation joinRelation)
{
Check.IfNullOrZero(binary);
var leftMember = (MemberExpression)binary.Left;
var rightMember = (MemberExpression)binary.Right;
//表达式左右两边都不为常量时例如 xx.Id==yy.Id
if (binary.Left.NodeType != ExpressionType.Constant && binary.Right.NodeType != ExpressionType.Constant)
{
var leftAliasName = ExtractMember(leftMember);
var rightAliasName = ExtractMember(rightMember);
var relationTemplate = _options.TemplateBase.CreatePredicate(predicateType, $"{rightAliasName}.{rightMember.Member.Name}", $"{leftAliasName}.{leftMember.Member.Name}");
AssignmentPredicateType(joinRelation, relationTemplate);
}
else if (binary.Left.NodeType == ExpressionType.Constant) //表达式左边为常量
{
var rightAliasName = ExtractMember(rightMember);
var constant = (ConstantExpression)binary.Left;
var value = Boolean.TryParse(constant.Value.ToString(), out var result) ? (result ? 1 : 0).ToString() : constant.Value;
AssignmentPredicateType(joinRelation, _options.TemplateBase.CreatePredicate(predicateType, value + "", $"{rightAliasName}.{rightMember.Member.Name}"));
}
else if (binary.Right.NodeType == ExpressionType.Constant) //表达式的右边为常量
{
var leftAliasName = ExtractMember(leftMember);
var constant = (ConstantExpression)binary.Right;
var value = Boolean.TryParse(constant.Value.ToString(), out var result) ? (result ? 1 : 0).ToString() : constant.Value;
AssignmentPredicateType(joinRelation, _options.TemplateBase.CreatePredicate(predicateType, $"{leftAliasName}.{leftMember.Member.Name}", value + ""));
}
}
/// <summary>
/// 创建谓词语句
/// </summary>
/// <param name="binary"></param>
/// <param name="predicateType"></param>
/// <param name="joinRelation"></param>
private void CreatePredicate(BinaryExpression binary, PredicateType predicateType, JoinRelation joinRelation)
{
Check.IfNullOrZero(binary);
var binaryExp = binary;
if (joinRelation != JoinRelation.NONE)
{
GetJoin(binaryExp, predicateType, joinRelation);
}
else
{
_predicateTypeStack.Push(predicateType);
//当表达式的左边和右边同时不为常量或者只有左边为常量的话，则从左到右解析表达式，否则从右到左解析表达式
if ((binary.Left.NodeType != ExpressionType.Constant && binary.Right.NodeType != ExpressionType.Constant) || binary.Left.NodeType != ExpressionType.Constant)
{
InternalProcess(binaryExp.Left, joinRelation);
InternalProcess(binaryExp.Right, joinRelation);
}
else
{
InternalProcess(binaryExp.Right, joinRelation);
InternalProcess(binaryExp.Left, joinRelation);
}
}
}
public static int Arity(this PredicateType predType)
{
switch (predType)
{
case PredicateType.Equal:
return(2);
case PredicateType.GreaterThan:
return(2);
case PredicateType.GreaterThanOrEqual:
return(2);
case PredicateType.LessThan:
return(2);
case PredicateType.LessThanOrEqual:
return(2);
case PredicateType.NotEqual:
return(2);
case PredicateType.IsTrue:
return(1);
case PredicateType.IsFalse:
return(1);
default:
throw AssertionHelper.Fail();
}
}
public static bool TextMatches(string textFilter, string textAoe, PredicateType predicateType, TextMode textMode)
{
if (string.IsNullOrWhiteSpace(textFilter) || string.IsNullOrWhiteSpace(textAoe))
{
return(false);
}
string caseTextFilter;
string caseTextAoe;
if (textMode == TextMode.CaseInsensitive)
{
caseTextFilter = textFilter.ToLower();
caseTextAoe = textAoe.ToLower();
}
else
{
caseTextFilter = textFilter;
caseTextAoe = textAoe;
}
switch (predicateType)
{
case PredicateType.FullMatch:
return(string.Equals(caseTextFilter, caseTextAoe));
case PredicateType.Contains:
return(caseTextAoe.Contains(caseTextFilter));
case PredicateType.AllWords:
return(AllWords(caseTextAoe, caseTextFilter));
}
return(false);
}
public override int GetHashCode()
{
int hash = 1;
if (Type.Length != 0)
{
hash ^= Type.GetHashCode();
}
hash ^= subject_.GetHashCode();
if (PredicateType.Length != 0)
{
hash ^= PredicateType.GetHashCode();
}
if (predicateCase_ == PredicateOneofCase.Provenance)
{
hash ^= Provenance.GetHashCode();
}
if (predicateCase_ == PredicateOneofCase.SlsaProvenance)
{
hash ^= SlsaProvenance.GetHashCode();
}
hash ^= (int)predicateCase_;
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
/// <summary>
/// Constructor for all non IN list predicates.
/// </summary>
/// <param name="type">The predicate type.</param>
/// <param name="column">The column to which the predicate applies.</param>
/// <param name="lower">
/// The lower bound serialized value if this is a Range predicate,
/// or the equality value if this is an Equality predicate.
/// </param>
/// <param name="upper">The upper bound serialized value if this is a Range predicate.</param>
public KuduPredicate(PredicateType type, ColumnSchema column, byte[]?lower, byte[]?upper)
{
Type = type;
Column = column;
Lower = lower;
Upper = upper;
}
/// <summary>
/// Compare
/// </summary>
/// <param name="il"></param>
/// <param name="pred"></param>
/// <returns></returns>
public static ILGenerator Cmp(this ILGenerator il, PredicateType pred)
{
switch (pred)
{
case PredicateType.Equal:
return(il.Ceq());
case PredicateType.GreaterThan:
return(il.Cgt());
case PredicateType.GreaterThanOrEqual:
return(il.Cge());
case PredicateType.LessThan:
return(il.Clt());
case PredicateType.LessThanOrEqual:
return(il.Cle());
case PredicateType.NotEqual:
return(il.Cne());
case PredicateType.IsFalse:
return(il.Cfalse());
case PredicateType.IsTrue:
return(il.Ctrue());
default:
throw new ArgumentException(@"Invalid Predicate Type", "pred");
}
}
public static String ToSymbol(this PredicateType predType)
{
switch (predType)
{
case PredicateType.Equal:
return("==");
case PredicateType.GreaterThan:
return(">");
case PredicateType.GreaterThanOrEqual:
return(">=");
case PredicateType.LessThan:
return("<");
case PredicateType.LessThanOrEqual:
return("<=");
case PredicateType.NotEqual:
return("!=");
case PredicateType.IsTrue:
return("true");
case PredicateType.IsFalse:
return("false");
default:
throw new ArgumentOutOfRangeException("predType");
}
}
public static OperatorType ToOperatorType(this PredicateType predType)
{
switch (predType)
{
case PredicateType.Equal:
return(OperatorType.Equal);
case PredicateType.GreaterThan:
return(OperatorType.GreaterThan);
case PredicateType.GreaterThanOrEqual:
return(OperatorType.GreaterThanOrEqual);
case PredicateType.LessThan:
return(OperatorType.LessThan);
case PredicateType.LessThanOrEqual:
return(OperatorType.LessThanOrEqual);
case PredicateType.NotEqual:
return(OperatorType.NotEqual);
default:
throw AssertionHelper.Fail();
}
}
internal static BooleanComparisonType GetComparisonType(PredicateType predicateType)
{
if (predicateType == PredicateType.eq)
{
return(BooleanComparisonType.Equals);
}
if (predicateType == PredicateType.neq)
{
return(BooleanComparisonType.NotEqualToExclamation);
}
if (predicateType == PredicateType.lt)
{
return(BooleanComparisonType.LessThan);
}
if (predicateType == PredicateType.lte)
{
return(BooleanComparisonType.LessThanOrEqualTo);
}
if (predicateType == PredicateType.gt)
{
return(BooleanComparisonType.GreaterThan);
}
if (predicateType == PredicateType.gte)
{
return(BooleanComparisonType.GreaterThanOrEqualTo);
}
throw new Exception("Error: GetComparisonTypeFromPredicateType");
}
public static Predicate <SYMBOL> operator~(Predicate <SYMBOL> predicate)
{
PredicateType type = (predicate.Type == PredicateType.In) ?
PredicateType.NotIn : PredicateType.In;
return(new Predicate <SYMBOL>(type, new Set <SYMBOL>(predicate.Set)));
}
public static IPredicateToken Create(
PredicateType type,
IEntityMapper mapper,
MethodCallExpression expression)
{
switch (type)
{
case PredicateType.Where:
return(new WhereToken(expression, mapper));
case PredicateType.GroupBy:
return(new GroupByToken(expression, mapper));
case PredicateType.OrderBy:
return(new OrderByToken(expression, mapper));
case PredicateType.OrderByDescending:
return(new OrderByToken(expression, mapper, descending: true));
case PredicateType.Take:
return(new TakeToken(expression, mapper));
case PredicateType.First:
return(new FirstToken(expression, mapper));
default:
throw new InvalidOperationException(
$"Predicate {type} does not exists");
}
}
public static ILGenerator cmp(this ILGenerator il, PredicateType pred)
{
switch (pred)
{
case PredicateType.Equal:
return(il.ceq());
case PredicateType.GreaterThan:
return(il.cgt());
case PredicateType.GreaterThanOrEqual:
return(il.cge());
case PredicateType.LessThan:
return(il.clt());
case PredicateType.LessThanOrEqual:
return(il.cle());
case PredicateType.NotEqual:
return(il.cne());
case PredicateType.IsFalse:
return(il.cne());
case PredicateType.IsTrue:
return(il.cne());
default:
throw AssertionHelper.Fail();
}
}
internal override String CreatePredicate(PredicateType predicateType, String left, String right)
{
Check.IfNullOrZero(predicateType);
Check.IfNullOrZero(left);
Check.IfNullOrZero(right);
return(String.Format(PredicateMapper[predicateType], left, right));
}
public Predicate(PredicateType type, params object[] values)
{
Values = new List <object>();
foreach (var value in values)
{
Values.Add(value);
}
PredicateType = type;
}
public Predicate(PredicateType type, params object[] values)
{
if (values != null)
{
Value = values[0];
Values = values.ToList();
}
PredicateType = type;
}
private static TypeScheme <PredicateType> Generalise(PredicateType predicateType)
=> new TypeScheme <PredicateType>(
predicateType
.Params
.SelectMany(t => t.Variables())
.Distinct()
.ToImmutableArray(),
predicateType
);
public static bool parsePredicate(string url, out predicates pred, out PredicateType type) //, out Dictionary<string, byte> urlValues) {
{
pred = predicates.no; type = PredicateType.no;
if (!string2Pred.TryGetValue(url, out pred))
{
return(false);
}
type = predicateTypes[pred];
//if (type == PredicateType.UriValuesProps) urlValues = ConstMan.enumValueMap[url];
return(true);
}
///<summary>
///Get the PredicateType based on the FilterPredicates.
///</summary>
///<returns>
///Return the PredicateType as symbol based on FilterPredicates.
///</returns>
private string GetPredicateType(PredicateType predicate)
{
if (predicate == PredicateType.And || predicate == PredicateType.AndAlso)
{
return("&&");
}
else
{
return("||");
}
}
public Predicate <SYMBOL> Simplify(Predicate <SYMBOL> predicate)
{
if (predicate.Set.Count > (Alphabet - predicate.Set).Count)
{
PredicateType type = (predicate.Type == PredicateType.In) ?
PredicateType.NotIn : PredicateType.In;
return(new Predicate <SYMBOL>(type, Alphabet - predicate.Set));
}
else
{
return(predicate);
}
}
/// <summary>
///
/// </summary>
/// <param name="predicateType"></param>
/// <returns></returns>
internal static string GetPredicateMethodName(PredicateType predicateType)
{
return(predicateType == PredicateType.Update
? "UpdateWhen(...)"
: predicateType == PredicateType.Delete ?
"DeleteWhen(...)"
: predicateType == PredicateType.Where ?
"Where(...)"
: predicateType == PredicateType.And ?
"And(...)"
: predicateType == PredicateType.Or ?
"Or(...)"
: string.Empty);
}
private static bool IsCompatible(SqlSelectStatement result, PredicateType predicateType)
{
switch (predicateType)
{
case PredicateType.Distinct:
return(result.Select.Top == null &&
result.Select.Skip == null &&
result.OrderBy.IsEmpty);
case PredicateType.Filter:
return(result.Select.IsEmpty &&
result.Where.IsEmpty &&
result.GroupBy.IsEmpty &&
result.Select.Top == null &&
result.Select.Skip == null);
case PredicateType.GroupBy:
return(result.Select.IsEmpty &&
result.GroupBy.IsEmpty &&
result.OrderBy.IsEmpty &&
result.Select.Top == null &&
result.Select.Skip == null &&
!result.Select.IsDistinct);
case PredicateType.Limit:
case PredicateType.Element:
return(result.Select.Top == null);
case PredicateType.Project:
return(result.Select.IsEmpty &&
result.GroupBy.IsEmpty &&
!result.Select.IsDistinct);
case PredicateType.Skip:
return(result.Select.IsEmpty &&
result.Select.Skip == null &&
result.GroupBy.IsEmpty &&
result.OrderBy.IsEmpty &&
!result.Select.IsDistinct);
case PredicateType.Sort:
return(result.Select.IsEmpty &&
result.GroupBy.IsEmpty &&
result.OrderBy.IsEmpty &&
!result.Select.IsDistinct);
default:
throw new InvalidOperationException(String.Empty);
}
}
/// <summary>
/// Fa il performe di un queryable tramite reflection
/// Serve per la deserializzazione delle query sql in queryable
/// </summary>
/// <param name="source">query</param>
/// <param name="property">proprietà sulla quale fare il confronto</param>
/// <param name="predicateType">Tipo di confronto da fare</param>
/// <param name="value">valore dell'espressione di confronto</param>
/// <returns>La query aggiornata</returns>
public static IQueryable Where(this IQueryable source, string property, PredicateType predicateType, object value)
{
var type = source.GetType();
ParameterExpression param = Expression.Parameter(source.GetType(), "specificQueryable");
Expression sourceExpression = Expression.Constant(source);
Expression propertyExpression = Expression.Constant(property);
Expression predicateTypeExpression = Expression.Constant(predicateType);
Expression valueExpression = Expression.Convert(Expression.Constant(value), typeof(object));
var methodInfo = typeof(IQueryablesExtension).GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance)
.FirstOrDefault(mi => mi.Name == "Where" && mi.IsGenericMethod)?.MakeGenericMethod(source.ElementType);
var methodExpression = Expression.Call(null, methodInfo, sourceExpression, propertyExpression, predicateTypeExpression, valueExpression);
//var methodException = Expression.Call(null, "Wherea", new Type[] { source.ElementType }, sourceExpression, propertyExpression, predicateTypeExpression, valueExpression);
return(Expression.Lambda <Func <IQueryable> >(methodExpression).Compile().Invoke());
}
public void AddOrUpdateSingleRootPredicate(SentenceElement candidate, PredicateType type)
{
var existingPredicate = All.
FindAll(x => x.PredicateType == PredicateType.Predicate || x.PredicateType == PredicateType.Phantom).
FindAll(x => x.Id == candidate?.Id);
if (existingPredicate.Count > 0) return;
Log.InfoFormat($"Актуализация: добаляем новое корневое сказуемое: Id = {candidate.Id}; Text = {candidate.Text}");
Items.Add(new List<PredicatePartHelperObject>()
{
new PredicatePartHelperObject(
candidate.GUID, candidate.Text, candidate.Id, candidate.Order, -1,
PredicateType.Predicate.ToString(), -1, 0, PredicatePartType.Root.ToString(), string.Empty,
false)
}
);
}
public static string ToSQL(this PredicateType condition)
{
switch (condition)
{
case PredicateType.LessThan: return("<");
case PredicateType.GreaterThan: return(">");
case PredicateType.Equal: return("=");
case PredicateType.NotEqual: return("<>");
case PredicateType.GreaterThanEqual: return(">=");
case PredicateType.LessThanEqual: return("<=");
default: throw new ArgumentException(nameof(condition));
}
}
/// <summary>
/// Generate the FiletrPredicates for StronglyTyped
/// </summary>
/// <param name="value"></param>
/// <param name="filterType"></param>
/// <param name="predType"></param>
/// <returns></returns>
private FilterPredicate GetFilterPredicates(object value, FilterType filterType, PredicateType predType)
{
return(new FilterPredicate()
{
FilterBehavior = FilterBehavior.StronglyTyped,
FilterType = filterType,
FilterValue = value,
IsCaseSensitive = false,
PredicateType = predType
});
}
internal UnaryPredicate(PredicateType predicateType, TypeUsage resultType, Predicate argument)
: base(predicateType, resultType)
{
_argument = argument;
}
/// <summary>
/// Compare
/// </summary>
/// <param name="il"></param>
/// <param name="pred"></param>
/// <returns></returns>
public static ILGenerator Cmp(this ILGenerator il, PredicateType pred)
{
switch (pred)
{
case PredicateType.Equal:
return il.Ceq();
case PredicateType.GreaterThan:
return il.Cgt();
case PredicateType.GreaterThanOrEqual:
return il.Cge();
case PredicateType.LessThan:
return il.Clt();
case PredicateType.LessThanOrEqual:
return il.Cle();
case PredicateType.NotEqual:
return il.Cne();
case PredicateType.IsFalse:
return il.Cfalse();
case PredicateType.IsTrue:
return il.Ctrue();
default:
throw new ArgumentException(@"Invalid Predicate Type", "pred");
}
}
/// <summary>
///
/// </summary>
/// <param name="mappingName">Dto name to create the query</param>
/// <param name="filterValue">Value to filter</param>
/// <param name="predicateType">Specify if the predicate is and/or/not</param>
public QueryFilter(string mappingName, object filterValue, PredicateType predicateType)
{
this.mappingName = mappingName;
this.filterValue = filterValue;
this.predicateType = predicateType;
}
public Predicate(PredicateType predicateType, string value)
{
PredicateType = predicateType;
Value = value;
}
/// <summary>
/// Gets the type of the predicate.
/// </summary>
/// <param name="filterType">Type of the filter.</param>
/// <returns></returns>
internal static PredicateType GetPredicateType(String filterType)
{
PredicateType predicate = (PredicateType)Enum.Parse(typeof(PredicateType), filterType, true);
return(predicate);
}
public static ILGenerator cmp(this ILGenerator il, PredicateType pred)
{
switch (pred)
{
case PredicateType.Equal:
return il.ceq();
case PredicateType.GreaterThan:
return il.cgt();
case PredicateType.GreaterThanOrEqual:
return il.cge();
case PredicateType.LessThan:
return il.clt();
case PredicateType.LessThanOrEqual:
return il.cle();
case PredicateType.NotEqual:
return il.cne();
case PredicateType.IsFalse:
return il.cne();
case PredicateType.IsTrue:
return il.cne();
default:
throw AssertionHelper.Fail();
}
}
/// <summary> /// 创建谓词关系 /// </summary> /// <param name="predicateType">关系的类型</param> /// <param name="left">左语句</param> /// <param name="right">右语句</param> /// <returns></returns> internal abstract String CreatePredicate(PredicateType predicateType, String left, String right);
void IPredicate.AddPredicate(PredicateType predicateType, DbNode sentence)
{
_predicates.Add(new Predicate(this, predicateType, true, LogicalOperator.And, (ISemantic)sentence));
}
