private static bool IsCollectionProperty(PropertyReference prop) { return(char.IsUpper(prop.Name[0])); }
public virtual void Visit(PropertyReference op) { WriteAlias(op.Table); WriteIdentifier(op.Name); }
private IExpression ProcessFilter(XElement elem, FilterSettings settings, PropertyReference prop) { var elemName = elem.Name.LocalName.ToLowerInvariant(); switch (elemName) { case "property": return(settings.ItemCallback(elem.Attribute("query_items_xpath")?.Value) .GetProperty(new[] { elem.Attribute("name")?.Value })); case "constant": if (long.TryParse(elem.Value, out var lng) || double.TryParse(elem.Value, out var dbl) || DateTime.TryParse(elem.Value, out var date)) { return(new ObjectLiteral(elem.Value, prop, _context)); } else if (elem.Value.IndexOf('$') >= 0) { return(ReplaceParameters(elem.Value)); } else { return(new StringLiteral(elem.Value)); } case "count": var path = elem.Element("query_reference_path").Value.Split('/'); var result = new CountAggregate(); foreach (var table in path.Select(s => settings.Joins[s].Right)) { result.TablePath.Add(table); } return(result); case "eq": case "ne": case "gt": case "ge": case "lt": case "le": case "like": var left = ProcessFilter(elem.Elements().First(), settings, prop); var right = ProcessFilter(elem.Elements().ElementAt(1), settings, left as PropertyReference); if (left is CountAggregate cnt && right is IntegerLiteral iLit && Parents(elem) .All(p => string.Equals(p.Name.LocalName, "condition", StringComparison.OrdinalIgnoreCase) || string.Equals(p.Name.LocalName, "and", StringComparison.OrdinalIgnoreCase)) && ((elemName == "gt" && iLit.Value == 0) || (elemName == "ge" && iLit.Value == 1))) { var refPath = elem.Element("count").Element("query_reference_path").Value.Split('/'); foreach (var join in refPath.Select(s => settings.Joins[s])) { join.Type = JoinType.Inner; } return(IgnoreNode.Instance); } switch (elemName) { case "eq": return(new EqualsOperator() { Left = left, Right = right }.Normalize()); case "ne": return(new NotEqualsOperator() { Left = left, Right = right }.Normalize()); case "gt": return(new GreaterThanOperator() { Left = left, Right = right }.Normalize()); case "ge": return(new GreaterThanOrEqualsOperator() { Left = left, Right = right }.Normalize()); case "lt": return(new LessThanOperator() { Left = left, Right = right }.Normalize()); case "le": return(new LessThanOrEqualsOperator() { Left = left, Right = right }.Normalize()); case "like": right = AmlLikeParser.Instance.Parse(right.ToString()); return(new LikeOperator() { Left = left, Right = right }.Normalize()); default: throw new InvalidOperationException(); } case "null": return(new IsOperator() { Left = ProcessFilter(elem.Elements().First(), settings, prop), Right = IsOperand.Null }.Normalize()); case "and": case "or": var children = elem.Elements() .Select(e => ProcessFilter(e, settings, prop)) .ToArray(); if (children.Length < 1) { throw new InvalidOperationException(); } else if (children.Length == 1) { return(children[0]); } else if (string.Equals(elem.Name.LocalName, "and", StringComparison.OrdinalIgnoreCase)) { var expr = new AndOperator() { Left = children[0], Right = children[1] }.Normalize(); for (var i = 2; i < children.Length; i++) { expr = new AndOperator() { Left = expr, Right = children[i] }.Normalize(); } return(expr); } else if (string.Equals(elem.Name.LocalName, "or", StringComparison.OrdinalIgnoreCase)) { var expr = new OrOperator() { Left = children[0], Right = children[1] }.Normalize(); for (var i = 2; i < children.Length; i++) { expr = new OrOperator() { Left = expr, Right = children[i] }.Normalize(); } return(expr); } break; case "not": return(new NotOperator() { Arg = ProcessFilter(elem.Elements().First(), settings, prop) }.Normalize()); case "condition": return(ProcessFilter(elem.Elements().First(), settings, prop)); } throw new InvalidOperationException(); }
public virtual void Visit(PropertyReference op) { }
public void Visit(PropertyReference op) { _conditionWriter.WriteStartElement("property"); _conditionWriter.WriteAttributeString("name", op.Name); _conditionWriter.WriteEndElement(); }
void IExpressionVisitor.Visit(PropertyReference op) { _clone = Clone(op); }
public ObjectLiteral(object value, PropertyReference prop, IServerContext context) { Context = context; TypeProvider = prop; Value = value; }
internal IExpression Parse(QueryItem table, IPropertyDefinition prop, string value, Condition condition = Condition.Undefined) { var propRef = new PropertyReference(prop.NameProp().Value ?? prop.KeyedName().Value ?? prop.IdProp().KeyedName().Value, table); var meta = prop.Metadata(); if (meta.DataType().Value == "item") { propRef = new PropertyReference("keyed_name", propRef.GetOrAddTable(table.Context)); } var expressions = new List <IExpression>(); var values = default(IEnumerable <string>); switch (condition) { case Condition.Undefined: case Condition.Equal: case Condition.NotEqual: case Condition.Like: case Condition.NotLike: values = SplitOr(value); break; default: values = new[] { value }; break; } foreach (var val in values) { if ((val == "*" || (val == "%" && String.IsPercentWildcard)) && condition == Condition.Undefined) { expressions.Add(new LikeOperator() { Left = propRef, Right = AmlLikeParser.Instance.Parse("%") }.Normalize()); } else if (condition == Condition.IsNotNull) { return(new IsOperator() { Left = propRef, Right = IsOperand.NotNull }.Normalize()); } else if (condition == Condition.IsNull) { return(new IsOperator() { Left = propRef, Right = IsOperand.Null }.Normalize()); } else { switch (meta.DataType().AsString("").ToLowerInvariant()) { case "boolean": expressions.Add(Boolean.Parse(propRef, val, condition)); break; case "date": expressions.Add(Date.Parse(propRef, val, condition)); break; case "decimal": case "float": case "integer": expressions.Add(Number.Parse(propRef, val, condition)); break; default: expressions.Add(String.Parse(propRef, val, condition)); break; } } } var addNotOperator = expressions.Count > 0 && expressions.All(e => e is NotOperator); if (addNotOperator) { expressions = expressions.Cast <NotOperator>().Select(n => n.Arg).ToList(); } var result = default(IExpression); if (expressions.Count > 0 && expressions.All(e => e is EqualsOperator eq && eq.Right is IOperand)) { var list = new ListExpression(); foreach (var op in expressions.Cast <EqualsOperator>().Select(e => (IOperand)e.Right)) { list.Values.Add(op); } result = new InOperator() { Left = propRef, Right = list }.Normalize(); }