private ParameterExpression AddAsQueryParameter(Expression node) { LinqPathProvider.GetValueFromExpressionWithoutConversion(node, out var value); var queryParameter = _documentQuery.ProjectionParameter(value); return(Expression.Parameter(node.Type, queryParameter)); }
private void AddSelectMethod(MethodCallExpression call) { if (call.Arguments.Count == 0) { AddSelectField(call.Method.Name); return; } Debug.Assert(call.Arguments.Count == 1 && call.Method.Name.Equals(nameof(AggregationType.Percentile)), "wrong number of arguments passed to method " + call.Method.Name); object value; if (call.Arguments[0] is ConstantExpression constant) { value = constant.Value; } else { LinqPathProvider.GetValueFromExpressionWithoutConversion(call.Arguments[0], out value); } if (!(value is double d)) { throw new InvalidOperationException("Invalid Select argument " + call.Arguments[0]); } AddSelectField(call.Method.Name, d); }
private static string GroupByWith(ref MethodCallExpression callExpression) { if (callExpression.Method.Name != nameof(ITimeSeriesAggregationOperations.WithOptions)) { return(null); } if (callExpression.Method.DeclaringType != typeof(ITimeSeriesAggregationOperations)) { ThrowInvalidMethodArgument(callExpression, nameof(ITimeSeriesQueryable.GroupBy)); return(null); } if (!(callExpression.Object is MethodCallExpression inner)) { ThrowInvalidMethodArgument(callExpression, nameof(ITimeSeriesQueryable.GroupBy)); return(null); } LinqPathProvider.GetValueFromExpressionWithoutConversion(callExpression.Arguments[0], out var value); if (!(value is TimeSeriesAggregationOptions options)) { ThrowInvalidMethodArgument(callExpression.Arguments[0], nameof(ITimeSeriesAggregationOperations.WithOptions)); return(null); } callExpression = inner; if (options.Interpolation == InterpolationType.None) { return(null); } return($"with interpolation({options.Interpolation})"); }
private string GetDateValue(Expression exp) { if (exp is ConstantExpression constant) { if (constant.Value is DateTime dt) { return(dt.EnsureUtc().GetDefaultRavenFormat()); } return(constant.Value.ToString()); } if (exp is ParameterExpression p) { Parameters ??= new List <string>(); Parameters.Add(p.Name); return(p.Name); } LinqPathProvider.GetValueFromExpressionWithoutConversion(exp, out var value); if (value is string s) { return(s); } if (!(value is DateTime d)) { throw new InvalidOperationException("Invalid from/to arguments" + exp); } return(d.EnsureUtc().GetDefaultRavenFormat()); }
public AbstractFilesQuery(InMemoryFilesSessionOperations theSession, IAsyncFilesCommands commands) { this.conventions = theSession == null ? new FilesConvention() : theSession.Conventions; this.linqPathProvider = new LinqPathProvider(conventions); this.Session = theSession; this.Commands = commands; }
private void Scale(Expression expression) { if (expression.Type != typeof(double)) { throw new InvalidOperationException($"Invalid argument in method '{nameof(ITimeSeriesQueryable.Scale)}'. " + $"Expected argument of type 'double' but got : '{expression.Type}'"); } LinqPathProvider.GetValueFromExpressionWithoutConversion(expression, out var value); _scale = $" scale {value}"; }
private void TimeSeriesCall(MethodCallExpression mce) { if (mce.Arguments.Count == 1) { _src = GetNameFromArgument(mce.Arguments[0]); } else { var sourceAlias = LinqPathProvider.RemoveTransparentIdentifiersIfNeeded(mce.Arguments[0].ToString()); Parameters = new List <string>(); if (_providerProcessor.FromAlias == null) { _providerProcessor.AddFromAlias(sourceAlias); Parameters.Add(sourceAlias); } else { if (mce.Arguments[0] is ParameterExpression) { Parameters.Add(sourceAlias); } else { Parameters.Add(_providerProcessor.FromAlias); if (sourceAlias != _providerProcessor.FromAlias) { Parameters.Add(sourceAlias); } } } _src = GetNameFromArgument(mce.Arguments[1]); if (mce.Arguments[1] is ParameterExpression == false) { _src = $"{sourceAlias}.{_src}"; } if (mce.Arguments.Count == 4) { Between(mce); } } if (_whereVisitor?.Parameters == null) { return; } Parameters ??= new List <string>(); Parameters.AddRange(_whereVisitor.Parameters); }
private void Offset(Expression expression) { if (expression.Type != typeof(TimeSpan)) { throw new InvalidOperationException($"Invalid argument in method '{nameof(ITimeSeriesAggregationQueryable.Offset)}'. " + $"Expected argument of type 'TimeSpan' but got : '{expression.Type}'"); } LinqPathProvider.GetValueFromExpressionWithoutConversion(expression, out var ts); _offset = $" offset '{ts}'"; }
internal LinqPathProvider.Result TranslateCustomQueryExpression(LinqPathProvider provider, Expression expression) { var member = GetMemberInfoFromExpression(expression); CustomQueryTranslator translator; if (!customQueryTranslators.TryGetValue(member, out translator)) { return(null); } return(translator.Invoke(provider, expression)); }
public static LinqPathProvider.Result OffsetDateTimeToInstantTranslator(LinqPathProvider provider, Expression expression) { // Just send the parent path back since we are storing it as a DateTimeOffset var exp = (MethodCallExpression)expression; var parent = provider.GetPath(exp.Object); return(new LinqPathProvider.Result { MemberType = exp.Method.ReturnType, IsNestedPath = false, Path = parent.Path }); }
public static LinqPathProvider.Result ZonedDateTimeTimeToInstantTranslator(LinqPathProvider provider, Expression expression) { // Change the ZonedDateTime.ToInstant() method to use our .OffsetDateTime property instead. var exp = (MethodCallExpression)expression; var parent = provider.GetPath(exp.Object); return(new LinqPathProvider.Result { MemberType = typeof(DateTimeOffset), IsNestedPath = false, Path = parent.Path + ".OffsetDateTime" }); }
public static LinqPathProvider.Result OffsetDateTimeLocalDateTimeTranslator(LinqPathProvider provider, Expression expression) { // Change the OffsetDateTime.LocalDateTime property to the DateTimeOffset.DateTime property var exp = (MemberExpression)expression; var parent = provider.GetPath(exp.Expression); return(new LinqPathProvider.Result { MemberType = typeof(DateTime), IsNestedPath = false, Path = parent.Path + ".DateTime" }); }
private static string TryGetValueFromArgument(Expression argument, bool groupByArgument) { try { if (LinqPathProvider.GetValueFromExpressionWithoutConversion(argument, out object value) == false) { throw new NotSupportedException("Unsupported node type: " + argument.NodeType); } return(value.ToString()); } catch (Exception e) { ThrowFailedToEvaluateArgument(argument, groupByArgument, e); return(null); } }
private void GroupBy(Expression expression) { string timePeriod; string with = null; string groupByTag = null; switch (expression) { case ConstantExpression constantExpression: if (constantExpression.Value is Action <ITimePeriodBuilder> action) { timePeriod = GetGroupByArgsFromAction(action, out with, out groupByTag); break; } timePeriod = constantExpression.Value.ToString(); break; case LambdaExpression lambda: { if (!(lambda.Body is MethodCallExpression methodCall) || lambda.Type != typeof(Action <ITimePeriodBuilder>)) { ThrowInvalidMethodArgument(lambda, nameof(ITimeSeriesQueryable.GroupBy)); return; } var typedLambda = Expression.Lambda <Action <ITimePeriodBuilder> >(methodCall, lambda.TailCall, lambda.Parameters); var compiledAction = typedLambda.Compile(); timePeriod = GetGroupByArgsFromAction(compiledAction, out with, out groupByTag); break; } default: if (LinqPathProvider.GetValueFromExpressionWithoutConversion(expression, out object value) == false) { ThrowFailedToEvaluateArgument(expression, groupBy: true, new NotSupportedException("Unsupported node type: " + expression.NodeType)); } GroupBy(Expression.Constant(value)); return; } _groupBy = $" group by '{timePeriod}' {groupByTag} {with}"; }
private string GetNameFromArgument(Expression argument) { if (argument is ConstantExpression constantExpression) { return(constantExpression.Value.ToString()); } if (JavascriptConversionExtensions.IsWrappedConstantExpression(argument)) { LinqPathProvider.GetValueFromExpressionWithoutConversion(argument, out var value); return(value.ToString()); } if (argument is ParameterExpression p) { Parameters ??= new List <string>(); Parameters.Add(p.Name); return(p.Name); } throw new InvalidOperationException("Invalid TimeSeries argument " + argument); }
public override void ConvertToJavascript(JavascriptConversionContext context) { var methodCallExpression = context.Node as MethodCallExpression; var nameAttribute = methodCallExpression? .Method .GetCustomAttributes(typeof(JavascriptMethodNameAttribute), false) .OfType <JavascriptMethodNameAttribute>() .FirstOrDefault(); if (nameAttribute == null) { return; } context.PreventDefault(); var javascriptWriter = context.GetWriter(); javascriptWriter.Write("."); javascriptWriter.Write(nameAttribute.Name); javascriptWriter.Write("("); var args = new List <Expression>(); foreach (var expr in methodCallExpression.Arguments) { var expression = expr as NewArrayExpression; if (expression != null) { args.AddRange(expression.Expressions); } else { args.Add(expr); } } for (var i = 0; i < args.Count; i++) { var name = $"arg_{Parameters.Count}_{Suffix}"; if (i != 0) { javascriptWriter.Write(", "); } javascriptWriter.Write("args."); javascriptWriter.Write(name); object val; if (LinqPathProvider.GetValueFromExpressionWithoutConversion(args[i], out val)) { Parameters[name] = val; } } if (nameAttribute.PositionalArguments != null) { for (int i = args.Count; i < nameAttribute.PositionalArguments.Length; i++) { if (i != 0) { javascriptWriter.Write(", "); } context.Visitor.Visit(Expression.Constant(nameAttribute.PositionalArguments[i])); } } javascriptWriter.Write(")"); }
public TimeSeriesQueryBuilder(IAbstractDocumentQuery <TEntity> abstractDocumentQuery, LinqPathProvider linqPathProvider) { _documentQuery = abstractDocumentQuery; _linqPathProvider = linqPathProvider; }
internal TimeSeriesQueryVisitor(IAbstractDocumentQuery <T> documentQuery, LinqPathProvider linqPathProvider) { _documentQuery = documentQuery; _linqPathProvider = linqPathProvider; }