public static void SetStatus(BsonDocument service, bool restart) { try { var server = MongoServer.Create(ConfigurationManager.ConnectionStrings["mongodb"].ConnectionString); server.Connect(); var database = server.GetDatabase("config"); var collection = database.GetCollection("services"); var filter = new QueryDocument { { "_id", service["_id"].AsObjectId } }; var update = new UpdateDocument(); foreach (var key in service) update[key.Name] = key.Value; update["restart"] = restart; collection.Update(filter, update); server.Disconnect(); } catch (Exception err) { Console.WriteLine("** error updating restart status: " + err.Message); } }
public static UpdateDocument ToUpdateDocument(this TextContent content) { UpdateDocument doc = new UpdateDocument(); foreach (var item in content) { doc[item.Key] = BsonHelper.Create(item.Value); } return doc; }
public static UpdateDocument ToUpdateDocument(this TextContent textContent) { textContent = textContent.ConvertToUTCTime(); UpdateDocument doc = new UpdateDocument(); foreach (var item in textContent) { doc[item.Key] = BsonHelper.Create(item.Value); doc[GetCaseInsensitiveFieldName(item.Key)] = BsonHelper.Create(ToCaseInsensitiveValue(item.Value)); } return doc; }
private void MarkExisting(BsonDocument document) { BsonValue id = document.GetValue(Field.RESOURCEID); IMongoQuery query = Query.And(Query.EQ(Field.RESOURCEID, id), Query.EQ(Field.STATE, Value.CURRENT)); IMongoUpdate update = new UpdateDocument("$set", new BsonDocument { { Field.TRANSACTION, transid }, } ); collection.Update(query, update, UpdateFlags.Multi); }
public void MarkExisting(IEnumerable<BsonDocument> documents) { IEnumerable<BsonValue> keys = KeysOf(documents); IMongoUpdate update = new UpdateDocument("$set", new BsonDocument { { Field.TRANSACTION, this.transid }, } ); IMongoQuery query = Query.And(Query.EQ(Field.STATE, Value.CURRENT), Query.In(Field.RESOURCEID, keys)); collection.Update(query, update, UpdateFlags.Multi); }
public string Edit(int dvid, int ssid, BsonDocument data) { if (!DataDV.GetDV().CheckConnected()) { return Errors.e7006; } var query1 = Query.EQ("dvid", dvid); var query2 = Query.EQ("ssid", ssid); var query = Query.And(query1, query2); UpdateDocument update = new UpdateDocument("$set", data); sss.Update(query, update, UpdateFlags.Upsert); return string.Empty; }
public int Update(MongoCollection<BsonDocument> collection, IDictionary<string, object> data, SimpleExpression criteria) { var condition = _expressionFormatter.Format(criteria); MongoIdKeys.ReplaceId(data); var update = new UpdateDocument("$set", data.ToBsonDocument()); var result = collection.Update(condition, update, UpdateFlags.Multi); if (result != null) return (int)result.DocumentsAffected; return int.MaxValue; }
public void Update(Currency currency) { var collection = GetCollection(); var query = new QueryDocument { { "Name", currency.Name } }; var update = new UpdateDocument { { "$set", new BsonDocument { { "updated_at", currency.updated_at }, {"Curs", currency.Curs} } } }; collection.Update(query, update); }
public int Update(MongoCollection<BsonDocument> collection, IDictionary<string, object> data, SimpleExpression criteria) { var condition = _expressionFormatter.Format(criteria); if (data.ContainsKey("Id")) { data["_id"] = data["Id"]; data.Remove("Id"); } var update = new UpdateDocument("$set", data.ToBsonDocument()); var result = collection.Update(condition, update, UpdateFlags.Multi); if (result != null) return (int)result.DocumentsAffected; return int.MaxValue; }
private void MarkExisting(BsonDocument document) { BsonValue id = document.GetValue(Field.Key); IMongoQuery query = Query.And(Query.EQ(Field.Key, id), Query.EQ(Field.Status, Value.Current)); IMongoUpdate update = new UpdateDocument("$set", new BsonDocument { { Field.Transaction, transid }, } ); collection.Update(query, update, UpdateFlags.Multi); }
public void MarkExisting(IEnumerable<BsonDocument> documents) { IEnumerable<BsonValue> keys = KeysOf(documents); IMongoUpdate update = new UpdateDocument("$set", new BsonDocument { { Field.Transaction, this.transid }, } ); IMongoQuery query = Query.And(Query.EQ(Field.Status, Value.Current), Query.In(Field.Key, keys)); collection.Update(query, update, UpdateFlags.Multi); }
public void PutNextVersion(UpdateDocument updateDoc, object entity) { var version = this.Accessor.GetValue(entity); object nextVersion; var type = this.Descriptor.Property.PropertyType; if (type == typeof(int)) { nextVersion = (int)version + 1; } else if (type == typeof(long)) { nextVersion = Int64Version.GetCurrent(); } else if (type == typeof(DateTime)) { nextVersion = DateTimeVersion.GetCurrent(); } else { throw new NotSupportedException(String.Format("Don't support type {0} as version.", type)); } ((IPropertyUpdateOperator)this).PutConstantUpdate(updateDoc, nextVersion); }
public void RemoveTransaction(string transid) { IMongoQuery query = Query.EQ(Field.TRANSACTION, transid); IMongoUpdate update = new UpdateDocument("$set", new BsonDocument { { Field.TRANSACTION, 0 } } ); collection.Update(query, update, UpdateFlags.Multi); }
public bool Update(Entity entity) { var queryDoc = new QueryDocument {{EntityIdName, entity.Id}}; var updateDoc = new UpdateDocument {{"$set", SerializeEntity(entity)}}; var result = Collection.Update(queryDoc, updateDoc); return result.Ok; }
private void SaveChunk() { var lastChunkIndex = (int) ((length + fileInfo.ChunkSize - 1) / fileInfo.ChunkSize) - 1; if (chunkIndex == -1 || chunkIndex > lastChunkIndex) { var message = string.Format("Invalid chunk index: {0}", chunkIndex); throw new MongoGridFSException(message); } var lastChunkSize = (int) (length % fileInfo.ChunkSize); if (lastChunkSize == 0) { lastChunkSize = fileInfo.ChunkSize; } BsonBinaryData data; if (chunkIndex < lastChunkIndex || lastChunkSize == fileInfo.ChunkSize) { data = new BsonBinaryData(chunk); } else { var lastChunk = new byte[lastChunkSize]; Buffer.BlockCopy(chunk, 0, lastChunk, 0, lastChunkSize); data = new BsonBinaryData(lastChunk); } var query = Query.EQ("_id", chunkId); var update = new UpdateDocument { { "_id", chunkId }, { "files_id", fileInfo.Id }, { "n", chunkIndex }, { "data", data } }; gridFS.Chunks.Update(query, update, UpdateFlags.Upsert); chunkIsDirty = false; }
/// <summary> /// Modify all documents that match a query /// </summary> /// <param name="query"></param> /// <param name="result"></param> protected void QueryModify(ICompiledQuery query, CollectionValue result) { MongoCollection<BsonDocument> collection = this.Database.GetCollection(query.Collections.FirstOrDefault()); BsonArray conditions = BsonSerializer.Deserialize<BsonArray>(query.Conditions.FirstOrDefault()); BsonArray assignments = BsonSerializer.Deserialize<BsonArray>(query.Assignments.FirstOrDefault()); QueryDocument queryDocument = new QueryDocument(conditions.First().AsBsonDocument); UpdateDocument updateDocument = new UpdateDocument(assignments.First().AsBsonDocument); WriteConcernResult writeConcernResult = collection.Update(queryDocument, updateDocument, UpdateFlags.Multi); result.Add( new Affected() { new NumericValue() { Long = (int)writeConcernResult.DocumentsAffected } } ); }
/// <summary> /// find and update, with upsert. /// </summary> /// <param name="query"></param> /// <param name="result"></param> protected void QueryMerge(ICompiledQuery query, CollectionValue result) { MongoCollection<BsonDocument> collection = this.Database.GetCollection(query.Collections.FirstOrDefault()); ICompiledQuery save = query.Children.FirstOrDefault(child => child.Root is Save); ICompiledQuery modify = query.Children.FirstOrDefault(child => child.Root is Modify); if (save != null && modify != null) { BsonArray conditions = BsonSerializer.Deserialize<BsonArray>(modify.Conditions.FirstOrDefault()); BsonArray assignments = BsonSerializer.Deserialize<BsonArray>(save.Assignments.FirstOrDefault()); BsonArray sortings = BsonSerializer.Deserialize<BsonArray>(modify.Sortings.FirstOrDefault()); QueryDocument queryDocument = new QueryDocument(conditions.First().AsBsonDocument); IMongoSortBy sortByDocument = new SortByDocument(sortings.First().AsBsonDocument); UpdateDocument updateDocument = new UpdateDocument(assignments.First().AsBsonDocument); FindAndModifyResult findAndModifyResult = collection.FindAndModify(queryDocument, sortByDocument, updateDocument, true, true); result.Add(this.ToDocument(findAndModifyResult.ModifiedDocument)); } }
/// <summary> /// This method stores a order. /// </summary> /// <param name="o">The order object to store</param> /// <returns>Success/Failure</returns> public Boolean storeOrder(Order o) { dLog.Info("Entering method storeOrder | ID: " + o.id); Boolean result = false; try { MongoServer server = MongoServer.Create(); MongoDatabase db = server.GetDatabase("neatoBurrito"); //MongoCredentials credentials = new MongoCredentials("username", "password"); //MongoDatabase salaries = server.GetDatabase("salaries", credentials); using (server.RequestStart(db)) { MongoCollection<BsonDocument> coll = db.GetCollection("order"); var query = new QueryDocument("id", o.id); dLog.Debug("Finding if order exists"); BsonDocument myDoc = coll.FindOne(query); query.Add("isComplete", o.isComplete); query.Add("isSubmitted", o.isSubmitted); query.Add("orderDate", o.orderDate); query.Add("totalCost", o.totalCost.ToString()); //ensure we were passed a valid object before attempting to write if (myDoc == null) { dLog.Debug("Inserting order"); coll.Insert(query); result = true; } else { var update = new UpdateDocument(); update.Add(query.ToBsonDocument()); dLog.Debug("Updating order"); dLog.Debug("myDoc: " + myDoc.ToString()); dLog.Debug("update Query: " + update.ToString()); SafeModeResult wr = coll.Update(new QueryDocument("id", o.id), update, SafeMode.True); dLog.Debug("SafeModeResult: " + wr.Ok); if (wr.LastErrorMessage == null && wr.Ok) { result = true; } else { dLog.Debug("SafeModeResult: " + wr.LastErrorMessage); } } //now insert the burritos if (result) { dLog.Debug("Trying to insert " + o.burritos.Count + " burritos"); var index = 0; foreach (Burrito b in o.burritos) { b.orderID = o.id; dLog.Debug("Set order ID " + o.id + " for burrito: " + index); if (b.validate()) { dLog.Debug("Storing burrito: " + index); result = burritoSvc.storeBurrito(b); } index++; } } } } catch (Exception e2) { dLog.Error("Exception in storeBurrito: " + e2.Message); } finally { //using statement above already calls RequestDone() } return result; }
/// <summary> /// This method stores a user. /// </summary> /// <param name="u">The user object to store</param> /// <returns>Success/Failure</returns> public Boolean storeUser(User u) { dLog.Info("Entering method storeUser | ID: " + u.id); Boolean result = false; try { MongoServer server = MongoServer.Create(); //MongoCredentials credentials = new MongoCredentials("username", "password"); MongoDatabase db = server.GetDatabase("neatoBurrito"); //MongoDatabase db = server.GetDatabase("neatoBurrito", credentials); using (server.RequestStart(db)) { MongoCollection<BsonDocument> coll = db.GetCollection("user"); var query = new QueryDocument("id", u.id); dLog.Debug("Finding if user exists"); BsonDocument myDoc = coll.FindOne(query); query.Add("username", u.userName); query.Add("password", u.password); //ensure we were passed a valid object before attempting to write if (myDoc == null) { dLog.Debug("Inserting user"); coll.Insert(query); result = true; } else { var update = new UpdateDocument(); update.Add(query.ToBsonDocument()); dLog.Debug("Updating user"); dLog.Debug("myDoc: " + myDoc.ToString()); dLog.Debug("update Query: " + update.ToString()); SafeModeResult wr = coll.Update(new QueryDocument("id", u.id), update, SafeMode.True); dLog.Debug("SafeModeResult: " + wr.Ok); if (wr.LastErrorMessage == null && wr.Ok) { result = true; } else { dLog.Debug("SafeModeResult: " + wr.LastErrorMessage); } } } } catch (Exception e2) { dLog.Error("Exception in storeEUser: " + e2.Message); } finally { //using statement above already calls RequestDone() } return result; }
public string EditVal(int dvid, int ssid, em_SensorType type, DateTime key, string netjson) { var coll = DataDV.GetDV().getCol().GetCollection(dvid.ToString() + ssid.ToString() + type.ToString()); DataPointValModel gm; try { gm = BsonSerializer.Deserialize<DataPointValModel>(netjson); if (!DataDV.GetDV().CheckConnected()) { return Errors.e7006; } var query = Query.EQ("timestamp", key); gm.timestamp = key; UpdateDocument update = new UpdateDocument("$set", gm.ToBsonDocument()); coll.Update(query, update, UpdateFlags.Upsert); return string.Empty; } catch { return Errors.e7003; } }
private void sweep(string transid, string statusfrom, string statusto) { IMongoQuery query = Query.And(Query.EQ(Field.Transaction, transid), Query.EQ(Field.Status, statusfrom)); IMongoUpdate update = new UpdateDocument("$set", new BsonDocument { { Field.Status, statusto } } ); collection.Update(query, update, UpdateFlags.Multi); }
static void Main(string[] args) { //这是一个公共的调试默认连接 var client = new MongoClient("mongodb://localhost"); var server = client.GetServer(); var database = server.GetDatabase("foo"); //如果要连接多个服务器,可以直接填写多个服务器名(以及需要的端口号),并且以‘,’分割。如下: //mongodb://server1,server2:27017,server2:27018 //多数据库服务是模糊不清的,不能分辨服务是否复本集,或者是多数据库服务。drive驱动会跳过connection string的语法检查, //直接连接进数据库服务器,让server自己检查他们的类别。还有一些办法在连接的时候就指定数据服务器的类别,就是在connection string里面直接描述。如下: //mongodb://server1,server2:27017,server2:27018/?connect=replicaset //可用的连接模式包括:automatic (默认), direct, replica set, 以及shardrouter。 //mongodb://server2/?ssl=true(安全链接) //在默认的情况下,server是通过本地的受信任的证书机构获取许可。在一些测试环境下面,测试server没有签署证书,为了缓解这个情况, //可以使用在connection string里面添加“sslverifycertificate=false”来屏蔽所有certificate errors(认证错误)。 //Authentication //MongoDB支持两种认证方式。一种是在程序执行时,调用特定的方法。在执行特定的方法时,认证将会被使用。另外一种健壮的方法是在MongoCredentialsStore存储认证 //使用credential store来确定admin和“foo”数据库的认证信息。除了使用“admin”以及“foo”连接入数据库,还可以使用默认的认证“test”。 //------------------------------------------------------------------------------ var url = new MongoUrl("mongodb://*****:*****@localhost:27017"); var settings = MongoClientSettings.FromUrl(url); var adminCredentials = new MongoCredentials("admin", "user", true); var fooCredentials = new MongoCredentials("foo", "user", false); settings.CredentialsStore.AddCredentials("admin", adminCredentials); settings.CredentialsStore.AddCredentials("foo", fooCredentials); var client_1 = new MongoClient(settings); //------------------------------------------------------------------------------ MongoClient client_2 = new MongoClient(); // connect to localhost MongoServer server_1 = client_2.GetServer(); MongoDatabase test = server_1.GetDatabase("test"); MongoCredentials credentials = new MongoCredentials("username", "password"); MongoDatabase salaries = server_1.GetDatabase("salaries", credentials); //------------------------------------------------------------------------------ //大多数的数据库设置从server对象中继承过来,并且提供了GetDatabase的重载。要override其他设置,可以调用CreateDataBaseSetting,在调用GetDataBase之前,改变设置。比如下面这样: var databaseSettings = server_1.CreateDatabaseSettings("test"); databaseSettings.SlaveOk = true; var database_1 = server_1.GetDatabase(databaseSettings); //大多数的collection设置都是继承了collection对象,并且提供了GetCollection的多态性来方便你来重写一些常用的使用设置。 //要重写其他的设置,先调用CreateCollectionSetting来改变设置,然后再调用GetCollection方法。比如下面代码: //GetCollection维持一个表的实例,如果你再次调用这个GetCollection,它会返回一样的内容。 var collectionSettings = database_1.CreateCollectionSettings<BsonDocument>("test"); collectionSettings.SlaveOk = true; var collection = database_1.GetCollection(collectionSettings); //插入函数。插入的对象可以是BsonDocument的实例对象,也可以是任何成功转换成BSON文档的类实例。例如: MongoCollection<Person> persons_object = database.GetCollection<Person>("Person"); Random r = new Random(BitConverter.ToInt32(Guid.NewGuid().ToByteArray(), 0)); int ages = r.Next(1,100); string name = CreateSimplifiedChinese(5); Person p_entity = new Person() { name = name, age = ages, sex = ages % 2 == 0 ? true : false }; persons_object.Insert(p_entity);//或者 //persons_object.Insert<Person>(p_entity); //如果你要插入多重文档,InsertBatch要比Insert有效。 //FindOne以及FindOneAs方法 //要从collection中检索文档,可以使用这个方法。FindOne是最简单的。它会返回结果的第一个文档。例如: Person p_1 = persons_object.FindOne(); //如果你想检索一个文档,但是它不是<TDefaultDocument>类型的,你需要用到FindOneAs方法。它允许你返回你需要的文档类型。例如: BsonDocument bson_1 = persons_object.FindOneAs<BsonDocument>(); //Find和FindAs方法是用query语句来告诉服务器返回什么的文档。这个query(查询语句)的类型是IMongoQuery。IMongoQuery是一个标记接口, //被类识别后可以用来作为查询语言。最常见的方法是,我们可以使用Query创建类或者是QueryDocument类来创建query语句。 //另外如果使用QueryWrapper封装任何类型query语句,query都可以被转变成BSON文档类型。 //使用QueryDocument var query_1 = new QueryDocument("name", name); foreach (Person item in persons_object.Find(query_1)) { Console.WriteLine("QueryDocument:" + item.name); } //使用Query Builder var query_2 = Query.EQ("name",name); foreach (Person item in persons_object.Find(query_2)) { Console.WriteLine("Query.EQ:" + item.name); } //使用FindAs来获取非默认类型的返回文档 var query_3 = Query<Person>.EQ(x => x.name, name); foreach (Person item in persons_object.Find(query_3)) { Console.WriteLine("Query<Person>.EQ:" + item.name); } //Save<TDocument>方法 //Save方法是Insert和Update的组合。如果文档的属性是有值的,它会成为Update,来对文档更新。否则将会创建一个新文档调用Insert方法。 //修改性别 var query_4 = Query.And( Query.EQ("name", "你这个人真是无聊到头顶了") //,Query.EQ("age",65) ); Person person_bs1 = persons_object.FindOne(query_4); if (person_bs1!=null) { person_bs1.age = r.Next(1,200); persons_object.Save(person_bs1); } //TDocument必须要有个ID元素,否则你将调用Insert,将文档插入。 //Update方法 var query_5 = Query.And( Query.EQ("name", "你这个人真是无聊到头顶了") ); var update_1 = new UpdateDocument { {"$set",new BsonDocument("age",r.Next(1,200))} }; WriteConcernResult updateP_1 = persons_object.Update(query_5, update_1); //FindAndModify方法 //使用FindAndModify方法,你可以在一个原子操作里面查找一个匹配的文档并且修改更新. //FindAndModify通常用于单个的文档,如果匹配了多个文档,可以使用标准的排序方法匹配到你自己想要修改的文档。 var query_6 = Query.And(Query.EQ("name", "你这个人真是无聊到头顶了"),Query.EQ("sex",true)); var sortby_1 = SortBy.Descending("age"); var update_3 = Update.Set("age", 112).Set("sex", false); var results_1 = persons_object.FindAndModify(query_6, sortby_1, update_3, true); var document_1 = results_1.ModifiedDocument; //MapReduce方法 //Map/Reduce是一种从collection中聚合数据的方法。每个文档(或者使用选择query语句产生的是子集)被发送至map函数, //map函数会产生一个中间的值。这个中间的值会传送至reduce函数进行数据的聚合。 //下面的例子采集自MongoDB:The Definitive Guide(MongDB权威解析)的87页。它计算在collection中找到的每个key要被计算多少次 //LT=>Less Than //GT=>More Than //EQ=>Equels //IN var query = Query.And(Query.LT("age", 100), Query.GT("age", 90)); var cursor = persons_object.Find(query); var firstBook = cursor.FirstOrDefault(); var lastBook = cursor.LastOrDefault(); //Query.All("name", "a", "b");//通过多个元素来匹配数组 //Query.And(Query.EQ("name", "a"), Query.EQ("title", "t"));//同时满足多个条件 //Query.EQ("name", "a");//等于 //Query.Exists("type", true);//判断键值是否存在 //Query.GT("value", 2);//大于> //Query.GTE("value", 3);//大于等于>= //Query.In("name", "a", "b");//包括指定的所有值,可以指定不同类型的条件和值 //Query.LT("value", 9);//小于< //Query.LTE("value", 8);//小于等于<= //Query.Mod("value", 3, 1);//将查询值除以第一个给定值,若余数等于第二个给定值则返回该结果 //Query.NE("name", "c");//不等于 //Query.Nor(Array);//不包括数组中的值 //Query.Not("name");//元素条件语句 //Query.NotIn("name", "a", 2);//返回与数组中所有条件都不匹配的文档 //Query.Or(Query.EQ("name", "a"), Query.EQ("title", "t"));//满足其中一个条件 //Query.Size("name", 2);//给定键的长度 //Query.Type("_id", BsonType.ObjectId);//给定键的类型 //Query.Where(BsonJavaScript);//执行JavaScript //Query.Matches("Title", str);//模糊查询 相当于sql中like -- str可包含正则表达式 Console.ReadKey(); }
public void TestUpdateDocumentConstructor() { var document1 = new UpdateDocument(dictionary); var document2 = new UpdateDocument(hashtable); var document3 = new UpdateDocument(idictionaryNonGeneric); var document4 = new UpdateDocument(idictionary); Assert.AreEqual("Dictionary<string, object>", document1["type"].AsString); Assert.AreEqual("Hashtable", document2["type"].AsString); Assert.AreEqual("IDictionary", document3["type"].AsString); Assert.AreEqual("IDictionary<string, object>", document4["type"].AsString); }
/// <summary> /// Get a non running message from queue /// </summary> /// <param name="query">query where top level fields do not contain operators. Lower level fields can however. eg: valid {a: {$gt: 1}, "b.c": 3}, invalid {$and: [{...}, {...}]}</param> /// <param name="resetRunning">duration before this message is considered abandoned and will be given with another call to Get()</param> /// <param name="wait">duration to keep polling before returning null</param> /// <param name="poll">duration between poll attempts</param> /// <returns>message or null</returns> /// <exception cref="ArgumentNullException">query is null</exception> public BsonDocument Get(QueryDocument query, TimeSpan resetRunning, TimeSpan wait, TimeSpan poll) { if (query == null) throw new ArgumentNullException("query"); //reset stuck messages collection.Update( new QueryDocument { { "running", true }, { "resetTimestamp", new BsonDocument("$lte", DateTime.UtcNow) } }, new UpdateDocument("$set", new BsonDocument("running", false)), UpdateFlags.Multi ); var builtQuery = new QueryDocument("running", false); foreach (var field in query) builtQuery.Add("payload." + field.Name, field.Value); builtQuery.Add("earliestGet", new BsonDocument("$lte", DateTime.UtcNow)); var resetTimestamp = DateTime.UtcNow; try { resetTimestamp += resetRunning; } catch (ArgumentOutOfRangeException) { resetTimestamp = resetRunning > TimeSpan.Zero ? DateTime.MaxValue : DateTime.MinValue; } var sort = new SortByDocument { { "priority", 1 }, { "created", 1 } }; var update = new UpdateDocument("$set", new BsonDocument { { "running", true }, { "resetTimestamp", resetTimestamp } }); var fields = new FieldsDocument("payload", 1); var end = DateTime.UtcNow; try { end += wait; } catch (ArgumentOutOfRangeException) { end = wait > TimeSpan.Zero ? DateTime.MaxValue : DateTime.MinValue; } while (true) { var message = collection.FindAndModify(builtQuery, sort, update, fields, false, false).ModifiedDocument; if (message != null) //using merge without overwriting so a possible id in payload doesnt wipe it out the generated one return new BsonDocument("id", message["_id"]).Merge(message["payload"].AsBsonDocument); if (DateTime.UtcNow >= end) return null; try { Thread.Sleep(poll); } catch (ArgumentOutOfRangeException) { poll = poll < TimeSpan.Zero ? TimeSpan.Zero : TimeSpan.FromMilliseconds(int.MaxValue); Thread.Sleep(poll); } } }
private void BulkUpdateStatus(string transid, string statusfrom, string statusto) { IMongoQuery query = Query.And(Query.EQ(Field.TRANSACTION, transid), Query.EQ(Field.STATE, statusfrom)); IMongoUpdate update = new UpdateDocument("$set", new BsonDocument { { Field.STATE, statusto } } ); collection.Update(query, update, UpdateFlags.Multi); }
public void TestUpdateChecksThatAllTopLevelFieldNamesAreOperators(bool ordered) { _collection.Drop(); var bulk = InitializeBulkOperation(_collection, ordered); var query = Query.EQ("_id", 1); var update = new UpdateDocument { { "key", 1 } }; bulk.Find(query).Update(update); Assert.Throws<BsonSerializationException>(() => bulk.Execute()); }
public void RequestAddFriend(string ownerUsername, string friendUsername, string remark, string groupName, string message, RequestAddFriendUpdateFlags flags) { var db = GetDatabase(); var collection = db.GetCollection("friend_request"); var queryDoc = new QueryDocument(); queryDoc.Add("OwnerUsername", ownerUsername.ToLower()); queryDoc.Add("FriendUsername", friendUsername.ToLower()); var cur = collection.Find(queryDoc); cur.Limit = 1; UpdateDocument updateDoc = new UpdateDocument(); if (cur.Size() > 0) { foreach (var item in cur) updateDoc.Add(item); } else { updateDoc.Add("OwnerUsername", ownerUsername.ToLower()); updateDoc.Add("FriendUsername", friendUsername.ToLower()); } if (flags == RequestAddFriendUpdateFlags.UpdateAll || (flags & RequestAddFriendUpdateFlags.UpdateRemark) == RequestAddFriendUpdateFlags.UpdateRemark) if (remark == null && updateDoc.Contains("Remark")) updateDoc.Remove("Remark"); else if (remark != null) updateDoc.Set("Remark", remark); if (flags == RequestAddFriendUpdateFlags.UpdateAll || (flags & RequestAddFriendUpdateFlags.UpdateMessage) == RequestAddFriendUpdateFlags.UpdateMessage) if (message == null && updateDoc.Contains("Message")) updateDoc.Remove("Message"); else if (message != null) updateDoc.Set("Message", message); if (flags == RequestAddFriendUpdateFlags.UpdateAll || (flags & RequestAddFriendUpdateFlags.UpdateGroup) == RequestAddFriendUpdateFlags.UpdateGroup) if (groupName == null && updateDoc.Contains("GroupName")) updateDoc.Remove("GroupName"); else if (groupName != null) updateDoc.Set("GroupName", groupName); updateDoc.Set("Time", DateTime.Now); collection.Update(queryDoc, updateDoc, UpdateFlags.Upsert); }
/// <summary> /// This method stores a burrito. /// </summary> /// <param name="b">The burrito object to store</param> /// <returns>Success/Failure</returns> public Boolean storeBurrito(Burrito b) { dLog.Info("Entering method storeBurrito | ID: " + b.id); Boolean result = false; try { MongoServer server = MongoServer.Create(); MongoDatabase db = server.GetDatabase("neatoBurrito"); //MongoCredentials credentials = new MongoCredentials("username", "password"); //MongoDatabase salaries = server.GetDatabase("salaries", credentials); using (server.RequestStart(db)) { MongoCollection<BsonDocument> coll = db.GetCollection("burrito"); var query = new QueryDocument("id", b.id); dLog.Debug("Finding if burrito exists"); BsonDocument myDoc = coll.FindOne(query); query.Add("beef", b.Beef); query.Add("blackBeans", b.BlackBeans); query.Add("brownRice", b.BrownRice); query.Add("chicken", b.Chicken); query.Add("chiliTortilla", b.ChiliTortilla); query.Add("cucumber", b.Cucumber); query.Add("flourTortilla", b.FlourTortilla); query.Add("guacamole", b.Guacamole); query.Add("herbGarlicTortilla", b.HerbGarlicTortilla); query.Add("hummus", b.Hummus); query.Add("jalapenoCheddarTortilla", b.JalapenoCheddarTortilla); query.Add("jalapenos", b.Jalapenos); query.Add("lettuce", b.Lettuce); query.Add("onion", b.Onion); query.Add("orderID", b.orderID); query.Add("pintoBeans", b.PintoBeans); query.Add("price", b.Price.ToString()); query.Add("salsaPico", b.SalsaPico); query.Add("salsaSpecial", b.SalsaSpecial); query.Add("salsaVerde", b.SalsaVerde); query.Add("tomatoBasilTortilla", b.TomatoBasilTortilla); query.Add("tomatoes", b.Tomatoes); query.Add("wheatTortilla", b.WheatTortilla); query.Add("whiteRice", b.WhiteRice); //ensure we were passed a valid object before attempting to write if (myDoc == null) { dLog.Debug("Inserting burrito"); coll.Insert(query); result = true; } else { var update = new UpdateDocument(); update.Add(query.ToBsonDocument()); dLog.Debug("Updating burrito"); dLog.Debug("myDoc: " + myDoc.ToString()); dLog.Debug("update Query: " + update.ToString()); SafeModeResult wr = coll.Update(new QueryDocument("id", b.id), update, SafeMode.True); dLog.Debug("SafeModeResult: " + wr.Ok); if (wr.LastErrorMessage == null && wr.Ok) { result = true; } else { dLog.Debug("SafeModeResult: " + wr.LastErrorMessage); } } } } catch (Exception e2) { dLog.Error("Exception in storeBurrito: " + e2.Message); } finally { //using statement above already calls RequestDone() } return result; }
/// <summary> /// Ack message and send payload to queue, atomically. /// </summary> /// <param name="message">message to ack received from Get()</param> /// <param name="payload">payload to send</param> /// <param name="earliestGet">earliest instant that a call to Get() can return message</param> /// <param name="priority">priority for order out of Get(). 0 is higher priority than 1</param> /// <exception cref="ArgumentNullException">message or payload is null</exception> /// <exception cref="ArgumentException">message id must be a BsonObjectId</exception> /// <exception cref="ArgumentException">priority was NaN</exception> public void AckSend(BsonDocument message, BsonDocument payload, DateTime earliestGet, double priority) { if (message == null) throw new ArgumentNullException("message"); if (payload == null) throw new ArgumentNullException("payload"); if (Double.IsNaN(priority)) throw new ArgumentException("priority was NaN", "priority"); var messageId = message["id"]; if (messageId.GetType() != typeof(BsonObjectId)) throw new ArgumentException("message id must be a BsonObjectId", "message"); var newMessage = new UpdateDocument { {"payload", payload}, {"running", false}, {"resetTimestamp", DateTime.MaxValue}, {"earliestGet", earliestGet}, {"priority", priority}, {"created", DateTime.UtcNow}, }; //using upsert because if no documents found then the doc was removed (SHOULD ONLY HAPPEN BY SOMEONE MANUALLY) so we can just send collection.Update(new QueryDocument("_id", messageId), newMessage, UpdateFlags.Upsert); }
private void SaveChunk() { var lastChunkIndex = (_length + _fileInfo.ChunkSize - 1) / _fileInfo.ChunkSize - 1; if (_chunkIndex == -1 || _chunkIndex > lastChunkIndex) { var message = string.Format("Invalid chunk index {0}.", _chunkIndex); throw new MongoGridFSException(message); } var lastChunkSize = (int)(_length % _fileInfo.ChunkSize); if (lastChunkSize == 0) { lastChunkSize = _fileInfo.ChunkSize; } BsonBinaryData data; if (_chunkIndex < lastChunkIndex || lastChunkSize == _fileInfo.ChunkSize) { data = new BsonBinaryData(_chunk); } else { var lastChunk = new byte[lastChunkSize]; Buffer.BlockCopy(_chunk, 0, lastChunk, 0, lastChunkSize); data = new BsonBinaryData(lastChunk); } var query = Query.EQ("_id", _chunkId); var update = new UpdateDocument { { "_id", _chunkId }, { "files_id", _fileInfo.Id }, { "n", (_chunkIndex < int.MaxValue) ? (BsonValue)BsonInt32.Create((int)_chunkIndex) : BsonInt64.Create(_chunkIndex) }, { "data", data } }; _gridFS.Chunks.Update(query, update, UpdateFlags.Upsert); _chunkIsDirty = false; }