/// <summary>
/// Returns the role by their role id
/// </summary>
/// <param name="roleId">The id of the role to retrieve</param>
/// <returns>the role found or null</returns>
public bool DeleteCart(ObjectId id, string clientIP)
{
var db = (from c in Carts.AsQueryable() where c.ClientIP == clientIP select c).First();
FindAndModifyResult spotResult = Carts.FindAndRemove(Query.EQ("_id", db.CartID), SortBy.Ascending("_id"));
return(spotResult.Ok);
}
public async void FindAndModifyAsyncTest1()
{
string entryMessage1 = "entry 1";
AddMongoEntry(entryMessage1, MONGO_COLLECTION_1_NAME);
List <Entry> results = new List <Entry>(_reader.Read <Entry>(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(entryMessage1, results[0].Message);
var searchQuery = Query.EQ("Message", entryMessage1);
var update = Update.Set("Message", MONGO_EDITED_TEXT);
var sortBy = SortBy.Descending("TimeStamp");
FindAndModifyArgs findAndModifyArgs = new FindAndModifyArgs();
findAndModifyArgs.Query = searchQuery;
findAndModifyArgs.SortBy = sortBy;
findAndModifyArgs.Update = update;
findAndModifyArgs.Upsert = true;
findAndModifyArgs.VersionReturned = FindAndModifyDocumentVersion.Modified;
FindAndModifyResult result = await _databaseUpdater.FindAndModifyAsync <Entry>(MONGO_COLLECTION_1_NAME, findAndModifyArgs);
Assert.IsNotNull(result);
Assert.IsTrue(result.Ok);
Assert.IsNull(result.ErrorMessage);
Assert.IsNotNull(result.ModifiedDocument);
results = new List <Entry>(_reader.Read <Entry>(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(MONGO_EDITED_TEXT, results[0].Message);/*This field we modified via FindAndModify...*/
}
// <summary>
/// Deletes the spot with the specified id
/// </summary>
/// <param name="spotId">Id of the spot to delete</param>
/// <returns>Result of the operation, true if was ok</returns>
public bool Delete(ObjectId id)
{
Spot spot = Spots.FindOneById(id);
FindAndModifyResult spotResult = Spots.FindAndRemove(Query.EQ("_id", id), SortBy.Ascending("_id"));
return(spotResult.Ok);
}
// <summary>
/// Deletes the role with the specified id
/// </summary>
/// <param name="roleId">Id of the role to delete</param>
/// <returns>Result of the operation, true if was ok</returns>
public bool Delete(ObjectId id)
{
Parcel parcel = Parcels.FindOneById(id);
FindAndModifyResult parcelResult = Parcels.FindAndRemove(Query.EQ("_id", id), SortBy.Ascending("_id"));
return(parcelResult.Ok);
}
public async void FindAndRemoveAsyncTest()
{
string entryMessage1 = "entry 1";
AddMongoEntry(entryMessage1, MONGO_COLLECTION_1_NAME);
List <Entry> results = new List <Entry>(_reader.Read <Entry>(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(entryMessage1, results[0].Message);
var searchQuery = Query.EQ("Message", entryMessage1);
var update = Update.Set("Message", MONGO_EDITED_TEXT);
var sortBy = SortBy.Descending("TimeStamp");
IMongoFields fields = Fields.Null;
FindAndRemoveArgs findAndRemoveArgs = new FindAndRemoveArgs();
findAndRemoveArgs.Query = searchQuery;
findAndRemoveArgs.SortBy = sortBy;
FindAndModifyResult result = await _databaseUpdater.FindAndRemoveAsync <Entry>(MONGO_COLLECTION_1_NAME, findAndRemoveArgs);
Assert.IsNotNull(result);
Assert.IsTrue(result.Ok);
Assert.IsNull(result.ErrorMessage);
Assert.IsNotNull(result.ModifiedDocument);
results = new List <Entry>(_reader.Read <Entry>(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(0, results.Count());/*we deleted the entry via FindAndRemove...*/
}
public bool Delete(ObjectId id)
{
Phase phase = Phases.FindOneById(id);
FindAndModifyResult phaseResult = Phases.FindAndRemove(Query.EQ("_id", id), SortBy.Ascending("_id"));
return(phaseResult.Ok);
}
// <summary>
/// Deletes the role with the specified id
/// </summary>
/// <param name="roleId">Id of the role to delete</param>
/// <returns>Result of the operation, true if was ok</returns>
public bool Delete(ObjectId roleId)
{
Role role = Roles.FindOneById(roleId);
FindAndModifyResult userRoleResult = UserRoles.FindAndRemove(Query.EQ("Role", role.Name), SortBy.Ascending("_id"));
FindAndModifyResult roleResult = Roles.FindAndRemove(Query.EQ("_id", roleId), SortBy.Ascending("_id"));
return(roleResult.Ok && userRoleResult.Ok);
}
/// <summary>
/// Deletes the user with the specified id
/// </summary>
/// <param name="userId">User to be deleted id</param>
/// <returns>Result of the operation, true if was ok</returns>
public bool Delete(ObjectId userId)
{
User user = Users.FindOneById(userId);
FindAndModifyResult userRoleResult = UserRoles.FindAndRemove(Query.EQ("Username", user.Username), SortBy.Ascending("_id"));
FindAndModifyResult result = Users.FindAndRemove(Query.EQ("_id", userId), SortBy.Ascending("_id"));
return(result.Ok && userRoleResult.Ok);
}
public bool UpdateSubsription(Subscription subscription)
{
var query = Query.And(Query.EQ("Email", subscription.EmailId));
var update = MongoDB.Driver.Builders.Update.Set("Allow", subscription.Allow);
var sortBy = SortBy.Descending("Email");
FindAndModifyResult result = emailCollection.FindAndModify(query, sortBy, update, true);
return(result.Ok);
}
public bool Update(Metric2 Metric)
{
var query = Query.And(Query.EQ("Name", Metric.Name), Query.EQ("Identifier", Metric.Identifier));
var update = MongoDB.Driver.Builders.Update.Inc("Count", 1).Inc("Total", Metric.Total);
var sortBy = SortBy.Descending("Name");
FindAndModifyResult result = collection2.FindAndModify(query, sortBy, update, true);
return(result.Ok);
}
public long GenerateId()
{
bool lockTaken = false;
try
{
// Entering single-thread block
_lock.Enter(ref lockTaken);
// Incrementing id if it belongs to reserved block
if (_isIdBlockReserved && ++_idBlockOffset < IdBlockLength)
{
return(_idBlockBegin + _idBlockOffset);
}
// Reserving new id block as atomic operation
MongoCollection <SequenceEntity> sequenceCollection = _sequenceRepository.Collection;
IMongoQuery query = Query.EQ("Name", TrackingUrlSequenceName);
IMongoSortBy sortBy = SortBy.Null;
UpdateBuilder update = Update.Inc("Current", IdBlockLength);
var argument = new FindAndModifyArgs {
Query = query, SortBy = sortBy, Update = update, VersionReturned = FindAndModifyDocumentVersion.Modified
};
FindAndModifyResult result = sequenceCollection.FindAndModify(argument);
BsonDocument sequence = result.ModifiedDocument;
if (sequence == null)
{
// first block
_idBlockBegin = 0;
_idBlockOffset = 0;
sequenceCollection.Insert(new SequenceEntity {
Name = TrackingUrlSequenceName, Current = 0
});
}
else
{
_idBlockBegin = sequence.GetValue("Current").AsInt64;
_idBlockOffset = 0;
}
_isIdBlockReserved = true;
long newId = _idBlockBegin + _idBlockOffset;
return(newId);
}
finally
{
if (lockTaken)
{
// Exiting single-thread block
_lock.Exit();
}
}
}
private Counters IncCounter(string counterName)
{
var CountersCollection = mongoDatabase.GetCollection <Counters>(Counters_Col);
var incId = Update.Inc(counterName, 1);
var query = Query.Null;
FindAndModifyResult counterIncResult = CountersCollection.FindAndModify(query, SortBy.Null, incId, true);
Counters updatedCounters = counterIncResult.GetModifiedDocumentAs <Counters>();
return(updatedCounters);
}
public TimeoutsBatch GetTimeoutsBatch()
{
var retval = new TimeoutsBatch {
DueTimeouts = new List <TimeoutData>()
};
MongoCollection <TimeoutData> collection = _mongoDatabase.GetCollection <TimeoutData>(TimeoutsCollectionName);
DateTime utcNow = DateTime.UtcNow;
// Find all the due timeouts and put a lock on each one to prevent multiple threads/processes getting hold of the same data.
bool doQuery = true;
while (doQuery)
{
var args = new FindAndModifyArgs
{
Query = Query.And(Query.EQ("Locked", false), Query.LTE("Time", utcNow)),
Update = Update <TimeoutData> .Set(c => c.Locked, true),
Upsert = false,
VersionReturned = FindAndModifyDocumentVersion.Original
};
FindAndModifyResult result = collection.FindAndModify(args);
if (result.ModifiedDocument == null)
{
doQuery = false;
}
else
{
retval.DueTimeouts.Add(result.GetModifiedDocumentAs <TimeoutData>());
}
}
// Get next query time
var nextQueryTime = DateTime.MaxValue;
var upcomingTimeoutsRes = collection.Find(Query.GT("Time", utcNow));
foreach (TimeoutData upcomingTimeout in upcomingTimeoutsRes)
{
if (upcomingTimeout.Time < nextQueryTime)
{
nextQueryTime = upcomingTimeout.Time;
}
}
if (nextQueryTime == DateTime.MaxValue)
{
nextQueryTime = utcNow.AddMinutes(1);
}
retval.NextQueryTime = nextQueryTime;
return(retval);
}
private Counters IncCounter(string counterName)
{
var CountersCollection = mongoDatabase.GetCollection <Counters>(Counters_Col);
var args = new FindAndModifyArgs()
{
Query = Query.Null, SortBy = SortBy.Null, Update = Update.Inc(counterName, 1), Upsert = true
};
FindAndModifyResult counterIncResult = CountersCollection.FindAndModify(args);
Counters updatedCounters = counterIncResult.GetModifiedDocumentAs <Counters>();
return(updatedCounters);
}
public void LogResult(FindAndModifyResult result)
{
if (_writeToFile == null)
{
return;
}
_writeToFile.Write(" result {0}", result.Ok ? "ok" : "");
if (result.ErrorMessage != null)
{
_writeToFile.Write(" error \"{0}\"", result.ErrorMessage);
}
_writeToFile.WriteLine();
_writeToFile.WriteLine("document");
_writeToFile.WriteLine(result.ModifiedDocument.zToJson());
}
private static MongoCollection <BsonDocument> UpdateCapital(MongoDatabase mongoDatabase, string oldName, string newName)
{
MongoCollection <BsonDocument> capitals = mongoDatabase.GetCollection <BsonDocument>("Capital");
FindAndModifyArgs args = new FindAndModifyArgs()
{
Query = Query.EQ("State", oldName),
Update = Update.Set("State", newName),
Upsert = false,
SortBy = null,
VersionReturned = FindAndModifyDocumentVersion.Original,
};
FindAndModifyResult res = capitals.FindAndModify(args);
return(capitals);
}
public async void FindAndModifyAsyncTest3()
{
string entryMessage1 = "entry 1";
AddMongoEntry(entryMessage1, MONGO_COLLECTION_1_NAME);
List <Entry> results = new List <Entry>(_collectionReader.Read <Entry>("TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(entryMessage1, results[0].Message);
var searchQuery = Query.EQ("Message", "some message that won't be found by the query");
var update = Update.Set("Message", MONGO_EDITED_TEXT);
var sortBy = SortBy.Descending("TimeStamp");
FindAndModifyArgs findAndModifyArgs = new FindAndModifyArgs();
findAndModifyArgs.Query = searchQuery;
findAndModifyArgs.SortBy = sortBy;
findAndModifyArgs.Update = update;
findAndModifyArgs.Upsert = true;
findAndModifyArgs.VersionReturned = FindAndModifyDocumentVersion.Modified;
FindAndModifyResult result = await _collectionUpdater.FindAndModifyAsync <Entry>(findAndModifyArgs);
Assert.IsNotNull(result);
Assert.IsTrue(result.Ok);
Assert.IsNull(result.ErrorMessage);
Assert.IsNotNull(result.ModifiedDocument);
findAndModifyArgs = new FindAndModifyArgs();
findAndModifyArgs.Query = searchQuery;
findAndModifyArgs.SortBy = sortBy;
findAndModifyArgs.Update = update;
findAndModifyArgs.Upsert = false;
result = await _collectionUpdater.FindAndModifyAsync <Entry>(findAndModifyArgs);
Assert.IsNotNull(result);
Assert.IsTrue(result.Ok);
Assert.IsNull(result.ErrorMessage);
Assert.IsNull(result.ModifiedDocument);
results = new List <Entry>(_collectionReader.Read <Entry>("TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(entryMessage1, results[0].Message);
}
public long Next()
{
var query = Query.EQ("_id", BsonValue.Create(CounterName));
var sort = SortBy.Ascending("_id");
var update = MDBUpdate.Inc("Count", 1);
FindAndModifyResult result = Collection.FindAndModify(query, sort, update, true);
if (result.ModifiedDocument == null)
{
AddInitialEntry();
result = Collection.FindAndModify(query, sort, update, true);
}
if (result.ModifiedDocument == null)
{
throw new InvalidOperationException(string.Format("Failed to update counter '{0}'.", CounterName));
}
return(result.ModifiedDocument.GetValue("Count").ToInt64());
}
public string Next(string name)
{
var collection = database.GetCollection(Collection.COUNTERS);
FindAndModifyArgs args = new FindAndModifyArgs();
args.Query = MonQ.Query.EQ("_id", name);
args.Update = MonQ.Update.Inc(Field.COUNTERVALUE, 1);
args.Fields = MonQ.Fields.Include(Field.COUNTERVALUE);
args.Upsert = true;
args.VersionReturned = FindAndModifyDocumentVersion.Modified;
FindAndModifyResult result = collection.FindAndModify(args);
BsonDocument document = result.ModifiedDocument;
string value = document[Field.COUNTERVALUE].AsInt32.ToString();
return(value);
}
public override BsonValue GetNewId()
{
MongoCollection collection = GetCollection();
// on utilise FindAndModify pour
FindAndModifyResult result = collection.zFindAndModify(new QueryDocument {
{ "_id", 0 }
}, new UpdateDocument {
{ "$inc", new BsonDocument {
{ "LastId", 1 }
} }
}, upsert: true);
// ATTENTION result.ModifiedDocument est le document avant update donc il faut faire + 1
// si result.ModifiedDocument est null le document _id 0 n'existait pas, il est créé (upsert: true) après update on a { _id: 0, LastId: 1 }
int id = 1;
if (result.ModifiedDocument != null)
{
id = result.ModifiedDocument["LastId"].AsInt32 + 1;
}
return(BsonValue.Create(id));
}
public MongoPersistenceEngine(MongoDatabase store, IDocumentSerializer serializer)
{
if (store == null)
{
throw new ArgumentNullException("store");
}
if (serializer == null)
{
throw new ArgumentNullException("serializer");
}
_store = store;
_serializer = serializer;
_commitSettings = new MongoCollectionSettings {
AssignIdOnInsert = false, WriteConcern = WriteConcern.Acknowledged
};
_snapshotSettings = new MongoCollectionSettings {
AssignIdOnInsert = false, WriteConcern = WriteConcern.Unacknowledged
};
_streamSettings = new MongoCollectionSettings {
AssignIdOnInsert = false, WriteConcern = WriteConcern.Unacknowledged
};
_countersSettings = new MongoCollectionSettings {
AssignIdOnInsert = false, WriteConcern = WriteConcern.Acknowledged
};
_getNextCheckpointNumber = () => TryMongo(() =>
{
IMongoQuery query = Query.And(Query.EQ("_id", "CheckpointNumber"));
IMongoUpdate update = Update.Inc("seq", 1);
FindAndModifyResult result = Counters.FindAndModify(query, null, update, true);
return(result.ModifiedDocument["seq"].ToInt32());
});
}
protected void CallbackFindAndModify(IAsyncResult asyncRes)
{
FindAndModifyResult result = null;
Exception exception = null;
try
{
try
{
AsyncResult ares = (AsyncResult)asyncRes;
var delg = (dynamic)ares.AsyncDelegate;
result = delg.EndInvoke(asyncRes);
}
catch (Exception ex)
{
// if an exception is caught here the dynamic binding of the "result" variable is unresolved thus causing a
// RuntimeTypeBindingException to be raised. The problem is that in this scenario - complicated to determine which
// sort of action originally invoked the async call -- making notification of the error problematic...
exception = ex;
}
finally
{
if (AsyncFindAndModifyCompleted != null)
{
AsyncFindAndModifyCompleted(result);
}
}
}
catch (RuntimeBinderException ex)
{
// TODO: add ex handling!
if (AsyncFindAndModifyCompleted != null)
{
AsyncFindAndModifyCompleted(result);
}
}
}
public void UpdateJobByIDAndRemove()
{
string dt = DateTime.Now.ToString();
ObjectId oid = ObjectId.GenerateNewId();
Job job = new Job
{
_id = oid
,
ScriptFileName = "scriptname.bteq"
,
ProjectName = "TestRun"
,
LastModified = DateTime.Now.AddHours(-1).ToString()
};
MongoDatabase localDB = MongoSrvr.GetDatabase("PMG");
MongoCollection <Job> jobCol = localDB.GetCollection <Job>("Test");
WriteConcernResult res = jobCol.Insert <Job>(job);
Assert.IsTrue(res.Ok);
IMongoQuery query = Query.EQ("_id", oid);
IMongoSortBy sortBy = SortBy.Null;
IMongoUpdate update = Update.Set("LastModified", dt);
MongoCollection jobsColl = localDB.GetCollection("Test");
FindAndModifyResult result = jobsColl.FindAndModify(query, sortBy, update, true);
Job modJob = result.GetModifiedDocumentAs <Job>();
Assert.AreEqual(modJob.LastModified, dt);
//cleanup
res = jobCol.Remove(Query.EQ("_id", oid), RemoveFlags.Single, WriteConcern.Acknowledged);
Assert.IsTrue(res.Ok);
}
protected void _updaterAsyncT_AsyncFindAndModifyCompleted(FindAndModifyResult result)
{
_findAndModifyResult = result;
_updaterAutoResetEvent.Set();
}
public static string UpdateOneProduct(string oldProduct, string newProduct, string option)
{
string connectstring1 = "mongodb://*****:*****@ds149433.mlab.com:49433/corevisesdb";
MongoClient client = new MongoClient(connectstring1);
MongoServer ms = client.GetServer();
MongoDatabase db = ms.GetDatabase("corevisesdb");
var collection = db.GetCollection <product>("producto");
FindAndModifyArgs args;
string result = "Hubo un error al actualizar el producto";
switch (option)
{
case "name":
args = new FindAndModifyArgs()
{
Query = Query.EQ("code", oldProduct),
Update = Update.Set("name", newProduct),
Upsert = false,
SortBy = null,
VersionReturned = FindAndModifyDocumentVersion.Original,
};
FindAndModifyResult res = collection.FindAndModify(args);
result = "el nombre se actualizo";
break;
case "img":
args = new FindAndModifyArgs()
{
Query = Query.EQ("code", oldProduct),
Update = Update.Set("img", newProduct),
Upsert = false,
SortBy = null,
VersionReturned = FindAndModifyDocumentVersion.Original,
};
result = "la imagen se actualizo";
break;
case "price":
args = new FindAndModifyArgs()
{
Query = Query.EQ("code", oldProduct),
Update = Update.Set("price", newProduct),
Upsert = false,
SortBy = null,
VersionReturned = FindAndModifyDocumentVersion.Original,
};
result = "el precio se actualizo";
break;
case "stock":
args = new FindAndModifyArgs()
{
Query = Query.EQ("code", oldProduct),
Update = Update.Set("stock", newProduct),
Upsert = false,
SortBy = null,
VersionReturned = FindAndModifyDocumentVersion.Original,
};
result = "stock se actualizo";
break;
default:
Console.WriteLine("Default case");
break;
}
//obtenemos la coleccion en la que vamos a almacenar el objeto
return(result);
}
public FindAndModifyUpdateResult(FindAndModifyResult result)
{
Result = result;
}
/// <summary>
/// Find existing instance of ProcessManager
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="mapper"></param>
/// <param name="message"></param>
/// <returns></returns>
public IPersistanceData <T> FindData <T>(IProcessManagerPropertyMapper mapper, Message message) where T : class, IProcessManagerData
{
if (message is StartProcessManagerMessage)
{
return(null);
}
var mapping = mapper.Mappings.FirstOrDefault(m => m.MessageType == message.GetType()) ??
mapper.Mappings.First(m => m.MessageType == typeof(Message));
var collectionName = typeof(T).Name;
MongoCollection <T> collection = _mongoDatabase.GetCollection <T>(collectionName);
object msgPropValue = mapping.MessageProp.Invoke(message);
if (null == msgPropValue)
{
throw new ArgumentException("Message property expression evaluates to null");
}
//Left
ParameterExpression pe = Expression.Parameter(typeof(MyMongoData <T>), "t");
Expression left = Expression.Property(pe, typeof(MyMongoData <T>).GetTypeInfo().GetProperty("Data"));
foreach (var prop in mapping.PropertiesHierarchy.Reverse())
{
left = Expression.Property(left, left.Type, prop.Key);
}
//Right
Expression right = Expression.Constant(msgPropValue, msgPropValue.GetType());
Expression expression;
try
{
expression = Expression.Equal(left, right);
}
catch (InvalidOperationException ex)
{
throw new Exception("Mapped incompatible types of ProcessManager Data and Message properties.", ex);
}
var lambda = Expression.Lambda <Func <MyMongoData <T>, bool> >(expression, pe);
IMongoQuery query = Query <MyMongoData <T> > .Where(lambda);
// check if data is locked
FindAndModifyResult result = collection.FindAndModify(new FindAndModifyArgs
{
Query = Query.And(
Query.Or(
Query.EQ("Locked", false),
Query.LTE("LockTimeout", DateTime.UtcNow)
),
query
),
Update = Update.Combine(
Update.Set("Locked", true),
Update.Set("LockTimeout", DateTime.UtcNow.AddSeconds(30))
)
});
if (result.ModifiedDocument == null)
{
// spin until lock is released
while (true)
{
result = collection.FindAndModify(new FindAndModifyArgs
{
Query = Query.And(
Query.Or(
Query.EQ("Locked", false),
Query.LTE("LockTimeout", DateTime.UtcNow)
),
query
),
Update = Update.Combine(
Update.Set("Locked", true),
Update.Set("LockTimeout", DateTime.UtcNow.AddSeconds(30))
)
});
// Found unlocked data
if (result.ModifiedDocument != null)
{
break;
}
Thread.Sleep(100);
}
}
return(result.GetModifiedDocumentAs <MyMongoData <T> >());
}
// <summary>
/// Deletes the user/role association with the specified id
/// </summary>
/// <param name="userRoleId">Id of the user/role to delete</param>
/// <returns>Result of the operation, true if was ok</returns>
public bool Delete(ObjectId userRoleId)
{
FindAndModifyResult result = UserRoles.FindAndRemove(Query.EQ("_id", userRoleId), SortBy.Ascending("_id"));
return(result.Ok);
}
public FindAndModifyUpdateResult(FindAndModifyResult result)
{
Result = result;
}
/// <summary>
/// Internal utility for obtaining blocks of unique OIDs for insertion
/// Call CatalogDatasetEntry.GetNextOID() to get OIDs if writing a dataloader
/// </summary>
/// <param name="Name">Name of the Dataset</param>
/// <param name="count">the size of the block requested</param>
/// <returns>A FIFO block of OIDs</returns>
internal Queue <int> GetOIDSet(string Name, int count = OIDCHECKOUT)
{
IMongoQuery query = Query.EQ("Name", BsonValue.Create(Name));
int currCount = 0;
int oidCheckOutTry = 0;
// we are going to try and get and update the shared OID resource
// this is a necessary choke point, but the implementation can be improved
// particularly for multi-client high volume inserts
// we repeat try a few times and then fail for good - can't get a lock on
// the oid set
for (; oidCheckOutTry < OIDCHECKOUTTRYLIMIT; oidCheckOutTry++)
{
try
{
BsonDocument doc = m_Conn[GDB_ITEMS].FindOne(query);
if (default(BsonDocument) == doc)
{
throw new COMException("missing metadata doc " + Name);
}
try
{
var next_oid = doc.GetElement("NEXT_OID");
currCount = esriBsonUtilities.BsonToInt(next_oid);
}
catch (Exception)
{
currCount = 0;
}
// include prev corr oid as condition
IMongoQuery query2 = Query.EQ("NEXT_OID", BsonValue.Create(currCount));
int newCount = currCount + count;
query = Query.And(new IMongoQuery[2] {
query, query2
});
// atomic find and update - fails if the NEXT_OID has been updated by another client
FindAndModifyResult res = m_Conn[GDB_ITEMS].FindAndModify(query, null, Update.Set("NEXT_OID", BsonValue.Create(newCount)), true, false);
// if it's been updated out from under us
if (default(FindAndModifyResult) == res)
{
System.Threading.Thread.Sleep(SLEEPTIME_OIDCHECKOUT);
continue;
}
break;
}
catch (Exception) // if it's been updated out from under us
{
System.Threading.Thread.Sleep(SLEEPTIME_OIDCHECKOUT);
continue;
}
}
// we failed to get a block of new oids
if (oidCheckOutTry == OIDCHECKOUTTRYLIMIT)
{
throw new COMException("Could not secure OIDs");
}
Queue <int> retVal = new Queue <int>(count);
for (int i = currCount; i < (currCount + count); i++)
{
retVal.Enqueue(i);
}
return(retVal);
}
public bool Delete(ObjectId id)
{
FindAndModifyResult phaseResult = Sponsors.FindAndRemove(Query.EQ("_id", id), SortBy.Ascending("_id"));
return(phaseResult.Ok);
}
