/// <summary>
/// Select all game objects that have the specified component and match the specified selector.
/// </summary>
public IEnumerable <ComponentT> SelectAll <ComponentT>(string selector)
where ComponentT : Component
{
var query = queryParser.Parse(selector);
return(GameObject.FindObjectsOfType <ComponentT>()
.Where(component => query.Match(component.gameObject)));
}
public void ShouldCallQueryRunIfParserReturnsAQuery()
{
queryParser.Parse(Arg.Any <string>()).Returns(new List <IQueryInstruction>
{
new SelectQuery(@"select * from students where id = '0';")
});
database.Query(string.Empty);
queryParser.Received(1).Parse(Arg.Any <string>());
databaseEngine.Received(1).Query(Arg.Any <IQueryInstruction>());
}
public void ParseFilterLongTest()
{
//Arrange
var p = new Dictionary <string, string>();
p.Add("jobid", "1");
p.Add("result", "failure");
//Act
var result = mQueryParser.Parse <JobLog>(p);
//Assert
Assert.IsNotNull(result);
Assert.AreEqual("WHERE 1 = 1 AND [JobId] = @JobId AND [Result] = @Result", result.QueryParameters.Predicate);
Assert.IsNotNull(result.QueryParameters.Parameters);
string[] names = new string[2];
int i = 0;
foreach (var _name in result.QueryParameters.Parameters.ParameterNames)
{
names[i] = _name;
i++;
}
Assert.AreEqual("JobId", names[0]); //Dapper doesn't return the @ symbol in the name
long value1 = result.QueryParameters.Parameters.Get <long>(names[0]);
Assert.AreEqual(1, value1);
Assert.AreEqual("Result", names[1]);
string value2 = result.QueryParameters.Parameters.Get <string>(names[1]);
Assert.AreEqual("failure", value2);
Assert.IsNull(result.QueryParameters.Sort);
}
public async Task <QueryResourceResponse> QueryAsync(
QueryParameters parameters,
CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(parameters);
ValidateRequestIdentifiers(parameters);
var queryTags = await _queryTagService.GetQueryTagsAsync(cancellationToken : cancellationToken);
QueryExpression queryExpression = _queryParser.Parse(parameters, queryTags);
var partitionKey = _contextAccessor.RequestContext.GetPartitionKey();
QueryResult queryResult = await _queryStore.QueryAsync(partitionKey, queryExpression, cancellationToken);
if (!queryResult.DicomInstances.Any())
{
return(new QueryResourceResponse(Array.Empty <DicomDataset>(), queryExpression.ErroneousTags));
}
IEnumerable <DicomDataset> instanceMetadata = await Task.WhenAll(
queryResult.DicomInstances.Select(x => _metadataStore.GetInstanceMetadataAsync(x, cancellationToken)));
var responseBuilder = new QueryResponseBuilder(queryExpression);
IEnumerable <DicomDataset> responseMetadata = instanceMetadata.Select(m => responseBuilder.GenerateResponseDataset(m));
return(new QueryResourceResponse(responseMetadata, queryExpression.ErroneousTags));
}
public decimal Calculate(string text)
{
var query = _queryParser.Parse(text);
var result = 0m;
switch (query.Operation)
{
case "x":
result = _multiplier.Multiply(query.FirstNumber, query.SecondNumber);
break;
case "+":
result = _adder.Add(query.FirstNumber, query.SecondNumber);
break;
case "-":
result = _subtractor.Subtract(query.FirstNumber, query.SecondNumber);
break;
case "/":
result = _divider.Divide(query.FirstNumber, query.SecondNumber);
break;
}
return(result);
}
public async Task <QueryResourceResponse> QueryAsync(
QueryResourceRequest message,
CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(message);
ValidateRequestIdentifiers(message);
var queryTags = await _queryTagService.GetQueryTagsAsync(cancellationToken);
QueryExpression queryExpression = _queryParser.Parse(message, queryTags);
QueryResult queryResult = await _queryStore.QueryAsync(queryExpression, cancellationToken);
if (!queryResult.DicomInstances.Any())
{
return(new QueryResourceResponse());
}
IEnumerable <DicomDataset> instanceMetadata = await Task.WhenAll(
queryResult.DicomInstances
.Select(x => _metadataStore.GetInstanceMetadataAsync(x, cancellationToken)));
var responseBuilder = new QueryResponseBuilder(queryExpression);
IEnumerable <DicomDataset> responseMetadata = instanceMetadata.Select(m => responseBuilder.GenerateResponseDataset(m));
return(new QueryResourceResponse(responseMetadata));
}
/// <summary>
/// Builds and executes the query.
/// </summary>
/// <param name="context">The request context.</param>
/// <param name="arguments">The arguments from which to build the query.</param>
/// <param name="repository">The <see cref="IRepository"/>.</param>
/// <param name="parser">The <see cref="IQueryParser"/>.</param>
/// <returns>Returns the <see cref="RecordSet"/>.</returns>
protected override RecordSet Retrieve(IMansionContext context, IPropertyBag arguments, IRepository repository, IQueryParser parser)
{
// parse them into a query
var query = parser.Parse(context, arguments);
// execute the query
return searcher.Search(context, query);
}
/// <summary>
/// Builds and executes the query.
/// </summary>
/// <param name="context">The request context.</param>
/// <param name="arguments">The arguments from which to build the query.</param>
/// <param name="repository">The <see cref="IRepository"/>.</param>
/// <param name="parser">The <see cref="IQueryParser"/>.</param>
/// <returns>Returns the result.</returns>
protected override Record Retrieve(IMansionContext context, IPropertyBag arguments, IRepository repository, IQueryParser parser)
{
// parse the query
var query = parser.Parse(context, arguments);
// execute and return the result
return repository.RetrieveSingle(context, query);
}
public override IQueryResult Query(string scriptBody)
{
//todo: assertion - pre
Debug.Assert(string.IsNullOrEmpty(scriptBody), "The script should not be empty in order to be execute on Database");
var query = queryParser.Parse(scriptBody).Single();
return(databaseEngine.Query(query));
}
/// <summary>
/// Builds and executes the query.
/// </summary>
/// <param name="context">The request context.</param>
/// <param name="arguments">The arguments from which to build the query.</param>
/// <param name="repository">The <see cref="IRepository"/>.</param>
/// <param name="parser">The <see cref="IQueryParser"/>.</param>
/// <returns>Returns the result.</returns>
protected override Record Retrieve(IMansionContext context, IPropertyBag arguments, IRepository repository, IQueryParser parser)
{
// parse the query
var query = parser.Parse(context, arguments);
// make sure a child of clause is specified
if (!query.HasSpecification<ChildOfSpecification>())
throw new InvalidOperationException("The parent node was not specified.");
// execute the query
return repository.RetrieveSingleNode(context, query);
}
public ICalculationResult Calculate(string query)
{
var tree = _queryParser.Parse(query);
int totalCount = CalculateTotal(tree);
var result = new CalculationResultWithColor()
{
Result = totalCount, ResultColor = "green"
};
return(result);
}
public IEnumerable <SearchHit> Get(string q, int page = 1, int pageSize = 20)
{
var query = _queryParser.Parse(q);
var searchResults = _pageSearcher.SearchPages(query, page, pageSize);
return(searchResults.Select(r => new SearchHit()
{
Headline = r.Headline,
Link = r.Link,
Sample = _sampleGetter.GetSample(r, query)
}));
}
public static void AssertQueries(IEnumerable <KeyValuePair <string, IList <QueryToken> > > cases, IQueryParser parser)
{
foreach (var item in cases)
{
try
{
AssertTokens(item.Value, parser.Parse(item.Key));
}
catch (AssertFailedException e)
{
throw new AssertFailedException($"Failed for query: \"{item.Key}\"\n{e.Message}", e);
}
}
}
private DocumentNode ParseDocument(IQuery query)
{
if (query is QueryDocument parsed)
{
return(parsed.Document);
}
if (query is QuerySourceText source)
{
return(_parser.Parse(source.ToSpan()));
}
throw new NotSupportedException(
CoreResources.ParseQuery_Middleware_QueryTypeNotSupported);
}
private DocumentNode ParseDocument(IQuery query)
{
if (query is QueryDocument parsed)
{
return(parsed.Document);
}
if (query is QuerySourceText source)
{
return(_parser.Parse(source.ToSource()));
}
// TODO : resources
throw new NotSupportedException(
"The specified query type is not supported.");
}
public static void AssertQueries(IEnumerable <KeyValuePair <string, Type> > cases, IQueryParser parser)
{
void AssertThrowsException(Type t, Action action, string msg)
{
Func <Action, string, Exception> assert = Assert.ThrowsException <Exception>;
var generic = assert.Method.GetGenericMethodDefinition().MakeGenericMethod(new[] { t });
generic.Invoke(null, new object[] { action, msg });
}
foreach (var item in cases)
{
AssertThrowsException(item.Value, () => parser.Parse(item.Key),
$"\"{item.Key}\" was expected to throw a {item.Value.Name}.");
}
}
/// <summary>
/// Builds and executes the query.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="arguments">The arguments from which to build the query.</param>
/// <param name="repository">The <see cref="IRepository"/>.</param>
/// <param name="parser">The <see cref="IQueryParser"/>.</param>
/// <returns>Returns the result.</returns>
protected override Record Retrieve(IMansionContext context, IPropertyBag arguments, IRepository repository, IQueryParser parser)
{
// get the url
Url url;
if (!arguments.TryGet(context, "url", out url))
url = context.Cast<IMansionWebContext>().Request.RequestUrl;
// parse the query
var query = parser.Parse(context, new PropertyBag
{
{"baseType", "Site"},
{"hostHeaders", url.HostName}
});
// execute the query
return repository.RetrieveSingleNode(context, query);
}
/// <summary>
/// Builds and executes the query.
/// </summary>
/// <param name="context">The request context.</param>
/// <param name="arguments">The arguments from which to build the query.</param>
/// <param name="repository">The <see cref="IRepository"/>.</param>
/// <param name="parser">The <see cref="IQueryParser"/>.</param>
/// <returns>Returns the result.</returns>
protected override Record Retrieve(IMansionContext context, IPropertyBag arguments, IRepository repository, IQueryParser parser)
{
// parse the query
var query = parser.Parse(context, arguments);
// make sure a child of clause is specified
var parentOfSpecifications = query.Components.OfType<SpecificationQueryComponent>().Select(component => component.Specification).OfType<ParentOfSpecification>().ToArray();
if (!parentOfSpecifications.Any())
throw new InvalidOperationException("The child node was not specified.");
// if there is a parent of specification for depth 0 it means a parent of the root node is queried, which does not exist
if (parentOfSpecifications.Any(candidate => candidate.ChildPointer.Depth == 1))
return null;
// execute the query
return repository.RetrieveSingleNode(context, query);
}
/// <summary>
/// Automatically applies the include statements specified on the HTTP request
/// to the underlying Entity Framework IQueryable to load up as much as the
/// client has requested via the url <c>?include=</c> queryString.
/// </summary>
/// <remarks>
/// If you need to do further server-side processing based upon related entities
/// which you do not intend to return to the client, you can chain a call to
/// <c>.Include()</c> to make sure these are fetched back from the database also
/// </remarks>
public IQueryable <TEntity> IncludedSet <TEntity>() where TEntity : class
{
var rawDbSet = this.Set <TEntity>();
IQueryable <TEntity> result = rawDbSet;
// TODO optimise here in a separate step maybe?? (Removing redundant navigations currently done within parser)
var requestedIncludeQuery = _httpContextAccess.HttpContext.Request.Query;
var parsedIncludes = _httpQueryParser.Parse(requestedIncludeQuery);
foreach (var requestedInclude in parsedIncludes)
{
string navPath = _navPathBuilder.Build(typeof(TEntity), requestedInclude);
result = _expressionApplicator.Include(result, navPath);
}
return(result);
}
/// <summary>
/// Builds and executes the query.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="arguments">The arguments from which to build the query.</param>
/// <param name="repository">The <see cref="IRepository"/>.</param>
/// <param name="parser">The <see cref="IQueryParser"/>.</param>
/// <returns>Returns the result.</returns>
protected override Record Retrieve(IMansionContext context, IPropertyBag arguments, IRepository repository, IQueryParser parser)
{
// get the url
Url url;
if (!arguments.TryGet(context, "url", out url))
url = context.Cast<IMansionWebContext>().Request.RequestUrl;
// parse the URL for identifiers
IPropertyBag queryAttributes;
if (!nodeUrlService.TryExtractQueryParameters(context.Cast<IMansionWebContext>(), url, out queryAttributes))
return null;
// parse the query
var query = parser.Parse(context, queryAttributes);
// execute the query
return repository.RetrieveSingleNode(context, query);
}
/// <summary>
/// Builds and executes the query.
/// </summary>
/// <param name="context">The request context.</param>
/// <param name="arguments">The arguments from which to build the query.</param>
/// <param name="repository">The <see cref="IRepository"/>.</param>
/// <param name="parser">The <see cref="IQueryParser"/>.</param>
/// <returns>Returns the result.</returns>
protected override Record Retrieve(IMansionContext context, IPropertyBag arguments, IRepository repository, IQueryParser parser)
{
// get the node
var contentNode = GetRequiredAttribute<Node>(context, "source");
// check if this node defines a theme
string theme;
if (contentNode.TryGet(context, "theme", out theme) && !string.IsNullOrEmpty(theme))
return contentNode;
// retrieve the parents of the current node
var parentNodeset = repository.RetrieveNodeset(context, parser.Parse(context, new PropertyBag
{
{"childSource", contentNode},
{"baseType", "Page"},
{"depth", "any"},
{"sort", "depth DESC"}
}));
return parentNodeset.Nodes.FirstOrDefault(parent => parent.TryGet(context, "theme", out theme) && !string.IsNullOrEmpty(theme));
}
public QueryFilterResult <User> Parse(string text) => _parser.Parse(text);
public static SearchCondition ParseStructuredQuery(string query, CultureInfo cultureInfo)
{
Contract.Requires <ArgumentException>(!String.IsNullOrEmpty(query));
ICondition result = null;
var nativeQueryParserManager = (IQueryParserManager) new QueryParserManagerCoClass();
IQueryParser queryParser = null;
IQuerySolution querySolution = null;
IEntity mainType = null;
SearchCondition searchCondition = null;
try
{
// IQueryParser作成
var guid = new Guid(SearchIID.IQueryParser);
var hr = nativeQueryParserManager.CreateLoadedParser(
"SystemIndex",
cultureInfo == null ? (ushort)0 : (ushort)cultureInfo.LCID,
ref guid,
out queryParser);
if (HRESULT.Failed(hr))
{
throw ShellException.FromHRESULT(hr);
}
if (queryParser != null)
{
var optionValue = PropVariant.FromObject(true);
try
{
hr = queryParser.SetOption(STRUCTURED_QUERY_SINGLE_OPTION.SQSO_NATURAL_SYNTAX, optionValue);
if (HRESULT.Failed(hr))
{
throw ShellException.FromHRESULT(hr);
}
}
finally
{
optionValue.Clear();
}
hr = queryParser.Parse(query, null, out querySolution);
if (HRESULT.Failed(hr))
{
throw ShellException.FromHRESULT(hr);
}
if (querySolution != null)
{
hr = querySolution.GetQuery(out result, out mainType);
if (HRESULT.Failed(hr))
{
throw ShellException.FromHRESULT(hr);
}
}
}
searchCondition = new SearchCondition(result);
}
catch
{
searchCondition?.Dispose();
throw;
}
finally
{
Marshal.ReleaseComObject(nativeQueryParserManager);
if (queryParser != null)
{
Marshal.ReleaseComObject(queryParser);
}
if (querySolution != null)
{
Marshal.ReleaseComObject(querySolution);
}
if (mainType != null)
{
Marshal.ReleaseComObject(mainType);
}
}
return(searchCondition);
}
private DocumentNode ParseDocument(string queryText)
{
return(_parser.Parse(queryText));
}
public QueryFilterResult <AuditTrailEvent> Parse(string text) => _parser.Parse(text);
public QueryFilterResult <ContentItem> Parse(string text) => _parser.Parse(text);
public IEnumerable <SearchResult> Search(string query)
{
if (query == null || query.Trim() == "")
{
yield break;
}
query = query.Trim();
var session = SessionId++;
mLogger.Log(nameof(SearchEngine), session + "\tSearching: " + query);
var time = DateTime.Now;
var parsedQuery = mQueryParser.Parse(query);
mLogger.Log(nameof(SearchEngine), session + "\tParsed query " + (DateTime.Now - time).TotalMilliseconds);
time = DateTime.Now;
var urlFileIds = mRetriever.Retrieve(parsedQuery.Expression).ToList();
var count = urlFileIds.Count;
mLogger.Log(nameof(SearchEngine), session + "\tRetrieved docs " + (DateTime.Now - time).TotalMilliseconds);
time = DateTime.Now;
var scores = mRanker.Rank(urlFileIds, parsedQuery.Words).ToList();
mLogger.Log(nameof(SearchEngine), session + "\tRanked docs 1 " + (DateTime.Now - time).TotalMilliseconds);
time = DateTime.Now;
var results = new List <SearchResult>();
for (int i = 0; i < count; ++i)
{
results.Add(new SearchResult
{
UrlFileId = urlFileIds[i],
Score = scores[i],
});
}
results = results.OrderByDescending(o => o.Score.Value).ToList();
for (int i = 0; i < (PageSize - 1 + count) / PageSize; ++i)
{
int subResultsLength = Math.Min(PageSize, count - PageSize * i);
var subResults = results.GetRange(i * PageSize, subResultsLength);
var proScores = mProRanker.Rank(subResults.Select(o => o.UrlFileId), parsedQuery.Words).ToList();
for (int j = 0; j < subResultsLength; ++j)
{
subResults[j].ProScore = proScores[j];
subResults[j].WordPositions = proScores[j].WordPositions?.Where(o => o.Position != uint.MaxValue);
}
mLogger.Log(nameof(SearchEngine), session + "\tRanked docs 2 " + (DateTime.Now - time).TotalMilliseconds);
time = DateTime.Now;
foreach (var proResult in subResults.OrderByDescending(o => o.ProScore.Value))
{
yield return(proResult);
}
}
}
public override QueryFilterResult <T> Parse(string text) => _parser.Parse(text);
/// <summary>
/// Parses an input string that contains Structured Query keywords (using Advanced Query Syntax
/// or Natural Query Syntax) and produces a SearchCondition object.
/// </summary>
/// <param name="query">The query to be parsed</param>
/// <param name="cultureInfo">The culture used to select the localized language for keywords.</param>
/// <returns>Search condition resulting from the query</returns>
/// <remarks>For more information on structured query syntax, visit http://msdn.microsoft.com/en-us/library/bb233500.aspx and
/// http://www.microsoft.com/windows/products/winfamily/desktopsearch/technicalresources/advquery.mspx</remarks>
public static SearchCondition ParseStructuredQuery(string query, CultureInfo cultureInfo)
{
if (string.IsNullOrEmpty(query))
{
throw new ArgumentNullException(nameof(query));
}
IQueryParserManager nativeQueryParserManager = (IQueryParserManager) new QueryParserManagerCoClass();
IQueryParser queryParser = null;
IQuerySolution querySolution = null;
ICondition result = null;
IEntity mainType = null;
SearchCondition searchCondition = null;
try
{
// First, try to create a new IQueryParser using IQueryParserManager
Guid guid = new Guid(ShellIIDGuid.IQueryParser);
HResult hr = nativeQueryParserManager.CreateLoadedParser(
"SystemIndex",
cultureInfo == null ? (ushort)0 : (ushort)cultureInfo.LCID,
ref guid,
out queryParser);
if (!CoreErrorHelper.Succeeded(hr))
{
throw new ShellException(hr);
}
if (queryParser != null)
{
// If user specified natural query, set the option on the query parser
using (PropVariant optionValue = new PropVariant(true))
{
hr = queryParser.SetOption(StructuredQuerySingleOption.NaturalSyntax, optionValue);
}
if (!CoreErrorHelper.Succeeded(hr))
{
throw new ShellException(hr);
}
// Next, try to parse the query.
// Result would be IQuerySolution that we can use for getting the ICondition and other
// details about the parsed query.
hr = queryParser.Parse(query, null, out querySolution);
if (!CoreErrorHelper.Succeeded(hr))
{
throw new ShellException(hr);
}
if (querySolution != null)
{
// Lastly, try to get the ICondition from this parsed query
hr = querySolution.GetQuery(out result, out mainType);
if (!CoreErrorHelper.Succeeded(hr))
{
throw new ShellException(hr);
}
}
}
searchCondition = new SearchCondition(result);
return(searchCondition);
}
catch
{
if (searchCondition != null)
{
searchCondition.Dispose();
}
throw;
}
finally
{
if (nativeQueryParserManager != null)
{
Marshal.ReleaseComObject(nativeQueryParserManager);
}
if (queryParser != null)
{
Marshal.ReleaseComObject(queryParser);
}
if (querySolution != null)
{
Marshal.ReleaseComObject(querySolution);
}
if (mainType != null)
{
Marshal.ReleaseComObject(mainType);
}
}
}
public ScoredResult Search(string query, int page = 0, int size = 10)
{
var queryContext = _parser.Parse(query);
return(Search(queryContext, page, size));
}
