protected override UpdateResult ExecuteAndGetResult(IMongoDatabase database, IMongoCollection <BsonDocument> collection, bool async)
{
UpdateDefinition <BsonDocument> updateDefinition = null;
if (_update is BsonDocument updateDocument)
{
updateDefinition = new BsonDocumentUpdateDefinition <BsonDocument>(updateDocument);
}
else if (_update is BsonArray stages)
{
var pipeline = new BsonDocumentStagePipelineDefinition <BsonDocument, BsonDocument>(stages.Cast <BsonDocument>());
updateDefinition = new PipelineUpdateDefinition <BsonDocument>(pipeline);
}
if (async)
{
return(collection
.UpdateManyAsync(_filter, updateDefinition, _options)
.GetAwaiter()
.GetResult());
}
else
{
return(collection.UpdateMany(_filter, updateDefinition, _options));
}
}
public virtual async Task <bool> Update(Expression <Func <TEntity, bool> > predicate, TEntity obj)
{
var update = new BsonDocumentUpdateDefinition <TEntity>(obj.ToBsonDocument());
var result = await document.UpdateManyAsync(predicate, update);
return(result.IsAcknowledged && result.ModifiedCount > 0);
}
public void ReplaceOne(T document)
{
var filter = Builders <T> .Filter.Eq(nameof(document.Id), document.Id);
var update = new BsonDocumentUpdateDefinition <BsonDocument>(document.ToBsonDocument());
Collection.ReplaceOne(filter, document);
}
private UpdateOneModel <BsonDocument> ParseUpdateOne(BsonDocument request)
{
var filter = new BsonDocumentFilterDefinition <BsonDocument>((BsonDocument)request["filter"]);
var update = new BsonDocumentUpdateDefinition <BsonDocument>((BsonDocument)request["update"]);
var model = new UpdateOneModel <BsonDocument>(filter, update);
model.IsUpsert = request.GetValue("upsert", false).ToBoolean();
return(model);
}
/// <summary>
/// 更新操作
/// </summary>
/// <param name="collectionName">集合名称</param>
/// <param name="t">更新对象</param>
/// <param name="filter">条件</param>
/// <returns>更新是否成功true or false</returns>
public bool UpdateOne <T>(string collectionName, Expression <Func <T, bool> > filter, T t)
{
if (t == null)
{
return(false);
}
var itemBson = t.ToBsonDocument();
var updateDef = new BsonDocumentUpdateDefinition <T>(new BsonDocument("$set", itemBson));
return(UpdateOne <T>(collectionName, filter, updateDef));
}
public async Task <ReceivedMessage> GetNextAsync()
{
var now = DateTime.UtcNow;
var receiveTimeCriteria = new BsonDocument {
{ "$lt", now.Subtract(_config.DefaultMessageLease) }
};
var filter = new BsonDocumentFilterDefinition <BsonDocument>(new BsonDocument
{
{ Fields.DestinationQueueName, QueueName },
{ Fields.ReceiveTime, receiveTimeCriteria },
{ Fields.DeliveryAttempts, new BsonDocument {
{ "$lt", _config.MaxDeliveryAttempts }
} },
});
var update = new BsonDocumentUpdateDefinition <BsonDocument>(new BsonDocument
{
{ "$set", new BsonDocument {
{ Fields.ReceiveTime, now }
} },
{ "$inc", new BsonDocument {
{ Fields.DeliveryAttempts, 1 }
} }
});
var options = new FindOneAndUpdateOptions <BsonDocument>
{
ReturnDocument = ReturnDocument.After
};
var collection = _config.Collection;
await _semaphore.WaitAsync();
try
{
var document = await collection.FindOneAndUpdateAsync(filter, update, options);
if (document == null)
{
return(null);
}
return(GetReceivedMessage(document));
}
finally
{
_semaphore.Release();
}
}
private UpdateOneModel <BsonDocument> ParseUpdateOneModel(BsonDocument model)
{
JsonDrivenHelper.EnsureAllFieldsAreValid(model, "filter", "update", "upsert");
var filter = new BsonDocumentFilterDefinition <BsonDocument>(model["filter"].AsBsonDocument);
var update = new BsonDocumentUpdateDefinition <BsonDocument>(model["update"].AsBsonDocument);
var isUpsert = model.GetValue("upsert", false).ToBoolean();
return(new UpdateOneModel <BsonDocument>(filter, update)
{
IsUpsert = isUpsert
});
}
public async Task Set(Position position)
{
var criteria = new BsonDocumentFilterDefinition <BsonDocument>(new BsonDocument
{
{ "_id", position.Topic }
});
var update = new BsonDocumentUpdateDefinition <BsonDocument>(new BsonDocument
{
{ "$set", new BsonDocument {
{ position.Partition.ToString(), position.Offset }
} }
});
await _positions.UpdateOneAsync(criteria, update, new UpdateOptions { IsUpsert = true });
}
public void updateUser(UserModel userModel)
{
var filter = Builders <UserModel> .Filter.Eq("_id", userModel.Id);
try
{
var dictionary = makeDictionaryFromModel(userModel);
var bsonDocument = new BsonDocument("$set", dictionary.ToBsonDocument());
var update = new BsonDocumentUpdateDefinition <UserModel>(bsonDocument);
db_.GetCollection <UserModel>("User").UpdateOne(filter, update);
}
catch (Exception ex)
{
throw new Exception("User update fail" + ex.Message);
}
}
/// <summary>
/// Update one or more documents partially by filter
/// </summary>
/// <param name="filters"></param>
/// <param name="partialDocument"></param>
/// <returns></returns>
public bool UpdateByQuery(FilterDefinition <TDocument> filters, object partialDocument)
{
filters = filters ?? FilterBuilder.GetFilterBuilder <TDocument>().Empty;
if (partialDocument == null)
{
throw new ArgumentNullException(nameof(partialDocument));
}
var updateMapped = new BsonDocument {
{ "$set", partialDocument.ToBsonDocument() }
};
var update = new BsonDocumentUpdateDefinition <TDocument>(updateMapped);
return(this.Collection.UpdateMany(filters, update).IsAcknowledged);
}
public UpdateResult Update(string set_name, Dictionary <object, object> search, string _op, Dictionary <object, object> data)
{
if (search.ContainsKey("_id"))
{
search["_id"] = new ObjectId(search["_id"].ToString());
}
BsonDocument bfilter = new BsonDocument(search);
BsonDocumentFilterDefinition <BsonDocument> filterDef = new BsonDocumentFilterDefinition <BsonDocument>(bfilter);
Dictionary <object, object> op = new Dictionary <object, object>();
op.Add(_op, data);
BsonDocument bdata = new BsonDocument(op);
BsonDocumentUpdateDefinition <BsonDocument> updateDef = new BsonDocumentUpdateDefinition <BsonDocument>(bdata);
UpdateResult ures = mdb.GetCollection <BsonDocument>(set_name).UpdateMany(filterDef, updateDef);
return(ures);
}
public void ShouldUpdateUser(string hostname, int portNum, string databaseName)
{
var update = new UpdateDefinitionBuilder <User>();
update.Set("Phone", "5132359201");
var nsContext = new NeighborstashContext(new NeighbostashDbSettings
{
ConnectionString = $"mongodb://{hostname}:{portNum}",
DatabaseName = databaseName
});
// UpdateDefinition<User> upd ="{Phone:5132359206}";
var builder = Builders <User> .Filter;
var filter = builder.Eq(u => u.Lastname, "Teddie");
var ub = Builders <User> .Update;
UpdateDefinition <User> updater = new BsonDocumentUpdateDefinition <User>(new BsonDocument
{
{ "Locale", "En" }
});
var filterDefinition = Builders <User> .Filter.Empty;
filterDefinition &= Builders <User> .Filter.Eq(u => u.Email, "*****@*****.**");
var qFind = nsContext.Users.Find(filterDefinition);
var user = qFind.First();
Console.WriteLine($"{user.Lastname}, {user.Firstname}");
var result = nsContext.Users.UpdateOne(u => u.Email == "*****@*****.**", updater, null);
Assert.IsTrue(result.IsAcknowledged);
//var modification = new UpdateDefinition<User>().Push(u => u.Lastname, "").Set(r => r.DateOfBirth, "");
}
public UnifiedFindOneAndUpdateOperation Build(string targetCollectionId, BsonDocument arguments)
{
var collection = _entityMap.GetCollection(targetCollectionId);
FilterDefinition <BsonDocument> filter = null;
FindOneAndUpdateOptions <BsonDocument> options = null;
UpdateDefinition <BsonDocument> update = null;
foreach (var argument in arguments)
{
switch (argument.Name)
{
case "filter":
filter = new BsonDocumentFilterDefinition <BsonDocument>(argument.Value.AsBsonDocument);
break;
case "returnDocument":
options = options ?? new FindOneAndUpdateOptions <BsonDocument>();
options.ReturnDocument = (ReturnDocument)Enum.Parse(typeof(ReturnDocument), argument.Value.AsString);
break;
case "sort":
options = options ?? new FindOneAndUpdateOptions <BsonDocument>();
options.Sort = new BsonDocumentSortDefinition <BsonDocument>(argument.Value.AsBsonDocument);
break;
case "update":
update = new BsonDocumentUpdateDefinition <BsonDocument>(argument.Value.AsBsonDocument);
break;
default:
throw new FormatException($"Invalid FindOneAndUpdateOperation argument name: '{argument.Name}'.");
}
}
return(new UnifiedFindOneAndUpdateOperation(collection, filter, update, options));
}
private bool TryParseUpdate(BsonDocument value, out UpdateDefinition <BsonDocument> update)
{
update = new BsonDocumentUpdateDefinition <BsonDocument>(value);
return(true);
}
private UpdateOneModel<BsonDocument> ParseUpdateOne(BsonDocument request)
{
var filter = new BsonDocumentFilterDefinition<BsonDocument>((BsonDocument)request["filter"]);
var update = new BsonDocumentUpdateDefinition<BsonDocument>((BsonDocument)request["update"]);
var model = new UpdateOneModel<BsonDocument>(filter, update);
model.IsUpsert = request.GetValue("upsert", false).ToBoolean();
return model;
}
