/// <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)); }