public async Task CreateLocationIndex()
{
var builder = Builders <User> .IndexKeys;
var indexModel = new CreateIndexModel <User>(builder.Geo2DSphere(u => u.Location));
await _database.GetCollection <User>(nameof(User)).Indexes
.CreateOneAsync(indexModel);
}
/// <summary>
/// Created index if not created
/// </summary>
/// <param name="connectionString">Connection string</param>
/// <param name="database">Database</param>
/// <returns></returns>
public async Task Init(string connectionString, string database)
{
var client = new MongoClient(connectionString);
var db = client.GetDatabase(database);
var roomsIndexKeyBuilder = Builders <Room> .IndexKeys;
var compoundIndex = roomsIndexKeyBuilder.Ascending(x => x.RoomId).Ascending(x => x.PropertyId);
var indexModel = new CreateIndexModel <Room>(compoundIndex, new CreateIndexOptions()
{
Name = COMPOUND_INDEX, Background = true, Unique = true
});
var existingIndexes = await(await db.GetCollection <Room>("rooms").Indexes.ListAsync()).ToListAsync();
bool hasCompoundIndex = false;
foreach (var index in existingIndexes.Where(index => index.Values.Any(x => x.Equals(COMPOUND_INDEX))))
{
hasCompoundIndex = true;
}
if (!hasCompoundIndex)
{
await db.GetCollection <Room>("rooms").Indexes.CreateOneAsync(indexModel);
}
}
public static void EnsureIndexes(MongoContext ctx)
{
var dateOrderIndex = new CreateIndexModel <EntranceLogEntry>(
Builders <EntranceLogEntry> .IndexKeys.Descending(e => e.EntranceDate));
ctx.EntranceLogEntries.Indexes.CreateOne(dateOrderIndex);
}
public virtual void CreateSignalDispatchHistoryIndex(TimeSpan?historyExpirationTime)
{
var receiverIndex = Builders <SignalDispatch <ObjectId> > .IndexKeys
.Ascending(p => p.ReceiverSubscriberId)
.Ascending(p => p.SendDateUtc);
var receiverOptions = new CreateIndexOptions()
{
Unique = false
};
var receiverModel = new CreateIndexModel <SignalDispatch <ObjectId> >(receiverIndex, receiverOptions);
var ttlIndex = Builders <SignalDispatch <ObjectId> > .IndexKeys
.Ascending(p => p.CreateDateUtc);
CreateIndexOptions ttlOptions = new CreateIndexOptions()
{
Name = "CreateDateUtc TTL",
Unique = false,
ExpireAfter = historyExpirationTime
};
var ttlModel = new CreateIndexModel <SignalDispatch <ObjectId> >(ttlIndex, ttlOptions);
IMongoCollection <SignalDispatch <ObjectId> > collection = _context.SignalDispatchesHistory;
string receiverName = collection.Indexes.CreateOne(receiverModel);
if (historyExpirationTime != null)
{
string ttlName = collection.Indexes.CreateOne(ttlModel);
}
}
public virtual void CreateSubscriberTopicSettingsIndex()
{
IndexKeysDefinition <SubscriberTopicSettings <ObjectId> > topicIndex = Builders <SubscriberTopicSettings <ObjectId> > .IndexKeys
.Ascending(p => p.CategoryId)
.Ascending(p => p.TopicId);
CreateIndexOptions topicOptions = new CreateIndexOptions()
{
Unique = false
};
var topicModel = new CreateIndexModel <SubscriberTopicSettings <ObjectId> >(topicIndex, topicOptions);
IndexKeysDefinition <SubscriberTopicSettings <ObjectId> > subscriberIndex = Builders <SubscriberTopicSettings <ObjectId> > .IndexKeys
.Ascending(p => p.SubscriberId);
CreateIndexOptions subscriberOptions = new CreateIndexOptions()
{
Unique = false
};
var subscriberModel = new CreateIndexModel <SubscriberTopicSettings <ObjectId> >(subscriberIndex, subscriberOptions);
IMongoCollection <SubscriberTopicSettings <ObjectId> > collection = _context.SubscriberTopicSettings;
string topicName = collection.Indexes.CreateOne(topicModel);
string subscriberName = collection.Indexes.CreateOne(subscriberModel);
}
public async Task CreateIndex()
{
var chunkIndexModel = new CreateIndexModel <Node>(Builders <Node> .IndexKeys.Ascending(x => x.Chunk));
var idIndexModel = new CreateIndexModel <Node>(Builders <Node> .IndexKeys.Ascending(x => x.OsmId));
await _nodes.Indexes.CreateOneAsync(chunkIndexModel);
await _nodes.Indexes.CreateOneAsync(idIndexModel);
}
/// <inheritdoc/>
public async Task <string> CreateOneIndexAsync(IndexKeysDefinition <T> keys, CreateIndexOptions options, CancellationToken cancellationToken = default)
{
var database = client.GetDatabase(databaseName);
var myCollection = database.GetCollection <T>(collectionName);
var index = new CreateIndexModel <T>(keys, options);
return(await myCollection.Indexes.CreateOneAsync(index, cancellationToken : cancellationToken).ConfigureAwait(false));
}
private void CreateIndex()
{
var indexKeys = Builders <MessageOutboxEntity> .IndexKeys.Ascending(message => message.IsProcessed);
var indexModel = new CreateIndexModel <MessageOutboxEntity>(indexKeys);
messages.Indexes.CreateOne(indexModel);
}
protected override void EnsureIndexes()
{
var indexKeys = Builders <Topic> .IndexKeys.Ascending(_ => _.Name);
var indexModel = new CreateIndexModel <Topic>(indexKeys);
Collection.Indexes.CreateOneAsync(indexModel);
}
/// <inheritdoc />
public Task <string> EnsureIndexCreatedAsync()
{
var keys = Builders <Location> .IndexKeys.Geo2DSphere(z => z.Geometry);
var model = new CreateIndexModel <Location>(keys);
return(_collection.Indexes.CreateOneAsync(model));
}
public static async Task CreateIndex <T>(this IMongoDatabase database,
Func <IndexKeysDefinitionBuilder <T>, IndexKeysDefinition <T> > buildIndex)
{
var notificationLogBuilder = Builders <T> .IndexKeys;
var collection = database.GetCollection <T>(typeof(T).Name);
var indexModel = new CreateIndexModel <T>(buildIndex?.Invoke(notificationLogBuilder));
await collection.Indexes.CreateOneAsync(indexModel).ConfigureAwait(false);
}
public Task CreateIndex(string elementName)
{
IndexKeysDefinition <T> keys = Builders <T> .IndexKeys.Ascending(elementName);
CreateIndexModel <T> index = new CreateIndexModel <T>(keys);
return(Collection.Indexes.CreateOneAsync(index));
}
/// <summary>
/// MongoDB provides text indexes to support text search queries on string content.
/// Text indexes can include any field whose value is a string or an array of string elements.
/// </summary>
public virtual void CreateIndex()
{
var filter = Builders <TEntity> .IndexKeys.Text("$**");
var indexModel = new CreateIndexModel <TEntity>(filter);
_collection.Indexes.CreateOne(indexModel);
}
/// <inheritdoc />
public virtual async Task Index(
IndexKeysDefinition <TSchema> key,
CreateIndexOptions <TSchema> options = null)
{
var model = new CreateIndexModel <TSchema>(key, options ?? new CreateIndexOptions());
await this.Collection.Indexes.CreateOneAsync(model);
}
protected override void PreStart()
{
base.PreStart();
_mongoDatabase = new Lazy <IMongoDatabase>(() =>
{
var connectionString = new MongoUrl(_settings.ConnectionString);
var client = new MongoClient(connectionString);
return(client.GetDatabase(connectionString.DatabaseName));
});
_journalCollection = new Lazy <IMongoCollection <JournalEntry> >(() =>
{
var collection = _mongoDatabase.Value.GetCollection <JournalEntry>(_settings.Collection);
if (_settings.AutoInitialize)
{
var modelForEntryAndSequenceNr = new CreateIndexModel <JournalEntry>(Builders <JournalEntry>
.IndexKeys
.Ascending(entry => entry.PersistenceId)
.Descending(entry => entry.SequenceNr));
collection.Indexes
.CreateOneAsync(modelForEntryAndSequenceNr, cancellationToken: CancellationToken.None)
.Wait();
var modelWithOrdering = new CreateIndexModel <JournalEntry>(
Builders <JournalEntry>
.IndexKeys
.Ascending(entry => entry.Ordering));
collection.Indexes
.CreateOne(modelWithOrdering);
}
return(collection);
});
_metadataCollection = new Lazy <IMongoCollection <MetadataEntry> >(() =>
{
var collection = _mongoDatabase.Value.GetCollection <MetadataEntry>(_settings.MetadataCollection);
if (_settings.AutoInitialize)
{
var modelWithAscendingPersistenceId = new CreateIndexModel <MetadataEntry>(
Builders <MetadataEntry>
.IndexKeys
.Ascending(entry => entry.PersistenceId));
collection.Indexes
.CreateOneAsync(modelWithAscendingPersistenceId, cancellationToken: CancellationToken.None)
.Wait();
}
return(collection);
});
}
private void ConfigureIndexes()
{
IndexKeysDefinition <ProjectInfo> keys = Builders <ProjectInfo> .IndexKeys
.Text(x => x.ProjectName)
.Text(x => x.ProjectDescription)
.Text(x => x.AssemblyName)
.Text(x => x.ProjectUri)
.Text(x => x.Tags)
.Text($"{nameof(ProjectInfo.Components)}.{nameof(ComponentManifest.Name)}")
.Text($"{nameof(ProjectInfo.Components)}.{nameof(ComponentManifest.Description)}")
.Text($"{nameof(ProjectInfo.Components)}.{nameof(ComponentManifest.DocumentationUri)}")
.Text($"{nameof(ProjectInfo.Components)}.{nameof(ComponentManifest.Tags)}")
;
CreateIndexModel <ProjectInfo> indexModel = new CreateIndexModel <ProjectInfo>(keys, new CreateIndexOptions()
{
Weights = new BsonDocument(
new Dictionary <string, object>()
{
//high priority
{ nameof(ProjectInfo.ProjectName), 10 },
{ nameof(ProjectInfo.AssemblyName), 10 },
{ nameof(ProjectInfo.Tags), 10 },
{ $"{nameof(ProjectInfo.Components)}.{nameof(ComponentManifest.Name)}", 10 },
{ $"{nameof(ProjectInfo.Components)}.{nameof(ComponentManifest.Tags)}", 10 },
//medium priority
{ nameof(ProjectInfo.ProjectDescription), 5 },
{ $"{nameof(ProjectInfo.Components)}.{nameof(ComponentManifest.Description)}", 5 },
{ $"{nameof(ProjectInfo.Components)}.{nameof(ComponentManifest.Properties)}.{nameof(Property.Value)}", 5 },
{ $"{nameof(ProjectInfo.Components)}.{nameof(ComponentManifest.Properties)}.{nameof(Property.ValueList)}", 5 },
{ $"{nameof(ProjectInfo.Properties)}.{nameof(Property.Value)}", 5 },
{ $"{nameof(ProjectInfo.Properties)}.{nameof(Property.ValueList)}", 5 },
//low priority
{ nameof(ProjectInfo.ProjectUri), 3 },
{ nameof(ProjectInfo.DocumentationUri), 3 },
{ nameof(ProjectInfo.DownloadLocation), 3 },
{ $"{nameof(ProjectInfo.Components)}.{nameof(ComponentManifest.DocumentationUri)}", 3 },
}
)
});
this.projects.Indexes.CreateOne(indexModel);
this.repositories.Indexes.CreateOne(
new CreateIndexModel <RepositoryInfo>(
Builders <RepositoryInfo> .IndexKeys
.Ascending(r => r.OrganizationName)
.Ascending(r => r.RepositoryName), new CreateIndexOptions()
{
Sparse = true,
Unique = true
}
)
);
}
/// <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
{
var mapping = mapper.Mappings.FirstOrDefault(m => m.MessageType == message.GetType()) ??
mapper.Mappings.First(m => m.MessageType == typeof(Message));
var collectionName = typeof(T).Name;
IMongoCollection <MongoDbSslData <T> > collection = _mongoDatabase.GetCollection <MongoDbSslData <T> >(collectionName);
var indexOptions = new CreateIndexOptions();
var indexKeys = Builders <MongoDbSslData <T> > .IndexKeys.Ascending("Data.CorrelationId");
var indexModel = new CreateIndexModel <MongoDbSslData <T> >(indexKeys, indexOptions);
collection.Indexes.CreateOne(indexModel);
object msgPropValue = null;
try
{
msgPropValue = mapping.MessageProp.Invoke(message);
}
catch
{
return(null);
}
if (null == msgPropValue)
{
throw new ArgumentException("Message property expression evaluates to null");
}
//Left
ParameterExpression pe = Expression.Parameter(typeof(MongoDbSslData <T>), "t");
Expression left = Expression.Property(pe, typeof(MongoDbSslData <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);
}
Expression <Func <MongoDbSslData <T>, bool> > lambda = Expression.Lambda <Func <MongoDbSslData <T>, bool> >(expression, pe);
return(collection.AsQueryable().FirstOrDefault(lambda));
}
/// <summary>
/// Creates the index.
/// </summary>
private void CreateIndex()
{
var indexOptions = new CreateIndexOptions();
var indexKeys = Builders <Adviser> .IndexKeys.Ascending(adviser => adviser.UserDetails.Name);
var indexModelName = new CreateIndexModel <Adviser>(indexKeys, indexOptions);
DbSet.Indexes.CreateOne(indexModelName);
}
public CommentContext(IOptions <Settings> settings)
{
var client = new MongoClient(settings.Value.ConnectionString);
_database = client.GetDatabase(settings.Value.Database);
var indexModel = new CreateIndexModel <PostComment>(Builders <PostComment> .IndexKeys.Ascending(c => c.PostId));
PostComments.Indexes.CreateOne(indexModel);
}
/*Build indexes on UserName field */
public void BuildIndex()
{
System.Console.WriteLine("Building indexes - standby");
var indexBuilder = Builders <TwitterData> .IndexKeys;
var indexmodel = new CreateIndexModel <TwitterData>(indexBuilder.Ascending(x => x.UserName));
collection.Indexes.CreateOne(indexmodel);
System.Console.WriteLine("Done building indexes");
}
public async Task CreateIndexes()
{
//store id index
var menuCollection = db.GetCollection <Menu>();
var storeIdIndex = Builders <Menu> .IndexKeys.Ascending(x => x.StoreId);
var storeIdModel = new CreateIndexModel <Menu>(storeIdIndex);
await menuCollection.Indexes.CreateOneAsync(storeIdModel);
}
static async Task SetIndexes()
{
var indexKeysDefinition = Builders <Location> .IndexKeys.Combine(
Builders <Location> .IndexKeys.Ascending(x => x.VehicleId),
Builders <Location> .IndexKeys.Ascending(x => x.UpdateDate));
var indexModel = new CreateIndexModel <Location>(indexKeysDefinition);
await context.Locations.Indexes.CreateOneAsync(indexModel);
}
/// <summary>
/// Creates index on defined field.
/// </summary>
public async Task CreateIndexOnCollection(IMongoCollection <BsonDocument> collection, string field)
{
//var keys = Builders<BsonDocument>.IndexKeys.Ascending(field);
//await collection.Indexes.CreateOneAsync(keys);
var keys = Builders <BsonDocument> .IndexKeys;
var indexModel = new CreateIndexModel <BsonDocument>(keys.Ascending(field));
await collection.Indexes.CreateOneAsync(indexModel).ConfigureAwait(false);
}
public static string CreateIndex <TDocument>(this IMongoCollection <TDocument> collection, Expression <Func <TDocument, object> > field)
{
var keys = Builders <TDocument> .IndexKeys.Ascending(field);
var options = new CreateIndexOptions();
var model = new CreateIndexModel <TDocument>(keys, options);
return(collection.Indexes.CreateOne(model));
}
/// <summary>
/// Creates index on Name field.
/// </summary>
public async Task CreateIndexOnNameField()
{
//var keys = Builders<User>.IndexKeys.Ascending(x => x.Name);
//await _usersCollection.Indexes.CreateOneAsync(keys).ConfigureAwait(false);
var keys = Builders <User> .IndexKeys;
var indexModel = new CreateIndexModel <User>(keys.Ascending(x => x.Name));
await _usersCollection.Indexes.CreateOneAsync(indexModel).ConfigureAwait(false);
}
/// <summary>
/// 添加索引
/// </summary>
public async Task AddIndex <T>(FieldDefinition <T> field)
{
var indexOptions = new CreateIndexOptions();
var indexKeys = Builders <T> .IndexKeys.Ascending(field);
var indexModel = new CreateIndexModel <T>(indexKeys, indexOptions);
await GetCollection <T>().Indexes.CreateOneAsync(indexModel);
}
private static void EnsureExpireIndexOnTimeStamp(IMongoCollection <BsonDocument> collection, TimeSpan expireAfter)
{
var model = new CreateIndexModel <BsonDocument>(Builders <BsonDocument> .IndexKeys.Ascending(RequestProperties.TIMESTAMP_UTC),
new CreateIndexOptions {
Background = true, ExpireAfter = expireAfter
});
collection.Indexes.CreateOneAsync(model);
}
protected override Task PrepareAsync(CancellationToken ct = default)
{
var index =
new CreateIndexModel <MongoContentEntity>(Index
.Ascending(x => x.ScheduledAt)
.Ascending(x => x.IsDeleted));
return(Collection.Indexes.CreateOneAsync(index, cancellationToken: ct));
}
public async Task EnsureIndex()
{
await _context.Posts.Indexes.DropAllAsync();
var index = Builders <BlogPostModel> .IndexKeys.Text(x => x.Body);
var indexModel = new CreateIndexModel <BlogPostModel>(index);
await _context.Posts.Indexes.CreateOneAsync(indexModel);
}
/// <summary>
/// Creates the lock indices
/// </summary>
/// <returns>Task</returns>
public async Task CreateLockIndices()
{
IndexKeysDefinitionBuilder <LockEntry> lockIndexBuilder = Builders <LockEntry> .IndexKeys;
CreateIndexModel <LockEntry> categoryIndex = new CreateIndexModel <LockEntry>(lockIndexBuilder.Ascending(x => x.Category));
await _LockCollection.Indexes.CreateOneAsync(categoryIndex);
CreateIndexModel <LockEntry> resourceIndex = new CreateIndexModel <LockEntry>(lockIndexBuilder.Ascending(x => x.ResourceId));
await _LockCollection.Indexes.CreateOneAsync(resourceIndex);
}
public static void EnsureJobIndexes(IMongoCollection<Job> jobCollection)
{
//Time Based indexes
CreateIndexOptions<Job> options = new CreateIndexOptions<Job>();
options.Background = true;
List<CreateIndexModel<Job>> TimeIndexes = new List<CreateIndexModel<Job>>();
var ascendCreateTime = new CreateIndexModel<Job>(Builders<Job>.IndexKeys.Ascending(x => x.CreateTime), options);
TimeIndexes.Add(ascendCreateTime);
var descendCreateTime = new CreateIndexModel<Job>(Builders<Job>.IndexKeys.Descending(x => x.CreateTime), options);
TimeIndexes.Add(descendCreateTime);
var ascendModifiedTime = new CreateIndexModel<Job>(Builders<Job>.IndexKeys.Ascending(x => x.ModifiedTime), options);
TimeIndexes.Add(ascendModifiedTime);
var descendModifiedTime = new CreateIndexModel<Job>(Builders<Job>.IndexKeys.Descending(x => x.ModifiedTime), options);
TimeIndexes.Add(descendModifiedTime);
jobCollection.Indexes.CreateMany(TimeIndexes);
//JobState Index
List<CreateIndexModel<Job>> BackgroundIndexes = new List<CreateIndexModel<Job>>();
var ascendJobState = new CreateIndexModel<Job>(Builders<Job>.IndexKeys.Ascending(x=>x.State), options);
BackgroundIndexes.Add(ascendCreateTime);
var descendJobState = new CreateIndexModel<Job>(Builders<Job>.IndexKeys.Descending(x => x.State), options);
BackgroundIndexes.Add(descendCreateTime);
jobCollection.Indexes.CreateMany(BackgroundIndexes);
//Geo Indexes
var geoIndexOptions = new CreateIndexOptions();
geoIndexOptions.Background = true;
geoIndexOptions.Sparse = true;
jobCollection.Indexes.CreateOne(Builders<Job>.IndexKeys.Geo2DSphere(x => x.Order.OrderLocation), geoIndexOptions);
}