private ResultSetBuilder VisitBinary(Expression expression) { switch (expression.NodeType) { case ExpressionType.Equal: case ExpressionType.NotEqual: return(EvaluateEquals(expression)); case ExpressionType.Or: case ExpressionType.And: case ExpressionType.OrElse: case ExpressionType.AndAlso: return(EvaluateLogical(expression)); case ExpressionType.GreaterThan: case ExpressionType.GreaterThanOrEqual: case ExpressionType.LessThan: case ExpressionType.LessThanOrEqual: return(EvaluateCompare(expression)); default: throw QueryExceptionExtensions.NotSupported( "Binary operation {0} cannot be bound to Journal operation", expression.NodeType); } }
private QueryRowsResult BindPostResult(IEnumerable <long> rowIds) { var hadNonTimestampOrder = false; foreach (var tranform in _directExpressions) { switch (tranform.Expression) { case EJournalExpressionType.Single: return(new QueryRowsResult(rowIds.Single())); case EJournalExpressionType.First: return(new QueryRowsResult(rowIds.First())); case EJournalExpressionType.Last: return(new QueryRowsResult(rowIds.Last())); case EJournalExpressionType.Reverse: if (hadNonTimestampOrder) { rowIds = rowIds.Reverse(); } break; case EJournalExpressionType.LongCount: case EJournalExpressionType.Count: return(new QueryRowsResult(rowIds, tranform.Expression)); case EJournalExpressionType.OrderByDescending: case EJournalExpressionType.OrderBy: if (tranform.Column.ColumnID != Metadata.TimestampColumnID) { hadNonTimestampOrder = true; rowIds = BindOrderBy(rowIds, tranform); } break; case EJournalExpressionType.Take: rowIds = rowIds.Take(tranform.Count); break; case EJournalExpressionType.Skip: rowIds = rowIds.Skip(tranform.Count); break; case EJournalExpressionType.FirstOrDefault: return(new QueryRowsResult(rowIds.FirstOrDefault())); case EJournalExpressionType.LastOrDefault: return(new QueryRowsResult(rowIds.LastOrDefault())); default: throw QueryExceptionExtensions.NotSupported( "Expression {0} is not expected to be post operation", tranform.Expression); } } return(new QueryRowsResult(rowIds)); }
public static string GetMemberName(MemberExpression memEx, Type journalType) { if (memEx.Member.DeclaringType == null || !memEx.Member.DeclaringType.IsAssignableFrom(journalType)) { throw QueryExceptionExtensions.NotSupported("Expressions of type \"column\" == value " + "where column is an NFSdb property " + "name are supported only"); } return(memEx.Member.Name); }
private Expression BindLatestBy(Expression ex1, LambdaExpression lambda) { var prop = lambda.Body as MemberExpression; if (prop != null) { return(new LatestBySymbolExpression(prop.Member.Name, Visit(ex1))); } throw QueryExceptionExtensions.NotSupported("LatestBy is only supported with property" + " expression, but instead had '{0}'", lambda); }
private TT GetConstant <TT>(Expression expression) { var c = expression as ConstantExpression; if (c != null) { if (c.Type == typeof(TT)) { return((TT)c.Value); } } throw QueryExceptionExtensions.NotSupported("Expected constant expression of type {0} but got {1}", typeof(T).Name, expression); }
private Expression BindPostResult(Type resultType, ReadOnlyCollection <Expression> arguments, EJournalExpressionType expressionType) { if (resultType != typeof(T)) { throw QueryExceptionExtensions.NotSupported("{0} operation canonly be bound to JournalQueryable of {1} but used on {2}", expressionType, typeof(T).Name, resultType); } var source = arguments[0]; if (arguments.Count > 1) { var lambda = GetLambda(arguments[1]); return(new PostResultExpression(new FilterExpression(Visit(lambda.Body), Visit(source)), expressionType)); } return(new PostResultExpression(Visit(source), expressionType)); }
private Expression BindContains(Expression source, Expression match) { var constSource = source as ConstantExpression; if (constSource != null && !IsQuery(constSource)) { var stringEnum = constSource.Value as IEnumerable; if (stringEnum != null) { match = Visit(match); return(new SymbolContainsExpression(match, Expression.Constant(stringEnum))); } } throw QueryExceptionExtensions.NotSupported( "List.Contains, Array.Contains allowed only. Unable to execute Contains on {0}.", constSource); }
private Expression BindUnion(Type type, Expression expression1, Expression expression2) { if (typeof(IQueryable <T>).IsAssignableFrom(type)) { var mc1 = expression1 as MethodCallExpression; var mc2 = expression2 as MethodCallExpression; if (mc1 != null && mc2 != null) { if (IsQuery(mc1.Arguments[0]) && IsQuery(mc2.Arguments[0])) { return(new UnionExpression(Visit(mc1), Visit(mc2))); } } } throw QueryExceptionExtensions.NotSupported("Union of 2 journal queriables supported. " + "Attempted to join '{0}' with '{1}' instead.", expression1, expression2); }