public ConcurrentDictionary<string, Lazy<IDocumentIndex>> this[DocumentIndexTypeToken documentIndexTypeToken]
{
get
{
switch (documentIndexTypeToken)
{
case DocumentIndexTypeToken.Entity:
return _entityIndexes;
case DocumentIndexTypeToken.Comment:
return _commentIndexes;
case DocumentIndexTypeToken.EntityProject:
return _entityProjectIndexes;
case DocumentIndexTypeToken.CommentProject:
return _commentProjectIndexes;
case DocumentIndexTypeToken.EntityType:
return _entityTypeIndexes;
case DocumentIndexTypeToken.EntityState:
return _entiyStateIndexes;
case DocumentIndexTypeToken.EntitySquad:
return _entitySquadIndexes;
case DocumentIndexTypeToken.CommentSquad:
return _commentSquadIndexes;
case DocumentIndexTypeToken.CommentEntityType:
return _commentEntityTypes;
default:
throw new NotSupportedException("{0} is not supported.".Fmt(documentIndexTypeToken));
}
}
}
private Maybe<IDocumentIndex> DoGetDocumentIndex(IPluginContext context, DocumentIndexTypeToken documentIndexTypeToken)
{
Lazy<IDocumentIndex> fetched;
return _documentIndexes[documentIndexTypeToken].TryGetValue(context.AccountName.Value, out fetched)
? Maybe.Return(fetched.Value)
: Maybe.Nothing;
}
private Maybe<IDocumentIndex> DoGetDocumentFinder(AccountName accountName, DocumentIndexTypeToken documentIndexTypeToken)
{
Lazy<IDocumentIndex> fetched;
return _documentIndexes[documentIndexTypeToken].TryGetValue(accountName.Value, out fetched)
? Maybe.Return(fetched.Value)
: Maybe.Nothing;
}
public bool Contains(DocumentIndexTypeToken typeToken, DocumentIndexDataTypeToken dataTypeToken)
{
return(_documentIndexTypes.Keys.Contains(new IndexTypeToken
{
Type = typeToken,
DataType = dataTypeToken
}));
}
private Maybe <IDocumentIndex> DoGetDocumentFinder(AccountName accountName, DocumentIndexTypeToken documentIndexTypeToken)
{
Lazy <IDocumentIndex> fetched;
return(_documentIndexes[documentIndexTypeToken].TryGetValue(accountName.Value, out fetched)
? Maybe.Return(fetched.Value)
: Maybe.Nothing);
}
private DocumentIndexType(DocumentIndexTypeToken typeToken, string fileName, IEnumerable <Enum> indexFields, IEnumerable <Enum> documentFields, int version)
{
_typeToken = typeToken;
_fileName = fileName + "_v" + version;
_indexFields = indexFields;
_documentFields = documentFields;
_version = version;
}
private Maybe <IDocumentIndex> DoGetDocumentIndex(IPluginContext context, DocumentIndexTypeToken documentIndexTypeToken)
{
Lazy <IDocumentIndex> fetched;
return(_documentIndexes[documentIndexTypeToken].TryGetValue(context.AccountName.Value, out fetched)
? Maybe.Return(fetched.Value)
: Maybe.Nothing);
}
private DocumentIndexType(DocumentIndexTypeToken typeToken, string fileName, IEnumerable<Enum> indexFields, IEnumerable<Enum> documentFields, int version)
{
_typeToken = typeToken;
_fileName = fileName + "_v" + version;
_indexFields = indexFields;
_documentFields = documentFields;
_version = version;
}
public Maybe<QueryPlan> Build(QueryData data, DocumentIndexTypeToken projectContextType, DocumentIndexTypeToken _, DocumentIndexTypeToken __)
{
var query = _indexDataFactory.CreateImpedimentData(false, data.LoggedUserId, data.LoggedUserId);
IDocumentIndex impedimentContextIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_pluginContext, DocumentIndexTypeToken.Impediment);
var impedimentPlan = impedimentContextIndex.BuildExecutionPlan(new ParsedQuery(words: query), _profile.Initialized);
var projectContextPlan = _plansBuilder.BuildProjectContextPlan(data.ProjectIds, data.IncludeNoProject, projectContextType);
return projectContextPlan.And(Maybe.Return(impedimentPlan));
}
public Maybe <QueryPlan> Build(QueryData data, DocumentIndexTypeToken projectContextType, DocumentIndexTypeToken _, DocumentIndexTypeToken __)
{
var query = _indexDataFactory.CreateImpedimentData(false, data.LoggedUserId, data.LoggedUserId);
IDocumentIndex impedimentContextIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_pluginContext, DocumentIndexTypeToken.Impediment);
var impedimentPlan = impedimentContextIndex.BuildExecutionPlan(new ParsedQuery(words: query), _profile.Initialized);
var projectContextPlan = _plansBuilder.BuildProjectContextPlan(data.ProjectIds, data.IncludeNoProject, projectContextType);
return(projectContextPlan.And(Maybe.Return(impedimentPlan)));
}
public Maybe<Lazy<WAHBitArray>> Build(QueryData data, DocumentIndexTypeToken projectContextType, DocumentIndexTypeToken squadContextType, DocumentIndexTypeToken entityType)
{
var projectContextPlan = BuildProjectContextPlan(data.ProjectIds, data.IncludeNoProject, projectContextType);
var squadPlan = BuildSquadPlan(data.TeamIds, data.IncludeNoTeam, squadContextType);
var projectAndSquad = Op(projectContextPlan, squadPlan, Operation.And);
var noSquadEntityPlan = BuildNoSquadEntityProjectContextPlan(data, projectContextType, entityType);
var resultPlan = Op(projectAndSquad, noSquadEntityPlan, Operation.Or);
var projectsReachableThroughTeamsPlan = BuildProjectReachableThroughTeamContextPlan(data, projectContextType, squadContextType);
return Op(resultPlan, projectsReachableThroughTeamsPlan, Operation.Or);
}
public DocumentIndex(DocumentIndexTypeToken documentIndexTypeToken, AccountName accountName, Action shuttingDown, DocumentIndexSetup documentIndexSetup, Action <string> log)
{
_documentType = DocumentIndexTypes[documentIndexTypeToken];
_hoot = new Hoot(GetIndexPath(documentIndexSetup, accountName), _documentType.FileName, log, documentIndexSetup.MinStringLengthToSearch, documentIndexSetup.MaxStringLengthIgnore);
_shuttingDown = shuttingDown;
_isAlive = true;
_gate = new object();
_documentIndexSetup = documentIndexSetup;
UpdateToken();
}
public Maybe <Lazy <WAHBitArray> > Build(QueryData data, DocumentIndexTypeToken projectContextType, DocumentIndexTypeToken squadContextType, DocumentIndexTypeToken entityType)
{
var projectContextPlan = BuildProjectContextPlan(data.ProjectIds, data.IncludeNoProject, projectContextType);
var squadPlan = BuildSquadPlan(data.TeamIds, data.IncludeNoTeam, squadContextType);
var projectAndSquad = Op(projectContextPlan, squadPlan, Operation.And);
var noSquadEntityPlan = BuildNoSquadEntityProjectContextPlan(data, projectContextType, entityType);
var resultPlan = Op(projectAndSquad, noSquadEntityPlan, Operation.Or);
var projectsReachableThroughTeamsPlan = BuildProjectReachableThroughTeamContextPlan(data, projectContextType, squadContextType);
return(Op(resultPlan, projectsReachableThroughTeamsPlan, Operation.Or));
}
public DocumentIndexType(DocumentIndexTypeToken typeToken, DocumentIndexDataTypeToken dataTypeToken, string fileName, IEnumerable <Enum> indexFields, IEnumerable <Enum> documentFields, int version, DocumentIndexDataTypeService documentIndexDataTypeService, IFileService fileService)
{
_typeToken = typeToken;
_dataTypeToken = dataTypeToken;
_fileName = fileName;
_documentIndexDataTypeService = documentIndexDataTypeService;
_fileService = fileService;
_versionedFileName = _documentIndexDataTypeService.CreateVersionedFilename(fileName, version);
_indexFields = indexFields;
_documentFields = documentFields;
_version = version;
}
public DocumentIndexType(DocumentIndexTypeToken typeToken, DocumentIndexDataTypeToken dataTypeToken, string fileName, IEnumerable<Enum> indexFields, IEnumerable<Enum> documentFields, int version, DocumentIndexDataTypeService documentIndexDataTypeService, IFileService fileService)
{
_typeToken = typeToken;
_dataTypeToken = dataTypeToken;
_fileName = fileName;
_documentIndexDataTypeService = documentIndexDataTypeService;
_fileService = fileService;
_versionedFileName = _documentIndexDataTypeService.CreateVersionedFilename(fileName, version);
_indexFields = indexFields;
_documentFields = documentFields;
_version = version;
}
public Maybe<QueryPlan> BuildProjectContextPlan(IEnumerable<int> projectIds, bool includeNoProject, DocumentIndexTypeToken projectIndexTypeToken)
{
ProjectIndexData projectIdsIndexData = projectIds != null ? new ProjectIndexData(projectIds.Cast<int?>().ToList()) : ProjectIndexData.Empty;
ProjectIndexData nullProjectIndexData = includeNoProject ? new ProjectIndexData(new int?[] {null}) : ProjectIndexData.Empty;
var result = ProjectIndexData.Sum(projectIdsIndexData, nullProjectIndexData);
string query = result.ToString();
if (string.IsNullOrEmpty(query))
{
return Maybe.Nothing;
}
IDocumentIndex projectContextIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_pluginContext, projectIndexTypeToken);
return projectContextIndex.BuildExecutionPlan(new ParsedQuery(words: query), _profile.Initialized);
}
private Maybe<QueryPlan> BuildSquadPlan(IEnumerable<int> squadIds, bool includeNoTeam, DocumentIndexTypeToken squadContextType)
{
var squadIdsIndexData = squadIds != null ? squadIds.Cast<int?>().ToArray() : new int?[0];
var nullSquadIndexData = includeNoTeam ? new int?[] {null} : new int?[0];
var squadIndexData = new SquadIndexData(squadIdsIndexData.Concat(nullSquadIndexData).Distinct());
var query = squadIndexData.ToString();
if (string.IsNullOrEmpty(query))
{
return Maybe.Nothing;
}
var squadIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_pluginContext, squadContextType);
return squadIndex.BuildExecutionPlan(new ParsedQuery(words: query), _profile.Initialized);
}
private IDocumentIndex DoGetOrCreateDocumentFinder(AccountName accountName, DocumentIndexTypeToken documentIndexTypeToken)
{
ConcurrentDictionary<string, Lazy<IDocumentIndex>> storage = _documentIndexes[documentIndexTypeToken];
return storage.GetOrAdd(accountName.Value, key => Lazy.Create(() =>
{
IDocumentIndex documentIndex = new DocumentIndex(documentIndexTypeToken, accountName, () =>
{
Lazy<IDocumentIndex> _;
storage.TryRemove(accountName.Value, out _);
}, _documentIndexSetup, _logger);
return documentIndex;
})).Value;
}
private IDocumentIndex DoGetOrCreateDocumentFinder(AccountName accountName, DocumentIndexTypeToken documentIndexTypeToken)
{
ConcurrentDictionary <string, Lazy <IDocumentIndex> > storage = _documentIndexes[documentIndexTypeToken];
return(storage.GetOrAdd(accountName.Value, key => Lazy.Create(() =>
{
IDocumentIndex documentIndex = new DocumentIndex(documentIndexTypeToken, accountName, () =>
{
Lazy <IDocumentIndex> _;
storage.TryRemove(accountName.Value, out _);
}, _documentIndexSetup, _logger);
return documentIndex;
})).Value);
}
private IDocumentIndex DoGetOrCreateDocumentIndex(IPluginContext context, DocumentIndexTypeToken documentIndexTypeToken)
{
ConcurrentDictionary<string, Lazy<IDocumentIndex>> storage = _documentIndexes[documentIndexTypeToken];
var index = storage.GetOrAdd(context.AccountName.Value, key => Lazy.Create(() =>
{
IDocumentIndex documentIndex = CreateDocumentIndex(context, documentIndexTypeToken);
var otherVersions = documentIndex.Type.GetVersions(context.AccountName, _documentIndexSetup).Except(new[] {documentIndex.Type.Version});
foreach (int version in otherVersions)
{
IDocumentIndex versionedDocumentIndex = CreateDocumentIndex(context, documentIndexTypeToken, version);
versionedDocumentIndex.Shutdown(new DocumentIndexShutdownSetup(forceShutdown: true, cleanStorage: true));
}
return documentIndex;
}));
return index.Value;
}
private Maybe<Lazy<WAHBitArray>> BuildProjectReachableThroughTeamContextPlan(QueryData data, DocumentIndexTypeToken projectContextType, DocumentIndexTypeToken squadContextType)
{
if (data.TeamProjectRelations == null)
{
return Maybe.Nothing;
}
Maybe<Lazy<WAHBitArray>> result = Maybe.Nothing;
foreach (var projectsReachableThroughTeamData in data.TeamProjectRelations)
{
var projectContextPlan = BuildProjectContextPlan(projectsReachableThroughTeamData.ProjectIds, false, projectContextType);
var squadPlan = BuildSquadPlan(new[] { projectsReachableThroughTeamData.TeamId }, false, squadContextType);
var temp = Op(projectContextPlan, squadPlan, Operation.And);
result = Op(result, temp, Operation.Or);
}
return result;
}
public Maybe<QueryPlan> Build(QueryData data, DocumentIndexTypeToken projectContextType, DocumentIndexTypeToken squadContextType, DocumentIndexTypeToken entityType)
{
var projectContextPlan = BuildProjectContextPlan(data.ProjectIds, data.IncludeNoProject, projectContextType);
var squadPlan = BuildSquadPlan(data.TeamIds, data.IncludeNoTeam, squadContextType);
var projectAndSquad = projectContextPlan.And(squadPlan);
var noSquadEntityPlan = BuildNoSquadEntityProjectContextPlan(data, projectContextType, entityType);
var resultPlan = projectAndSquad.Or(noSquadEntityPlan);
var projectsReachableThroughTeamsPlan = BuildProjectReachableThroughTeamContextPlan(data, projectContextType, squadContextType);
resultPlan = resultPlan.Or(projectsReachableThroughTeamsPlan);
resultPlan = _planBuilders.Where(b => b.ShouldBuild(data)).Aggregate(resultPlan, (acc, builder) =>
{
var plan = builder.Build(data, projectContextType, squadContextType, entityType);
return acc.Or(plan);
});
return resultPlan;
}
private Maybe<QueryPlan> BuildProjectReachableThroughTeamContextPlan(QueryData data, DocumentIndexTypeToken projectContextType, DocumentIndexTypeToken squadContextType)
{
if (data.TeamProjectRelations == null)
{
return Maybe.Nothing;
}
Maybe<QueryPlan> result = Maybe.Nothing;
foreach (var projectsReachableThroughTeamData in data.TeamProjectRelations)
{
var projectContextPlan = BuildProjectContextPlan(projectsReachableThroughTeamData.ProjectIds, false, projectContextType);
var squadPlan = BuildSquadPlan(new[] { projectsReachableThroughTeamData.TeamId }, false, squadContextType);
var temp = projectContextPlan.And(squadPlan);
result = result.Or(temp);
}
return result;
}
public ConcurrentDictionary <string, Lazy <IDocumentIndex> > this[DocumentIndexTypeToken documentIndexTypeToken]
{
get
{
switch (documentIndexTypeToken)
{
case DocumentIndexTypeToken.Entity:
return(_entityIndexes);
case DocumentIndexTypeToken.Comment:
return(_commentIndexes);
case DocumentIndexTypeToken.EntityProject:
return(_entityProjectIndexes);
case DocumentIndexTypeToken.CommentProject:
return(_commentProjectIndexes);
case DocumentIndexTypeToken.EntityType:
return(_entityTypeIndexes);
case DocumentIndexTypeToken.EntityState:
return(_entiyStateIndexes);
case DocumentIndexTypeToken.EntitySquad:
return(_entitySquadIndexes);
case DocumentIndexTypeToken.CommentSquad:
return(_commentSquadIndexes);
case DocumentIndexTypeToken.CommentEntityType:
return(_commentEntityTypes);
case DocumentIndexTypeToken.Impediment:
return(_impedimentContextIndexes);
case DocumentIndexTypeToken.TestStep:
return(_testStepIndexes);
case DocumentIndexTypeToken.TestStepProject:
return(_testStepProjectIndexes);
default:
throw new NotSupportedException("{0} is not supported.".Fmt(documentIndexTypeToken));
}
}
}
private IDocumentIndex CreateDocumentIndex(IPluginContext context, DocumentIndexTypeToken documentIndexTypeToken, int?version = null)
{
DocumentIndexType charactersIndexType = null;
DocumentIndexType digitsIndexType = null;
if (_documentIndexMetadata.Contains(documentIndexTypeToken, DocumentIndexDataTypeToken.Characters))
{
charactersIndexType = _documentIndexMetadata.GetDocumentIndexType(documentIndexTypeToken, DocumentIndexDataTypeToken.Characters);
}
if (_documentIndexMetadata.Contains(documentIndexTypeToken, DocumentIndexDataTypeToken.Digits))
{
digitsIndexType = _documentIndexMetadata.GetDocumentIndexType(documentIndexTypeToken, DocumentIndexDataTypeToken.Digits);
}
if (version != null)
{
if (charactersIndexType != null)
{
charactersIndexType = charactersIndexType.CreateVersion(version.Value);
}
if (digitsIndexType != null)
{
digitsIndexType = digitsIndexType.CreateVersion(version.Value);
}
}
DocumentIndexMonitor monitor = null;
Action detachIndex = () =>
{
if (monitor != null)
{
monitor.DetachIndex();
}
};
IActivityLogger logger = _loggerFactory.Create(new PluginContextSnapshot(context));
monitor = new DocumentIndexMonitor(charactersIndexType ?? digitsIndexType, () =>
{
if (charactersIndexType != null)
{
return(digitsIndexType != null
? (IDocumentIndex) new DocumentIndex(charactersIndexType, digitsIndexType, context, detachIndex, _documentIndexSetup, _loggerFactory, _optimizeHintFactory)
: new DocumentIndexTyped(charactersIndexType, context, detachIndex, _documentIndexSetup, _loggerFactory, _optimizeHintFactory));
}
throw new ApplicationException("Characters index for {0} type is not supported.".Fmt(documentIndexTypeToken));
}, logger);
return(monitor);
}
private IDocumentIndex DoGetOrCreateDocumentIndex(IPluginContext context, DocumentIndexTypeToken documentIndexTypeToken)
{
ConcurrentDictionary <string, Lazy <IDocumentIndex> > storage = _documentIndexes[documentIndexTypeToken];
var index = storage.GetOrAdd(context.AccountName.Value, key => Lazy.Create(() =>
{
IDocumentIndex documentIndex = CreateDocumentIndex(context, documentIndexTypeToken);
var otherVersions = documentIndex.Type.GetVersions(context.AccountName, _documentIndexSetup).Except(new[] { documentIndex.Type.Version });
foreach (int version in otherVersions)
{
IDocumentIndex versionedDocumentIndex = CreateDocumentIndex(context, documentIndexTypeToken, version);
versionedDocumentIndex.Shutdown(new DocumentIndexShutdownSetup(forceShutdown: true, cleanStorage: true));
}
return(documentIndex);
}));
return(index.Value);
}
public Maybe <QueryPlan> Build(QueryData data, DocumentIndexTypeToken projectContextType, DocumentIndexTypeToken squadContextType, DocumentIndexTypeToken entityType)
{
var projectContextPlan = BuildProjectContextPlan(data.ProjectIds, data.IncludeNoProject, projectContextType);
var squadPlan = BuildSquadPlan(data.TeamIds, data.IncludeNoTeam, squadContextType);
var projectAndSquad = projectContextPlan.And(squadPlan);
var noSquadEntityPlan = BuildNoSquadEntityProjectContextPlan(data, projectContextType, entityType);
var resultPlan = projectAndSquad.Or(noSquadEntityPlan);
var projectsReachableThroughTeamsPlan = BuildProjectReachableThroughTeamContextPlan(data, projectContextType, squadContextType);
resultPlan = resultPlan.Or(projectsReachableThroughTeamsPlan);
resultPlan = _planBuilders.Where(b => b.ShouldBuild(data)).Aggregate(resultPlan, (acc, builder) =>
{
var plan = builder.Build(data, projectContextType, squadContextType, entityType);
return(acc.Or(plan));
});
return(resultPlan);
}
private IDocumentIndex CreateDocumentIndex(IPluginContext context, DocumentIndexTypeToken documentIndexTypeToken, int? version = null)
{
DocumentIndexType charactersIndexType = null;
DocumentIndexType digitsIndexType = null;
if (_documentIndexMetadata.Contains(documentIndexTypeToken, DocumentIndexDataTypeToken.Characters))
{
charactersIndexType = _documentIndexMetadata.GetDocumentIndexType(documentIndexTypeToken, DocumentIndexDataTypeToken.Characters);
}
if (_documentIndexMetadata.Contains(documentIndexTypeToken, DocumentIndexDataTypeToken.Digits))
{
digitsIndexType = _documentIndexMetadata.GetDocumentIndexType(documentIndexTypeToken, DocumentIndexDataTypeToken.Digits);
}
if (version != null)
{
if (charactersIndexType != null)
{
charactersIndexType = charactersIndexType.CreateVersion(version.Value);
}
if (digitsIndexType != null)
{
digitsIndexType = digitsIndexType.CreateVersion(version.Value);
}
}
DocumentIndexMonitor monitor = null;
Action detachIndex = () =>
{
if (monitor != null)
{
monitor.DetachIndex();
}
};
IActivityLogger logger = _loggerFactory.Create(new PluginContextSnapshot(context));
monitor = new DocumentIndexMonitor(charactersIndexType ?? digitsIndexType, () =>
{
if (charactersIndexType != null)
{
return digitsIndexType != null
? (IDocumentIndex)new DocumentIndex(charactersIndexType, digitsIndexType, context, detachIndex, _documentIndexSetup, _loggerFactory, _optimizeHintFactory)
: new DocumentIndexTyped(charactersIndexType, context, detachIndex, _documentIndexSetup, _loggerFactory, _optimizeHintFactory);
}
throw new ApplicationException("Characters index for {0} type is not supported.".Fmt(documentIndexTypeToken));
}, logger);
return monitor;
}
private Maybe<Lazy<WAHBitArray>> BuildProjectContextPlan(IEnumerable<int> projectIds, bool includeNoProject, DocumentIndexTypeToken documentIndexTypeToken)
{
var queryBuf = new List<string>();
if (projectIds != null)
{
queryBuf.AddRange(projectIds.Select(projectId => _documentIdFactory.EncodeProjectId(projectId)));
}
if (includeNoProject)
{
queryBuf.Add(_documentIdFactory.EncodeProjectId(null));
}
if (!queryBuf.Any())
{
return Maybe.Nothing;
}
string query = String.Join(" ", queryBuf.ToArray());
IDocumentIndex projectContextIndices = _documentIndexProvider.GetOrCreateDocumentIndex(_accountName, documentIndexTypeToken);
return projectContextIndices.BuildExecutionPlan(query, _profile.Initialized);
}
private Maybe<Lazy<WAHBitArray>> BuildSquadPlan(IEnumerable<int> squadIds, bool includeNoTeam, DocumentIndexTypeToken squadContextType)
{
var queryBuf = new List<string>();
if (squadIds != null)
{
queryBuf.AddRange(squadIds.Select(squadId => _documentIdFactory.EncodeSquadId(squadId)));
}
if (includeNoTeam)
{
queryBuf.Add(_documentIdFactory.EncodeSquadId(null));
}
if (!queryBuf.Any())
{
return Maybe.Nothing;
}
string query = String.Join(" ", queryBuf.ToArray());
IDocumentIndex squadIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_accountName, squadContextType);
return squadIndex.BuildExecutionPlan(query, _profile.Initialized);
}
Maybe<QueryPlan> IProjectContextQueryPlanBuilder.BuildProjectContextPlan(IEnumerable<int> projectIds, bool includeNoProject, DocumentIndexTypeToken projectIndexTypeToken)
{
var queryBuf = new List<string>();
if (projectIds != null)
{
queryBuf.AddRange(projectIds.Select(projectId => _indexDataFactory.CreateProjectData(projectId)));
}
if (includeNoProject)
{
queryBuf.Add(_indexDataFactory.CreateProjectData(null));
}
if (!queryBuf.Any())
{
return Maybe.Nothing;
}
string query = String.Join(" ", queryBuf.ToArray());
IDocumentIndex projectContextIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_pluginContext, projectIndexTypeToken);
return projectContextIndex.BuildExecutionPlan(new ParsedQuery(words:query), _profile.Initialized);
}
private Maybe<QueryPlan> BuildSquadPlan(IEnumerable<int> squadIds, bool includeNoTeam, DocumentIndexTypeToken squadContextType)
{
var queryBuf = new List<string>();
if (squadIds != null)
{
queryBuf.AddRange(squadIds.Select(squadId => _indexDataFactory.CreateSquadData(squadId)));
}
if (includeNoTeam)
{
queryBuf.Add(_indexDataFactory.CreateSquadData(null));
}
if (!queryBuf.Any())
{
return Maybe.Nothing;
}
string query = String.Join(" ", queryBuf.ToArray());
IDocumentIndex squadIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_pluginContext, squadContextType);
return squadIndex.BuildExecutionPlan(new ParsedQuery(words:query), _profile.Initialized);
}
private Maybe <Lazy <WAHBitArray> > BuildProjectContextPlan(IEnumerable <int> projectIds, bool includeNoProject, DocumentIndexTypeToken documentIndexTypeToken)
{
var queryBuf = new List <string>();
if (projectIds != null)
{
queryBuf.AddRange(projectIds.Select(projectId => _documentIdFactory.EncodeProjectId(projectId)));
}
if (includeNoProject)
{
queryBuf.Add(_documentIdFactory.EncodeProjectId(null));
}
if (!queryBuf.Any())
{
return(Maybe.Nothing);
}
string query = String.Join(" ", queryBuf.ToArray());
IDocumentIndex projectContextIndices = _documentIndexProvider.GetOrCreateDocumentIndex(_accountName, documentIndexTypeToken);
return(projectContextIndices.BuildExecutionPlan(query, _profile.Initialized));
}
private Maybe <Lazy <WAHBitArray> > BuildSquadPlan(IEnumerable <int> squadIds, bool includeNoTeam, DocumentIndexTypeToken squadContextType)
{
var queryBuf = new List <string>();
if (squadIds != null)
{
queryBuf.AddRange(squadIds.Select(squadId => _documentIdFactory.EncodeSquadId(squadId)));
}
if (includeNoTeam)
{
queryBuf.Add(_documentIdFactory.EncodeSquadId(null));
}
if (!queryBuf.Any())
{
return(Maybe.Nothing);
}
string query = String.Join(" ", queryBuf.ToArray());
IDocumentIndex squadIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_accountName, squadContextType);
return(squadIndex.BuildExecutionPlan(query, _profile.Initialized));
}
public Maybe <IDocumentIndex> GetDocumentIndex(AccountName accountName, DocumentIndexTypeToken indexTypeToken)
{
return(DoGetDocumentFinder(accountName, indexTypeToken));
}
private Maybe <Lazy <WAHBitArray> > BuildProjectReachableThroughTeamContextPlan(QueryData data, DocumentIndexTypeToken projectContextType, DocumentIndexTypeToken squadContextType)
{
if (data.TeamProjectRelations == null)
{
return(Maybe.Nothing);
}
Maybe <Lazy <WAHBitArray> > result = Maybe.Nothing;
foreach (var projectsReachableThroughTeamData in data.TeamProjectRelations)
{
var projectContextPlan = BuildProjectContextPlan(projectsReachableThroughTeamData.ProjectIds, false, projectContextType);
var squadPlan = BuildSquadPlan(new[] { projectsReachableThroughTeamData.TeamId }, false, squadContextType);
var temp = Op(projectContextPlan, squadPlan, Operation.And);
result = Op(result, temp, Operation.Or);
}
return(result);
}
private Maybe <QueryPlan> BuildProjectReachableThroughTeamContextPlan(QueryData data, DocumentIndexTypeToken projectContextType, DocumentIndexTypeToken squadContextType)
{
if (data.TeamProjectRelations == null)
{
return(Maybe.Nothing);
}
Maybe <QueryPlan> result = Maybe.Nothing;
foreach (var projectsReachableThroughTeamData in data.TeamProjectRelations)
{
var projectContextPlan = BuildProjectContextPlan(projectsReachableThroughTeamData.ProjectIds, false, projectContextType);
var squadPlan = BuildSquadPlan(new[] { projectsReachableThroughTeamData.TeamId }, false, squadContextType);
var temp = projectContextPlan.And(squadPlan);
result = result.Or(temp);
}
return(result);
}
Maybe <QueryPlan> IProjectContextQueryPlanBuilder.BuildProjectContextPlan(IEnumerable <int> projectIds, bool includeNoProject, DocumentIndexTypeToken projectIndexTypeToken)
{
var queryBuf = new List <string>();
if (projectIds != null)
{
queryBuf.AddRange(projectIds.Select(projectId => _indexDataFactory.CreateProjectData(projectId)));
}
if (includeNoProject)
{
queryBuf.Add(_indexDataFactory.CreateProjectData(null));
}
if (!queryBuf.Any())
{
return(Maybe.Nothing);
}
string query = String.Join(" ", queryBuf.ToArray());
IDocumentIndex projectContextIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_pluginContext, projectIndexTypeToken);
return(projectContextIndex.BuildExecutionPlan(new ParsedQuery(words: query), _profile.Initialized));
}
public int GetVersion(DocumentIndexTypeToken token)
{
return(_versions[token]);
}
public IDocumentIndex GetOrCreateDocumentIndex(IPluginContext context, DocumentIndexTypeToken indexTypeToken)
{
return DoGetOrCreateDocumentIndex(context, indexTypeToken);
}
public IDocumentIndex GetOrCreateDocumentIndex(AccountName accountName, DocumentIndexTypeToken indexTypeToken)
{
return DoGetOrCreateDocumentFinder(accountName, indexTypeToken);
}
public DocumentIndexType GetDocumentIndexType(DocumentIndexTypeToken typeToken, DocumentIndexDataTypeToken dataTypeToken)
{
return(_documentIndexTypes[new IndexTypeToken {
Type = typeToken, DataType = dataTypeToken
}]);
}
public Maybe<IDocumentIndex> GetDocumentIndex(AccountName accountName, DocumentIndexTypeToken indexTypeToken)
{
return DoGetDocumentFinder(accountName, indexTypeToken);
}
public IDocumentIndex GetOrCreateDocumentIndex(IPluginContext context, DocumentIndexTypeToken indexTypeToken)
{
return(DoGetOrCreateDocumentIndex(context, indexTypeToken));
}
public Maybe <IDocumentIndex> GetDocumentIndex(IPluginContext context, DocumentIndexTypeToken indexTypeToken)
{
return(DoGetDocumentIndex(context, indexTypeToken));
}
private Maybe <QueryPlan> BuildSquadPlan(IEnumerable <int> squadIds, bool includeNoTeam, DocumentIndexTypeToken squadContextType)
{
var queryBuf = new List <string>();
if (squadIds != null)
{
queryBuf.AddRange(squadIds.Select(squadId => _indexDataFactory.CreateSquadData(squadId)));
}
if (includeNoTeam)
{
queryBuf.Add(_indexDataFactory.CreateSquadData(null));
}
if (!queryBuf.Any())
{
return(Maybe.Nothing);
}
string query = String.Join(" ", queryBuf.ToArray());
IDocumentIndex squadIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_pluginContext, squadContextType);
return(squadIndex.BuildExecutionPlan(new ParsedQuery(words: query), _profile.Initialized));
}
private Maybe<QueryPlan> BuildNoSquadEntityProjectContextPlan(QueryData data, DocumentIndexTypeToken project, DocumentIndexTypeToken entityType)
{
var projectContextPlan = BuildProjectContextPlan(data.ProjectIds, data.IncludeNoProject, project);
if (!projectContextPlan.HasValue)
{
return Maybe.Nothing;
}
string noSquadEntityTypeIdsQuery = String.Join(" ", _entityTypeProvider.NoSquadEntityTypeNames);
IDocumentIndex entityTypeIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_pluginContext, entityType);
QueryPlan noSquadEntityPlan = entityTypeIndex.BuildExecutionPlan(new ParsedQuery(words:noSquadEntityTypeIdsQuery), _profile.Initialized);
return Maybe.Return(QueryPlan.And(noSquadEntityPlan, projectContextPlan.Value));
}
public Maybe <QueryPlan> BuildProjectContextPlan(IEnumerable <int> projectIds, bool includeNoProject, DocumentIndexTypeToken projectIndexTypeToken)
{
ProjectIndexData projectIdsIndexData = projectIds != null ? new ProjectIndexData(projectIds.Cast <int?>().ToList()) : ProjectIndexData.Empty;
ProjectIndexData nullProjectIndexData = includeNoProject ? new ProjectIndexData(new int?[] { null }) : ProjectIndexData.Empty;
var result = ProjectIndexData.Sum(projectIdsIndexData, nullProjectIndexData);
string query = result.ToString();
if (string.IsNullOrEmpty(query))
{
return(Maybe.Nothing);
}
IDocumentIndex projectContextIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_pluginContext, projectIndexTypeToken);
return(projectContextIndex.BuildExecutionPlan(new ParsedQuery(words: query), _profile.Initialized));
}
private bool Exists <TDocument>(int entityId, DocumentIndexTypeToken indexType) where TDocument : hOOt.Document, new()
{
IDocumentIndex entityIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_pluginContext.AccountName, indexType);
return(entityIndex.FindDocumentByName <TDocument>(EntityDocument.CreateName(entityId)) != null);
}
public Maybe<IDocumentIndex> GetDocumentIndex(IPluginContext context, DocumentIndexTypeToken indexTypeToken)
{
return DoGetDocumentIndex(context, indexTypeToken);
}
private Maybe <Lazy <WAHBitArray> > BuildNoSquadEntityProjectContextPlan(QueryData data, DocumentIndexTypeToken project, DocumentIndexTypeToken entityType)
{
var projectContextPlan = BuildProjectContextPlan(data.ProjectIds, data.IncludeNoProject, project);
if (!projectContextPlan.HasValue)
{
return(Maybe.Nothing);
}
string noSquadEntityTypeIdsQuery = String.Join(" ", _entityTypeProvider.NoSquadEntityTypeNames);
IDocumentIndex entityTypeIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_accountName, entityType);
Lazy <WAHBitArray> noSquadEntityPlan = entityTypeIndex.BuildExecutionPlan(noSquadEntityTypeIdsQuery, _profile.Initialized);
return(Maybe.Return(Lazy.Create(() => noSquadEntityPlan.Value.And(projectContextPlan.Value.Value))));
}
private Maybe <QueryPlan> BuildNoSquadEntityProjectContextPlan(QueryData data, DocumentIndexTypeToken project, DocumentIndexTypeToken entityType)
{
var projectContextPlan = BuildProjectContextPlan(data.ProjectIds, data.IncludeNoProject, project);
if (!projectContextPlan.HasValue)
{
return(Maybe.Nothing);
}
string noSquadEntityTypeIdsQuery = String.Join(" ", _entityTypeProvider.NoSquadEntityTypeNames);
IDocumentIndex entityTypeIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_pluginContext, entityType);
QueryPlan noSquadEntityPlan = entityTypeIndex.BuildExecutionPlan(new ParsedQuery(words: noSquadEntityTypeIdsQuery), _profile.Initialized);
return(Maybe.Return(QueryPlan.And(noSquadEntityPlan, projectContextPlan.Value)));
}
private Maybe<Lazy<WAHBitArray>> BuildNoSquadEntityProjectContextPlan(QueryData data, DocumentIndexTypeToken project, DocumentIndexTypeToken entityType)
{
var projectContextPlan = BuildProjectContextPlan(data.ProjectIds, data.IncludeNoProject, project);
if (!projectContextPlan.HasValue)
{
return Maybe.Nothing;
}
string noSquadEntityTypeIdsQuery = String.Join(" ", _entityTypeProvider.NoSquadEntityTypeNames);
IDocumentIndex entityTypeIndex = _documentIndexProvider.GetOrCreateDocumentIndex(_accountName, entityType);
Lazy<WAHBitArray> noSquadEntityPlan = entityTypeIndex.BuildExecutionPlan(noSquadEntityTypeIdsQuery, _profile.Initialized);
return Maybe.Return(Lazy.Create(() => noSquadEntityPlan.Value.And(projectContextPlan.Value.Value)));
}
public int GetVersion(DocumentIndexTypeToken token)
{
return _versions[token];
}
public IDocumentIndex GetOrCreateDocumentIndex(AccountName accountName, DocumentIndexTypeToken indexTypeToken)
{
return(DoGetOrCreateDocumentFinder(accountName, indexTypeToken));
}
