public static FilterDefinition <TDocument> NotDeactivated <TDocument, TItem>(FilterDefinitionBuilder <TDocument> builder, Expression <Func <TDocument, IEnumerable <TItem> > > acessor, DateTime?dateTime = null) where TItem : IActivationAware { var twoBuilder = new FilterDefinitionBuilder <TItem>(); if (!dateTime.HasValue) { dateTime = DateTime.UtcNow; } return(builder.Or ( builder.Not ( builder.ElemMatch ( acessor, twoBuilder.Exists ( t => t.DeactivationDate ) ) ), builder.ElemMatch ( acessor, twoBuilder.Gt ( t => t.DeactivationDate, dateTime.Value ) ) )); }
public override FilterDefinition <T> VisitIntOp([NotNull] FilterParser.IntOpContext context) { string id = context.ID().GetText(); string integer = context.INT().GetText(); var op = context.op.Type; switch (op) { case FilterParser.EQ: return(_builder.Eq(id, integer)); case FilterParser.NE: return(_builder.Ne(id, integer)); case FilterParser.GT: return(_builder.Gt(id, integer)); case FilterParser.GE: return(_builder.Gte(id, integer)); case FilterParser.LT: return(_builder.Lt(id, integer)); case FilterParser.LE: return(_builder.Lte(id, integer)); default: throw new InvalidOperationException($"Invalid StringOp {context.GetText()}"); } }
//提交 private void CommitTransfer(TransactionDocument txn, TimeSpan maxTxnTime) { DateTime now = DateTime.Now.ToUniversalTime(); DateTime cutOff = now - maxTxnTime; //更新事务文档 FilterDefinitionBuilder <TransactionDocument> filterBuilder = Builders <TransactionDocument> .Filter; FilterDefinition <TransactionDocument> filter1 = filterBuilder.Eq(m => m._id, txn._id); FilterDefinition <TransactionDocument> filter2 = filterBuilder.Gt(m => m.Ts, cutOff); FilterDefinition <TransactionDocument> filter = filterBuilder.And(new FilterDefinition <TransactionDocument>[] { filter1, filter2 }); var update = Builders <TransactionDocument> .Update.Set(m => m.State, "commit"); UpdateResult updateResult = mongoDBService.DocumentUpdate(TransactionCollectionName, filter, update); bool isSuccess = updateResult.ModifiedCount > 0 && updateResult.ModifiedCount == updateResult.MatchedCount ? true : false; if (!isSuccess) { throw new Exception("修改事务文档失败"); } else { RetireTransaction(txn); } }
public async Task <IAsyncCursor <BsonDocument> > GetCursor(ResumeToken resumeToken, IEnumerable <string> collections, CancellationToken cancellationToken) { BsonValue ts; if (resumeToken.Token != null) { ts = resumeToken.Token["ts"]; } else { var operation = await operations .Find(new BsonDocument()) .Sort(Builders <BsonDocument> .Sort.Descending("$natural")) .FirstAsync(cancellationToken); ts = operation["ts"]; } var filter = builder.And( builder.In("op", new[] { "i", "u", "d" }), builder.Gt("ts", ts), builder.In("ns", collections.Select(collectionName => $"{databaseName}.{collectionName}")), builder.Exists("fromMigrate", false) ); var options = new FindOptions <BsonDocument> { CursorType = CursorType.TailableAwait, NoCursorTimeout = true, OplogReplay = true }; return(await operations.FindAsync(filter, options, cancellationToken)); }
public async Task WhenGet_Grade_Score_Greater_Than_Returns_RestaurantList() { var collection = _database.GetCollection<BsonDocument>("restaurants"); var builder = new FilterDefinitionBuilder<BsonDocument>(); var filter = builder.Gt("grades.score", 20); var result = await collection.Find(filter).ToListAsync(); Assert.AreEqual(6332, result.Count()); }
public AggregateResponce <Book> GetBooksInStock(BooksInStockQueryParams queryParams) { if (queryParams == null) { throw new ArgumentNullException(nameof(queryParams)); } var response = new AggregateResponce <Book>(); var filter = _filter.Gt(BooksTableFieldNames.Count, 1); var filteredResult = _context.Books.Find(filter).Limit(queryParams.GetLimitedItemsNumber); if (queryParams.ShowOnlyTitle) { filteredResult = filteredResult.Project(Builders <BsonDocument> .Projection.Include(BooksTableFieldNames.Name)); } if (queryParams.SortByTitle) { var sortFilter = new BsonDocument().Add(BooksTableFieldNames.Name, 1); filteredResult = filteredResult.Sort(sortFilter); } if (!queryParams.GetOnlyCount) { if (queryParams.ShowOnlyTitle) { response.Titles = filteredResult.ToEnumerable() .Select(doc => doc[BooksTableFieldNames.Name].AsString) .ToList(); } else { response.Items = filteredResult.ToEnumerable() .Select(BookConverter.ConvertDocumentToBook) .ToList(); } } response.AgregateValue = filteredResult.ToEnumerable().Count(); return(response); }
public List <Message> FindMessageByLastDate(ChatRoom chatRoom, long longLastDate) { var builder = new FilterDefinitionBuilder <Message>(); var filterChat = builder.Eq("ChatRoom", chatRoom.ToRef()); var filterDate = builder.Gt("Date", longLastDate); var messages = messageDao.Find.WhenMatch(filterChat & filterDate, new PageDefinition("Date", false)); return(new List <Message>(messages)); }
/* 输入:起止时间 * 输出:时间段内数据总数 * */ public int GetDeviceAlarmInfoNumberByTime(DateTime startTime, DateTime endTime) { FilterDefinitionBuilder <AlarmInfoModel> builderFilter = Builders <AlarmInfoModel> .Filter; FilterDefinition <AlarmInfoModel> filter = builderFilter.And( builderFilter.Gt("Timestamp", startTime), builderFilter.Lt("Timestamp", endTime)); return((int)_alarmInfo.Find(filter).CountDocuments()); }
public override FilterDefinition <T> Visit(CompareFilter <ClrValue> nodeIn, None args) { var propertyName = nodeIn.Path.ToString(); var value = nodeIn.Value.Value; switch (nodeIn.Operator) { case CompareOperator.Empty: return(Filter.Or( Filter.Exists(propertyName, false), Filter.Eq <object?>(propertyName, null), Filter.Eq <object?>(propertyName, string.Empty), Filter.Size(propertyName, 0))); case CompareOperator.Exists: return(Filter.And( Filter.Exists(propertyName, true), Filter.Ne <object?>(propertyName, null))); case CompareOperator.Matchs: return(Filter.Regex(propertyName, BuildMatchRegex(nodeIn))); case CompareOperator.StartsWith: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => "^" + s))); case CompareOperator.Contains: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s))); case CompareOperator.EndsWith: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s + "$"))); case CompareOperator.Equals: return(Filter.Eq(propertyName, value)); case CompareOperator.GreaterThan: return(Filter.Gt(propertyName, value)); case CompareOperator.GreaterThanOrEqual: return(Filter.Gte(propertyName, value)); case CompareOperator.LessThan: return(Filter.Lt(propertyName, value)); case CompareOperator.LessThanOrEqual: return(Filter.Lte(propertyName, value)); case CompareOperator.NotEquals: return(Filter.Ne(propertyName, value)); case CompareOperator.In: return(Filter.In(propertyName, ((IList)value !).OfType <object>())); } throw new NotSupportedException(); }
public FilterDefinition <IUser> ConcatenateFilter(List <SearchFilter> filters, FilterDefinitionBuilder <IUser> builder, FilterDefinition <IUser> filter, int i) { if (filters[i] is SearchFilter) { switch (filters[i].FieldName) { case "_id": filter = filter & builder.Ne("_id", ((ValueSearchFilter <string>)filters[i]).Value); break; case "UserType": filter = filter & builder.Eq(filters[i].FieldName, ((ValueSearchFilter <string>)filters[i]).Value); break; case "Gender": if (((ValueSearchFilter <int>)filters[i]).Value != 2) { filter = filter & builder.Eq(filters[i].FieldName, ((ValueSearchFilter <int>)filters[i]).Value); } break; case "Location": break; case "Expertise": //ExpertiseEntityService expertiseService = new ExpertiseEntityService(); //IExpertise expertiseVal = await expertiseService.GetExpertiseById(((ValueSearchFilter<string>)filters[i]).Value); //expertiseVal.ExpertiseName filter = filter & builder.Eq(filters[i].FieldName, ((ValueSearchFilter <string>)filters[i]).Value); break; case "Reputation": filter = filter & builder.Eq(filters[i].FieldName, ((ValueSearchFilter <int>)filters[i]).Value); break; case "Showers": filter = filter & builder.Eq(filters[i].FieldName, ((ValueSearchFilter <bool>)filters[i]).Value); break; case "ParkingLot": filter = filter & builder.Eq(filters[i].FieldName, ((ValueSearchFilter <bool>)filters[i]).Value); break; } } else { filter = filter & builder.Lte(filters[i].FieldName, ((RangeSearchFilter)filters[i]).ToValue) & builder.Gt(filters[i].FieldName, ((RangeSearchFilter)filters[i]).FromValue); } return(filter); }
public static FilterDefinition <TDocument> NotDeactivated <TDocument>(FilterDefinitionBuilder <TDocument> builder, DateTime?dateTime = null) where TDocument : IActivationAware { if (!dateTime.HasValue) { dateTime = DateTime.UtcNow; } return(builder.Or( builder.Not( builder.Exists(doc => doc.DeactivationDate) ), builder.Gt(doc => doc.DeactivationDate, dateTime.Value) )); }
public void AggregateAllFourOrMoreStarsRestaurants() { filterBuilder = Builders <Restaurant> .Filter; var starFilter = filterBuilder.Gt("Stars", 3); var projectBuilder = Builders <Restaurant> .Projection; var projection = projectBuilder.Include("Name").Include("Stars").Exclude("_id"); var restaurants = collection.Aggregate().Match(starFilter).Project(projection).ToList(); foreach (var restaurant in restaurants) { Console.WriteLine(restaurant); } }
public IPageList <T> Query <T>(FilterCondition filter) where T : IBaseObject { this.CheckType <T>(); IMongoCollection <T> collection = this.GetCollection <T>(); FilterDefinitionBuilder <T> filter2 = Builders <T> .Filter; SortDefinitionBuilder <T> sort = Builders <T> .Sort; FilterDefinition <T> filterDefinition = filter2.Empty; foreach (FilterValue current in filter.Fields) { switch (current.FilterType) { case FilterType.LTE: filterDefinition &= filter2.Lte <object>(current.FieldName, current.Value); break; case FilterType.GTE: filterDefinition &= filter2.Gte <object>(current.FieldName, current.Value); break; case FilterType.LT: filterDefinition &= filter2.Lt <object>(current.FieldName, current.Value); break; case FilterType.GT: filterDefinition &= filter2.Gt <object>(current.FieldName, current.Value); break; case FilterType.EQ: goto IL_12E; case FilterType.Like: filterDefinition &= filter2.Regex(current.FieldName, new Regex(current.Value.ToString(), RegexOptions.IgnoreCase)); break; default: goto IL_12E; } continue; IL_12E: filterDefinition &= filter2.Eq <object>(current.FieldName, current.Value); } Task <long> task = collection.CountAsync(filterDefinition, null, default(CancellationToken)); SortDefinition <T> sort2 = (filter.Direction == OrderDirection.DESC) ? sort.Descending(filter.OrderBy) : sort.Ascending(filter.OrderBy); Task <List <T> > task2 = collection.Find(filterDefinition, null).Sort(sort2).Limit(new int?(filter.PageSize)).Skip(new int?((filter.PageIndex - 1) * filter.PageSize)).ToListAsync(default(CancellationToken)); return(new PageList <T>(task2.Result, filter.PageIndex, filter.PageSize, (int)task.Result)); }
public Puzzle GetOneRandomly(List <int> excludedIds, string variant, int?userId, double nearRating = 1500) { FilterDefinitionBuilder <Puzzle> filterBuilder = Builders <Puzzle> .Filter; FilterDefinition <Puzzle> filter = filterBuilder.Nin("_id", excludedIds) & filterBuilder.Eq("inReview", false) & filterBuilder.Eq("approved", true); if (variant != "Mixed") { filter &= filterBuilder.Eq("variant", variant); } if (userId.HasValue) { filter &= filterBuilder.Ne("author", userId.Value) & filterBuilder.Nin("reviewers", new int[] { userId.Value }); } FilterDefinition <Puzzle> lteFilter = filter; FilterDefinition <Puzzle> gtFilter = filter; bool higherRated = RandomBoolean(); gtFilter &= filterBuilder.Gt("rating.value", nearRating); lteFilter &= filterBuilder.Lte("rating.value", nearRating); var foundGt = puzzleCollection.Find(gtFilter); var foundLte = puzzleCollection.Find(lteFilter); if (foundGt == null && foundLte == null) { return(null); } SortDefinitionBuilder <Puzzle> sortBuilder = Builders <Puzzle> .Sort; foundGt = foundGt.Sort(sortBuilder.Ascending("rating.value")).Limit(1); foundLte = foundLte.Sort(sortBuilder.Descending("rating.value")).Limit(1); Puzzle oneGt = foundGt.FirstOrDefault(); Puzzle oneLte = foundLte.FirstOrDefault(); if (oneGt == null) { return(oneLte); } else if (oneLte == null) { return(oneGt); } else { return(RandomBoolean() ? oneGt : oneLte); } }
public static FilterDefinition <TDocument> NotDeactivated <TDocument, TItem>(FilterDefinitionBuilder <TDocument> builder, Expression <Func <TDocument, TItem> > acessor, DateTime?dateTime = null) where TItem : IActivationAware { if (!dateTime.HasValue) { dateTime = DateTime.UtcNow; } return(builder.Or ( builder.Not ( builder.Exists ( Expression.Lambda <Func <TDocument, object> > ( Expression.Convert ( Expression.Property ( acessor.Body, nameof(IActivationAware.DeactivationDate) ), typeof(object) ), acessor.Parameters ) ) ), builder.Gt ( Expression.Lambda <Func <TDocument, DateTime> > ( Expression.Convert ( Expression.Property ( acessor.Body, nameof(IActivationAware.DeactivationDate) ), typeof(DateTime) ), acessor.Parameters ), dateTime.Value ) )); }
public async Task FindUsingFilterDefinitionBuilder1Async(IMongoCollection <ClubMember> collection) { Console.WriteLine("Starting FindUsingFilterDefinitionBuilder1Async"); DateTime cutOffDate = DateTime.Now.AddYears(-5); FilterDefinitionBuilder <ClubMember> builder = Builders <ClubMember> .Filter; //A greater than filter. Selects where the MembershipDate is greater than the cutOffDate FilterDefinition <ClubMember> filterDefinition = builder.Gt("MembershipDate", cutOffDate.ToUniversalTime()); //DateTime is stored in BsonElement as a UTC value so need to convert List <ClubMember> membersList = await collection.Find(filterDefinition).SortBy(c => c.Lastname).ThenBy(c => c.Forename).ToListAsync(); Console.WriteLine("Finished FindUsingFilterDefinitionBuilder1Async"); Console.WriteLine("\r\nMembers who have joined in the last 5 years ..."); foreach (ClubMember clubMember in membersList) { ConsoleHelper.PrintClubMemberToConsole(clubMember); } }
protected override async Task Execute(CancellationToken cancellationToken) { var checkpoint = await checkpoints.Find(c => c.Name == name).FirstOrDefaultAsync(cancellationToken); if (checkpoint is null) { var @event = await events .Find(Builders <EventEnvelope> .Filter.In("event._t", handlers.Keys)) .Sort(Builders <EventEnvelope> .Sort.Descending(envelope => envelope.Timestamp)) .FirstOrDefaultAsync(cancellationToken); checkpoint = new Checkpoint { Name = name, Position = @event?.Timestamp ?? new BsonTimestamp(0, 0) }; await checkpoints.InsertOneAsync(checkpoint, cancellationToken : cancellationToken); } while (!cancellationToken.IsCancellationRequested) { await events .Find(filter.And( filter.In("event._t", handlers.Keys), filter.Gt(envelope => envelope.Timestamp, checkpoint.Position))) .Sort(Builders <EventEnvelope> .Sort.Ascending(envelope => envelope.Timestamp)) .ForEachAsync(async envelope => { if (handlers.TryGetValue(envelope.Event.GetType().Name, out var handler)) { if (!string.IsNullOrEmpty(envelope.CorrelationId)) { TraceContext.Set(envelope.CorrelationId, envelope.EventId); } await handler.Invoke(envelope.Event); } await SaveCheckpoint(checkpoint, envelope.Timestamp); }, cancellationToken); await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken); } }
public override FilterDefinition <T> Visit(FilterComparison nodeIn) { var propertyName = string.Join(".", nodeIn.Lhs); switch (nodeIn.Operator) { case FilterOperator.Empty: return(Filter.Or(Filter.Exists(propertyName, false), Filter.Eq(propertyName, default(T)), Filter.Eq(propertyName, string.Empty), Filter.Eq(propertyName, new T[0]))); case FilterOperator.StartsWith: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => "^" + s))); case FilterOperator.Contains: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s))); case FilterOperator.EndsWith: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s + "$"))); case FilterOperator.Equals: return(Filter.Eq(propertyName, nodeIn.Rhs.Value)); case FilterOperator.GreaterThan: return(Filter.Gt(propertyName, nodeIn.Rhs.Value)); case FilterOperator.GreaterThanOrEqual: return(Filter.Gte(propertyName, nodeIn.Rhs.Value)); case FilterOperator.LessThan: return(Filter.Lt(propertyName, nodeIn.Rhs.Value)); case FilterOperator.LessThanOrEqual: return(Filter.Lte(propertyName, nodeIn.Rhs.Value)); case FilterOperator.NotEquals: return(Filter.Ne(propertyName, nodeIn.Rhs.Value)); case FilterOperator.In: return(Filter.In(propertyName, ((IList)nodeIn.Rhs.Value).OfType <object>())); } throw new NotSupportedException(); }
public FilterDefinition <T> GetFromCompareType <T>(FilterCondition s) { FilterDefinitionBuilder <T> filter = Builders <T> .Filter; if (s.Value == null) { return(filter.Empty); } switch (s.CompareType) { case TableCompareType.EQ: return(filter.Eq(s.Key, s.Value)); case TableCompareType.GT: return(filter.Gt(s.Key, s.Value)); case TableCompareType.GTE: return(filter.Gte(s.Key, s.Value)); case TableCompareType.LT: return(filter.Lt(s.Key, s.Value)); case TableCompareType.LTE: return(filter.Lte(s.Key, s.Value)); case TableCompareType.NE: return(filter.Ne(s.Key, s.Value)); case TableCompareType.REGEX: { return(filter.Regex(s.Key, s.Value.ToString())); } case TableCompareType.TEXT: return(filter.Text(s.Value.ToString())); default: return(filter.Eq(s.Key, s.Value)); } }
static void ExecuteAggregationQuery(DateRange dr) { FilterDefinitionBuilder <BsonDocument> matchFilterDefinition = Builders <BsonDocument> .Filter; var filter = matchFilterDefinition.Eq("event_type", "Address_Contact_Change_Request_Event") & matchFilterDefinition.Gt("request_status_isodate", dr.Begin.ToString("o", CultureInfo.InvariantCulture)) & matchFilterDefinition.Lt("request_status_isodate", dr.End.ToString("o", CultureInfo.InvariantCulture)); var matchFilter = BsonDocument.Parse("{\"event_type\":\"Address_Contact_Change_Request_Event\",\"request_status_isodate\":{$ne:null}}"); var sortFilter = BsonDocument.Parse("{\"request_status_isodate\":-1}"); var groupByFilter = BsonDocument.Parse("{\"_id\":{\"agreement_id\":\"$agreement_id\"},\"events\":{ \"$push\":{ \"event\":\"$$CURRENT\"} }}"); var projectOp = BsonDocument.Parse("{\"events\":{\"$slice\":[\"$events\",1]}}"); var finalProjectOp = BsonDocument.Parse("{\"_id\":0,\"data\":\"$events.event\"}"); var docs = aggCollection .Aggregate() .Match(filter) .Sort(sortFilter) .Group(groupByFilter) .Project(projectOp) .Unwind("events") .Project(finalProjectOp) .ToList(); }
public override FilterDefinition <MongoContentEntity> Visit(BinaryOperatorNode nodeIn) { if (nodeIn.OperatorKind == BinaryOperatorKind.And) { return(Filter.And(nodeIn.Left.Accept(this), nodeIn.Right.Accept(this))); } if (nodeIn.OperatorKind == BinaryOperatorKind.Or) { return(Filter.Or(nodeIn.Left.Accept(this), nodeIn.Right.Accept(this))); } if (nodeIn.OperatorKind == BinaryOperatorKind.NotEqual) { return(Filter.Ne(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right))); } if (nodeIn.OperatorKind == BinaryOperatorKind.Equal) { return(Filter.Eq(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right))); } if (nodeIn.OperatorKind == BinaryOperatorKind.LessThan) { return(Filter.Lt(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right))); } if (nodeIn.OperatorKind == BinaryOperatorKind.LessThanOrEqual) { return(Filter.Lte(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right))); } if (nodeIn.OperatorKind == BinaryOperatorKind.GreaterThan) { return(Filter.Gt(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right))); } if (nodeIn.OperatorKind == BinaryOperatorKind.GreaterThanOrEqual) { return(Filter.Gte(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right))); } throw new NotSupportedException(); }
public void Gt_with_field_name_should_render_correctly(int?value, string expectedFilter) { var filter = __subject.Gt("I", value); filter.Render(__serializer, __registry).Should().Be(expectedFilter); }
public async Task <List <BsonDocument> > Query() { IMongoCollection <BsonDocument> coll = GetCollection <BsonDocument>(DbName, CollName); FilterDefinitionBuilder <BsonDocument> filterBuilder = Builders <BsonDocument> .Filter; FilterDefinition <BsonDocument> filter = filterBuilder.Eq("name", "MongoDB") & filterBuilder.Gt("count", 1); return(await coll.Find(filter).ToListAsync()); }
private async Task <IEnumerable <T> > FetchEntities <T> ( string metaPhrase, ProjectionDefinition <T> projection, IMongoCollection <T> collection, double daysTolerance, int limit, GeoJsonPoint <GeoJson3DGeographicCoordinates> targetPosition = null ) where T : IIdentifiable <ObjectId>, ILocatable, IMetaScored { var referenceDate = DateTime.UtcNow; var filterBuilder = new FilterDefinitionBuilder <T>(); var filter = filterBuilder.And ( filterBuilder.Gt ( post => post._id, new ObjectId(referenceDate.Subtract(TimeSpan.FromDays(daysTolerance)), 0, 0, 0) ), filterBuilder.Or ( filterBuilder.Text(metaPhrase, new TextSearchOptions { CaseSensitive = false, DiacriticSensitive = false, }) , filterBuilder.Exists(p => p._id) ) ); var sortBuilder = new SortDefinitionBuilder <T>(); var sort = sortBuilder.Combine ( sortBuilder.MetaTextScore("metaScore"), sortBuilder.Descending(p => p._id) ); var cursor = await collection.FindAsync(filter, new FindOptions <T> { AllowPartialResults = true, Limit = limit, Sort = sort, Projection = projection }); var enumerable = cursor.ToEnumerable(); if (targetPosition != null) { enumerable = enumerable.OrderBy ( item => item.Position.Coordinates.ToGeoCoordinate().GetDistanceTo(targetPosition.Coordinates.ToGeoCoordinate()) - Math.Pow(item.MetaScore, 2) ); } return(enumerable); }
// // 摘要: // Tests that the value of the named element is greater than some value (see $gt). // // 参数: // name: // The name of the element to test. // // value: // The value to compare to. // // 返回结果: // The builder (so method calls can be chained). public static FilterDefinition <BsonDocument> GT(string name, BsonValue value) { return(filter.Gt(name, value)); }
public override FilterDefinition <MongoContentEntity> Visit(BinaryOperatorNode nodeIn) { if (nodeIn.OperatorKind == BinaryOperatorKind.And) { return(Filter.And(nodeIn.Left.Accept(this), nodeIn.Right.Accept(this))); } if (nodeIn.OperatorKind == BinaryOperatorKind.Or) { return(Filter.Or(nodeIn.Left.Accept(this), nodeIn.Right.Accept(this))); } if (nodeIn.Left is SingleValueFunctionCallNode functionNode) { var regexFilter = Visit(functionNode); var value = BuildValue(nodeIn.Right); if (value is bool booleanRight) { if ((nodeIn.OperatorKind == BinaryOperatorKind.Equal && !booleanRight) || (nodeIn.OperatorKind == BinaryOperatorKind.NotEqual && booleanRight)) { regexFilter = Filter.Not(regexFilter); } return(regexFilter); } } else { if (nodeIn.OperatorKind == BinaryOperatorKind.NotEqual) { var field = BuildFieldDefinition(nodeIn.Left); return(Filter.Or( Filter.Not(Filter.Exists(field)), Filter.Ne(field, BuildValue(nodeIn.Right)))); } if (nodeIn.OperatorKind == BinaryOperatorKind.Equal) { return(Filter.Eq(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right))); } if (nodeIn.OperatorKind == BinaryOperatorKind.LessThan) { return(Filter.Lt(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right))); } if (nodeIn.OperatorKind == BinaryOperatorKind.LessThanOrEqual) { return(Filter.Lte(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right))); } if (nodeIn.OperatorKind == BinaryOperatorKind.GreaterThan) { return(Filter.Gt(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right))); } if (nodeIn.OperatorKind == BinaryOperatorKind.GreaterThanOrEqual) { return(Filter.Gte(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right))); } } throw new NotSupportedException(); }
/* 输入:设备Id、起止时间 * 输出:总告警次数 */ public int GetDeviceAffiliateAlarmInfoNumber(String deviceId, DateTime startTime, DateTime endTime) { FilterDefinitionBuilder <AlarmInfoModel> builderFilter = Builders <AlarmInfoModel> .Filter; FilterDefinition <AlarmInfoModel> filter = builderFilter.And(builderFilter.Eq("DeviceId", deviceId), builderFilter.Gt("Timestamp", startTime), builderFilter.Lt("Timestamp", endTime)); return((int)_alarmInfo.Find(filter).CountDocuments()); /* * return _alarmInfo.AsQueryable() * .Where(ai => ai.DeviceId == deviceId & ai.Timestamp>=startTime &ai.Timestamp<=endTime) * .ToList().Count; */ }
public object Gt <TProperty>(string property, TProperty value) { return(InternalBuilder.Gt(property, value)); }
/// <inheritdoc/> public Task <CommittedAggregateEvents> FetchForAggregateAfter(EventSourceId eventSource, ArtifactId aggregateRoot, AggregateRootVersion after, CancellationToken cancellationToken) => DoFetchForAggregate( eventSource, aggregateRoot, defaultFilter => defaultFilter & _eventFilter.Gt(_ => _.Aggregate.Version, after.Value), cancellationToken);