public ListResponse<MedicineDto> GetMatchingMedicines(QueryRequest<MedicineQuery> request) { try { using (var dbContext = new AptekaNETDbContext()) { var medicines = dbContext.Medicines.AsEnumerable().Where(p => request.Query.IsMatch(p)).ToList(); if (medicines.Any()) { var medicineDtos = medicines.Select(p => _medicineAssembler.ToDto(p)).ToList(); return new ListResponse<MedicineDto>(request.Id, medicineDtos) { Message = "Pobrano pomyślnie" }; } return new ListResponse<MedicineDto>(request.Id, new List<MedicineDto>()) { Message = "Nie ma leku spełniającego powyższe warunki" }; } } catch (Exception e) { return new ListResponse<MedicineDto>(request.Id, new List<MedicineDto>()) { Message = "Błąd" }; } }
public QueryRequest GetMetadataByNameQueryRequest(string name, Guid pageTypeId, Guid languageId, SecurityToken token) { // Set up page query. var request = new QueryRequest(languageId, CmsSearchDomains.Pages, token); // Set pagetype. request.FilterTags.Add(new Tag(TagNames.PageTypeId, pageTypeId)); // Set pagetype. request.FilterTags.Add(new Tag(TagNames.Name, name) { AllowFuzzy = false }); // Only published pages. request.FilterTags.Add(new Tag(TagNames.IsPublished, true)); request.Paging = Paging.Default; return request; }
/// <summary> /// Gets a list of metadatas with only the most basic information set (ID and Name). /// </summary> /// <param name="request">The request.</param> /// <param name="searchService">The search service.</param> /// <param name="siteMapCache">The site map cache.</param> /// <returns>A list of metadata with most basic information</returns> public List<Metadata> GetBasicMetadata(QueryRequest request, SiteMapCache siteMapCache) { SearchResponse response = Solution.Instance.SearchService.Search(request); List<Metadata> metadatas = new List<Metadata>(); if (response != null) { List<PageInfoCarrier> pages = GetPageInfoCarriersFromSearchResponse(response, siteMapCache); foreach (PageInfoCarrier page in pages) { metadatas.Add(new Metadata(page, this)); } } else { _log.Error("Search returned null instead of zero results."); } return metadatas; }
/// <summary> /// Overridden. Starts to create the requested object, /// either immediately or on a background thread, /// based on the value of the IsAsynchronous property. /// </summary> protected override void BeginQuery() { if (this._init) return; if (this._firstRun) { this._firstRun = false; if (!IsInitialLoadEnabled) return; } if (this._endInitError) { // this handles a case where the WPF form initilizer // invokes the data provider twice when an exception // occurs - we really don't want to try the query twice // or report the error twice this._endInitError = false; this.OnQueryFinished(null, null, null, null); return; } if (this.IsRefreshDeferred) return; var request = new QueryRequest() { DataProducer = this.DataProducer, Version = this._queryVersion }; this.IsBusy = true; AsyncHelper.Invoke(() => DoQuery(request)); }
private RequestBase SearchInternal(QuerySetup setup) { _searchType = setup.SearchType; setup.SearchText.EnsureNotNull("searchText"); if (setup.From > 10000 || setup.Size > 10000) { throw new ArgumentOutOfRangeException(nameof(setup), "From (skip) and size (take) must be less than or equal to: 10000. If you really must, this limit can be set by changing the [index.max_result_window] index level parameter"); } var request = new QueryRequest(setup); request.Query.SearchText = setup.SearchText.ToLower(); if (setup.SearchFields.Count == 0) { setup.SearchFields.AddRange(GetMappedFields(Language.GetLanguageCode(setup.Language), setup.IndexName, setup.SearchType)); } if (Log.IsDebugEnabled()) { Log.Debug("SearchFields:"); setup.SearchFields.ForEach(f => Log.Debug(f)); } SetupAttachmentFields(setup); SetupSourceFields(request, setup); if (setup.IsGetQuery) { request.Query.Bool.Must.Add(new MatchAll()); } else if (setup.IsWildcard) { setup.SearchFields.ForEach(field => request.Query.Bool.Should.Add(new Wildcard(field, request.Query.SearchText))); // Boost hits that starts with searchtext, ie. when searching for "*foo*", // hits on "foobar" will score higher than hits on "barfoo" if (request.Query.SearchText.StartsWith("*")) { setup.SearchFields.ForEach(field => request.Query.Bool.Should.Add(new Wildcard(field, request.Query.SearchText.TrimStart('*'), 10))); } request.Query.Bool.MinimumNumberShouldMatch = 1; } else { request.Query.Bool.Must.Add( new MatchMulti( request.Query.SearchText, setup.SearchFields, setup.Operator, null, null, setup.FuzzyLength, setup.Analyzer)); // Boost phrase matches if multiple words if (request.Query.SearchText?.IndexOf(" ", StringComparison.OrdinalIgnoreCase) > 0) { request.Query.Bool.Should.Add( new MatchMulti( request.Query.SearchText, setup.SearchFields, setup.Operator, "phrase", 2)); } } SetupBoosting(setup, request); if (setup.FacetFieldNames.Count > 0) { request.Aggregation = GetAggregationQuery(setup.FacetFieldNames); } SetupFilters(setup, request); // Highlighting if (setup.UseHighlight) { request.Highlight = new Highlight { Fields = GetHighlightFields() }; } // Did-you-mean if (setup.EnableDidYouMean) { request.DidYouMeanSuggest = new DidYouMeanSuggest(request.Query.SearchText); } // function_score. Must be the last operation in this method. // Cannot use Gauss and ScriptScore simultaneously if (setup.ScriptScore != null && setup.Gauss.Count > 0) { throw new Exception("Cannot use Gauss and ScriptScore simultaneously"); } if (setup.ScriptScore != null) { request.Query = new FunctionScoreQuery(request.Query, setup.ScriptScore); } if (setup.Gauss.Count > 0) { request.Query = new FunctionScoreQuery(request.Query, setup.Gauss); } return(request); }
/// <summary> /// Queries the resources managed by Azure Resource Manager for scopes /// specified in the request. /// <see href="https://aka.ms/resource-graph/learntoquery" /> /// </summary> /// <param name='query'> /// Request specifying query and its options. /// </param> /// <param name='customHeaders'> /// Headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> /// <exception cref="ErrorResponseException"> /// Thrown when the operation returned an invalid status code /// </exception> /// <exception cref="SerializationException"> /// Thrown when unable to deserialize the response /// </exception> /// <exception cref="ValidationException"> /// Thrown when a required parameter is null /// </exception> /// <exception cref="System.ArgumentNullException"> /// Thrown when a required parameter is null /// </exception> /// <return> /// A response object containing the response body and response headers. /// </return> public async Task <AzureOperationResponse <QueryResponse> > ResourcesWithHttpMessagesAsync(QueryRequest query, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (ApiVersion == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.ApiVersion"); } if (query == null) { throw new ValidationException(ValidationRules.CannotBeNull, "query"); } if (query != null) { query.Validate(); } // Tracing bool _shouldTrace = ServiceClientTracing.IsEnabled; string _invocationId = null; if (_shouldTrace) { _invocationId = ServiceClientTracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("query", query); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "Resources", tracingParameters); } // Construct URL var _baseUrl = BaseUri.AbsoluteUri; var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "providers/Microsoft.ResourceGraph/resources").ToString(); List <string> _queryParameters = new List <string>(); if (ApiVersion != null) { _queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(ApiVersion))); } if (_queryParameters.Count > 0) { _url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters); } // Create HTTP transport objects var _httpRequest = new HttpRequestMessage(); HttpResponseMessage _httpResponse = null; _httpRequest.Method = new HttpMethod("POST"); _httpRequest.RequestUri = new System.Uri(_url); // Set Headers if (GenerateClientRequestId != null && GenerateClientRequestId.Value) { _httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString()); } if (AcceptLanguage != null) { if (_httpRequest.Headers.Contains("accept-language")) { _httpRequest.Headers.Remove("accept-language"); } _httpRequest.Headers.TryAddWithoutValidation("accept-language", AcceptLanguage); } if (customHeaders != null) { foreach (var _header in customHeaders) { if (_httpRequest.Headers.Contains(_header.Key)) { _httpRequest.Headers.Remove(_header.Key); } _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value); } } // Serialize Request string _requestContent = null; if (query != null) { _requestContent = SafeJsonConvert.SerializeObject(query, SerializationSettings); _httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8); _httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); } // Set Credentials if (Credentials != null) { cancellationToken.ThrowIfCancellationRequested(); await Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false); } // Send Request if (_shouldTrace) { ServiceClientTracing.SendRequest(_invocationId, _httpRequest); } cancellationToken.ThrowIfCancellationRequested(); _httpResponse = await HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false); if (_shouldTrace) { ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse); } HttpStatusCode _statusCode = _httpResponse.StatusCode; cancellationToken.ThrowIfCancellationRequested(); string _responseContent = null; if ((int)_statusCode != 200) { var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); try { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); ErrorResponse _errorBody = SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, DeserializationSettings); if (_errorBody != null) { ex.Body = _errorBody; } } catch (JsonException) { // Ignore the exception } ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent); ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent); if (_shouldTrace) { ServiceClientTracing.Error(_invocationId, ex); } _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw ex; } // Create Result var _result = new AzureOperationResponse <QueryResponse>(); _result.Request = _httpRequest; _result.Response = _httpResponse; if (_httpResponse.Headers.Contains("x-ms-request-id")) { _result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } // Deserialize Response if ((int)_statusCode == 200) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = SafeJsonConvert.DeserializeObject <QueryResponse>(_responseContent, DeserializationSettings); } catch (JsonException ex) { _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw new SerializationException("Unable to deserialize the response.", _responseContent, ex); } } if (_shouldTrace) { ServiceClientTracing.Exit(_invocationId, _result); } return(_result); }
/// <summary> /// Gets executed once the idle timeout has passed /// </summary> private void IdleTimeoutHandler(object state) { //Ensure there are no more idle timeouts until the query finished sending if (_isCanceled) { if (!IsDisposed) { //If it was not manually disposed _logger.Warning("Can not issue an heartbeat request as connection is closed"); if (OnIdleRequestException != null) { OnIdleRequestException(new SocketException((int)SocketError.NotConnected)); } } return; } _logger.Verbose("Connection idling, issuing a Request to prevent idle disconnects"); var request = new QueryRequest(ProtocolVersion, IdleQuery, false, QueryProtocolOptions.Default); Send(request, (ex, response) => { if (ex == null) { //The send succeeded //There is a valid response but we don't care about the response return; } _logger.Warning("Received heartbeat request exception " + ex.ToString()); if (ex is SocketException && OnIdleRequestException != null) { OnIdleRequestException(ex); } }); }
public override Task <QueryResponse> query(QueryRequest request, ServerCallContext context) { return(Task.FromResult(new QueryResponse { SqlData = Program.QueryCommand() })); }
/// <summary> /// Executes Time Series Query in pages of results - Get Events, Get Series or /// Aggregate Series. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='parameters'> /// Time series query request body. /// </param> /// <param name='storeType'> /// For the environments with warm store enabled, the query can be executed /// either on the 'WarmStore' or 'ColdStore'. This parameter in the query /// defines which store the query should be executed on. If not defined, the /// query will be executed on the cold store. /// </param> /// <param name='continuationToken'> /// Continuation token from previous page of results to retrieve the next page /// of the results in calls that support pagination. To get the first page /// results, specify null continuation token as parameter value. Returned /// continuation token is null if all results have been returned, and there is /// no next page of results. /// </param> /// <param name='clientRequestId'> /// Optional client request ID. Service records this value. Allows the service /// to trace operation across services, and allows the customer to contact /// support regarding a particular request. /// </param> /// <param name='clientSessionId'> /// Optional client session ID. Service records this value. Allows the service /// to trace a group of related operations across services, and allows the /// customer to contact support regarding a particular group of requests. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <QueryResultPage> ExecuteAsync(this IQuery operations, QueryRequest parameters, string storeType = default(string), string continuationToken = default(string), string clientRequestId = default(string), string clientSessionId = default(string), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.ExecuteWithHttpMessagesAsync(parameters, storeType, continuationToken, clientRequestId, clientSessionId, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public QueryRequest GetPagesTaggedWithMetadataQueryRequest(Guid metadataId, Guid parentPageId, Guid webSiteId, Guid languageId, int pageIndex, int pageSize, SecurityToken token) { var request = new QueryRequest(languageId, SearchDomains.Pages, token); // Make sure page is searchable request.FilterTags.Add(new Tag(TagNames.IsSearchable, bool.TrueString)); // Make sure pages are published request.FilterTags.Add(new Tag(TagNames.IsPublished, bool.TrueString)); if (parentPageId != Guid.Empty) { // Only search pages under specified page request.FilterTags.Add(new Tag(TagNames.PageParentTreeId, parentPageId)); } if (webSiteId != Guid.Empty) { // Only search pages under specified web site request.FilterTags.Add(new Tag(TagNames.WebSiteId, webSiteId)); } // Add required metadatas as filter request.FilterTags.Add(new Tag(TagNames.GetTagNameForProperty(Metadata.PropertyNameSelectedMetadata), metadataId)); // Set paging request.Paging = GetPaging(pageIndex, pageSize); return request; }
public virtual Task <IEnumerable <DeviceGroup> > GetDeviceGroups(QueryRequest request, CancellationToken cancellationToken) { return(DataSource?.GetDeviceGroups(request, cancellationToken) ?? Task.FromResult(new List <DeviceGroup>().AsEnumerable())); }
public override void Query(IRpcController controller, QueryRequest request, Action<QueryResponse> done) { throw new NotImplementedException(); }
public Task<IEnumerable<Row>> QueryAsync(string cqlQuery, bool retry = false) { var request = new QueryRequest(ProtocolVersion, cqlQuery, false, QueryProtocolOptions.Default); var task = _connection .Send(request) .ContinueSync(GetRowSet); if (!retry) { return task; } return task.ContinueWith(t => { var ex = t.Exception != null ? t.Exception.InnerException : null; if (ex is SocketException) { const string message = "There was an error while executing on the host {0} the query '{1}'"; _logger.Error(string.Format(message, cqlQuery, _connection.Address), ex); //Reconnect and query again return Reconnect() .Then(_ => QueryAsync(cqlQuery, false)); } return task; }).Unwrap(); }
public QueryResponse Query(QueryRequest request) { return client.Query(request); }
private void Exception_Query(QueryRequest req, Exception ex) { _queryResults = new QueryResults(req.ConnectionString, req.SQLStatement, ex.Message); DoSOM(); }
private void Finished_Query(QueryRequest req, QueryResults results) { _queryResults = results; DoSOM(); }
private static void SetupFilters(QuerySetup setup, QueryRequest request) { var filterQuery = new NestedBoolQuery(); // Filter away excluded types if (setup.ExcludedTypes.Count > 0) { filterQuery.Bool.MustNot.AddRange(setup.ExcludedTypes.Select(e => new MatchSimple(DefaultFields.Types, e.GetTypeName().ToLower()))); } foreach (var ex in GetExcludedRoots(setup)) { filterQuery.Bool.MustNot.Add(new MatchSimple(DefaultFields.Id, ex.Key.ToString())); if (ex.Value) { filterQuery.Bool.MustNot.Add(new MatchSimple(DefaultFields.Path, ex.Key.ToString())); } } // Filter on type if (setup.Type != null) { var term = CreateTerm(new Filter(DefaultFields.Types, setup.Type.GetTypeName().ToLower(), null, false, Operator.And)); filterQuery.Bool.Must.Add(term); } // Filter on ranges if (setup.Ranges.Count > 0) { request.Query.Bool.Filter.AddRange(setup.Ranges); } // Filter on root-id if (setup.RootId != 0) { var term = new Term(DefaultFields.Path, Convert.ToString(setup.RootId), true); filterQuery.Bool.Must.Add(term); } // Filter on ACL if (setup.AppendAclFilters && setup.AclPrincipal != null) { var boolQuery = new NestedBoolQuery(); foreach (var role in setup.AclPrincipal.RoleList) { var roleTerm = new MatchSimple(DefaultFields.Acl, $"R:{role}"); boolQuery.Bool.Should.Add(roleTerm); } var userTerm = new MatchSimple(DefaultFields.Acl, $"U:{setup.AclPrincipal.Name}"); boolQuery.Bool.Should.Add(userTerm); boolQuery.Bool.MinimumNumberShouldMatch = 1; request.Query.Bool.Filter.Add(boolQuery); } if (setup.FilterGroups.Count > 0) { foreach (var filterGroup in setup.FilterGroups) { foreach (var filter in filterGroup.Value.Filters) { var boolQuery = new BoolQuery(); if (filter.Operator == Operator.Or) { boolQuery.MinimumNumberShouldMatch = 1; boolQuery.Should = new List <MatchBase>(); if (ArrayHelper.IsArrayCandidate(filter.Value.GetType())) { foreach (object value in (IEnumerable)ArrayHelper.ToArray(filter.Value)) { boolQuery.Should.Add(Term.FromFilter(filter, value)); } } else { boolQuery.Should.Add(Term.FromFilter(filter)); } } else if (filter.Operator == Operator.And) { boolQuery.Must = new List <MatchBase>(); if (ArrayHelper.IsArrayCandidate(filter.Value.GetType())) { foreach (object value in (IEnumerable)ArrayHelper.ToArray(filter.Value)) { boolQuery.Must.Add(Term.FromFilter(filter, value)); } } else { boolQuery.Must.Add(Term.FromFilter(filter)); } } // Use regular or post filter? if (!setup.UsePostfilters) { request.Query.Bool.Filter.Add(Term.FromArrayFilter(filter)); } else { if (filterGroup.Value.Operator == Operator.And) { request.PostFilter.Bool.Must.Add(new NestedBoolQuery(boolQuery)); } else if (filterGroup.Value.Operator == Operator.Or) { request.PostFilter.Bool.Should.Add(new NestedBoolQuery(boolQuery)); } } } } } if (setup.Filters.Count > 0) { // Add not-filters as regular filter regardless of post-filter value IEnumerable <Filter> notFilters = setup.Filters.Where(f => f.Not).ToArray(); filterQuery.Bool.MustNot.AddRange(notFilters.Select(CreateTerm)); // Use regular or post filter? if (!setup.UsePostfilters) { request.Query.Bool.Filter.AddRange( setup.Filters .Except(notFilters) .Select(CreateTerm)); } else { request.PostFilter.Bool.Must.AddRange( setup.Filters .Except(notFilters) .Where(f => f.Operator == Operator.And && !f.Not) .Select(CreateTerm)); request.PostFilter.Bool.Should.AddRange( setup.Filters .Except(notFilters) .Where(f => f.Operator == Operator.Or && !f.Not) .Select(CreateTerm)); } } if (filterQuery.HasAnyValues()) { request.Query.Bool.Filter.Add(filterQuery); } AppendDefaultFilters(request.Query, setup.Type); if (request.Query.Bool.Should.Count > 1 && request.Query.Bool.Must.Count == 0) { request.Query.Bool.MinimumNumberShouldMatch = 1; } else { request.Query.Bool.MinimumNumberShouldMatch = null; } if (request.PostFilter.Bool.Should.Count > 0 && request.PostFilter.Bool.Must.Count == 0) { request.PostFilter.Bool.MinimumNumberShouldMatch = 1; } else { request.PostFilter.Bool.MinimumNumberShouldMatch = null; } }
public QueryRequest GetPageTypeInstancesQueryRequest(Guid pageTypeId, Guid languageId, SecurityToken token) { // Set up page query. var request = new QueryRequest(languageId, CmsSearchDomains.Pages, token); // Set pagetype. request.FilterTags.Add(new Tag(TagNames.PageTypeId, pageTypeId)); // Only published pages. request.FilterTags.Add(new Tag(TagNames.IsPublished, true)); // Sort order. Sorting sorting = new Sorting(TagNames.PageIndex, SortingFieldType.Int); request.Sortings.Add(sorting); // Fetch many. request.Paging = new Paging(1, 999999); return request; }
public virtual Task <IEnumerable <AlarmDeviceStateView> > GetAlarmState(QueryRequest request, CancellationToken cancellationToken) { return(DataSource?.GetAlarmState(request, cancellationToken) ?? Task.FromResult(new List <AlarmDeviceStateView>().AsEnumerable())); }
private void DoQuery(QueryRequest request) { object data = null; Exception exception = null; try { data = request.DataProducer(); } catch (Exception e) { exception = e; } //if (!System.Windows.Application.Current.Dispatcher.CheckAccess()) // System.Windows.Application.Current.Dispatcher.Invoke( // new Action(() => { IsBusy = false; }), // new object[] { }); if (!this._endInitCompete && exception != null) this._endInitError = true; //如果没有取消,则继续通知更改。 if (request.Version == this._queryVersion) { //把结果返回到基类中。 this.OnQueryFinished(data, exception, o => { this.IsBusy = false; return null; }, null); } }
private static QueryResults DoWork_Query(QueryRequest req, CancellationToken cancel) { try { using (SqlConnection connection = new SqlConnection(req.ConnectionString)) { if (cancel.IsCancellationRequested) return new QueryResults(req.ConnectionString, req.SQLStatement, "cancelled"); connection.Open(); if (cancel.IsCancellationRequested) return new QueryResults(req.ConnectionString, req.SQLStatement, "cancelled"); using (SqlCommand command = new SqlCommand(req.SQLStatement, connection)) { using (SqlDataReader reader = command.ExecuteReader()) { if (cancel.IsCancellationRequested) return new QueryResults(req.ConnectionString, req.SQLStatement, "cancelled"); string[] columnNames = null; List<string[]> rows = new List<string[]>(); while (reader.Read()) { if (cancel.IsCancellationRequested) return new QueryResults(req.ConnectionString, req.SQLStatement, "cancelled"); // Column Names if (columnNames == null) { columnNames = new string[reader.VisibleFieldCount]; for (int cntr = 0; cntr < reader.VisibleFieldCount; cntr++) { columnNames[cntr] = reader.GetName(cntr); } } // Row Values string[] row = new string[reader.VisibleFieldCount]; for (int cntr = 0; cntr < reader.VisibleFieldCount; cntr++) { row[cntr] = reader.GetValue(cntr).ToString(); } rows.Add(row); } if (cancel.IsCancellationRequested) return new QueryResults(req.ConnectionString, req.SQLStatement, "cancelled"); if (rows.Count == 0) { return new QueryResults(req.ConnectionString, req.SQLStatement, "No rows found"); } else { return new QueryResults(req.ConnectionString, req.SQLStatement, columnNames, rows.ToArray()); } } } } } catch (Exception ex) { return new QueryResults(req.ConnectionString, req.SQLStatement, ex.Message); } }
public QueryRequest GetPagesTaggedWithMetadataQueryRequest(List<Metadata> requiredMetadatas, List<Metadata> optionalMetadatas, Guid parentPageId, Guid webSiteId, SortType sortType, int pageIndex, int pageSize, Guid languageId, SecurityToken token) { var request = new QueryRequest(languageId, SearchDomains.Pages, token); // Make sure page is searchable request.FilterTags.Add(new Tag(TagNames.IsSearchable, bool.TrueString)); // Make sure pages are published request.FilterTags.Add(new Tag(TagNames.IsPublished, bool.TrueString)); if (parentPageId != Guid.Empty) { // Only search pages under specified page request.FilterTags.Add(new Tag(TagNames.PageParentTreeId, parentPageId)); } if (webSiteId != Guid.Empty) { // Only search pages under specified web site request.FilterTags.Add(new Tag(TagNames.WebSiteId, webSiteId)); } // Add required metadatas as filter foreach (Metadata metadata in requiredMetadatas) { request.FilterTags.Add(new Tag(TagNames.GetTagNameForProperty(Metadata.PropertyNameSelectedMetadata), metadata.ID)); } if (optionalMetadatas != null && optionalMetadatas.Count > 0) { // Add optional metadatas OptionalTagClause optionalMetadatasClause = new OptionalTagClause(); foreach (Metadata metadata in optionalMetadatas) { optionalMetadatasClause.FilterTags.Add(new Tag(TagNames.GetTagNameForProperty(Metadata.PropertyNameSelectedMetadata), metadata.ID)); } request.FilterTags.Add(optionalMetadatasClause); } request.Paging = GetPaging(pageIndex, pageSize); Sorting sorting = GetSortType(sortType); if (sorting != null) { request.Sortings.Add(sorting); } return request; }
public async Task <List <CheckPoint> > ParseLocationHistoryAsync(LocationHistory locationHistory, QueryRequest model, ProgressChangedEventHandler callback) { var locations = BorderCrossingHelper.PrepareLocations(locationHistory, model.IntervalType); var filteredLocations = locations.Where(l => l.Date >= model.StartDate && l.Date <= model.EndDate).OrderBy(l => l.TimestampMsUnix).ToList(); var currentLocation = filteredLocations.First(); var currentCountry = GetCountryName(currentLocation.Point); var i = 0; var count = filteredLocations.Count(); var checkPoints = new List <CheckPoint> { BorderCrossingHelper.LocationToCheckPoint(currentLocation, currentCountry) }; foreach (var location in filteredLocations) { await Task.Run(() => { i++; callback(this, new ProgressChangedEventArgs((int)(100.0 * i / count), null)); var countryName = GetCountryName(location.Point); if (currentCountry == countryName) { currentLocation = location; return; } var range = locationHistory.Locations.Where(lh => lh.TimestampMsUnix >= currentLocation.TimestampMsUnix && lh.TimestampMsUnix <= location.TimestampMsUnix).ToList(); var checkPoint = BorderCrossingHelper.FindCheckPoint(range, currentLocation, currentCountry, location, countryName, GetCountryName); checkPoints.Add(checkPoint); currentCountry = countryName; currentLocation = location; }); } var last = filteredLocations.Last(); checkPoints.Add(BorderCrossingHelper.LocationToCheckPoint(last, GetCountryName(last.Point))); return(checkPoints); }
public Hashtable GetItem(Hashtable State, string tableName, string PrimaryKeyValue, string RangeKeyValue) { if (State["DynamoDBClient"] == null) SetupClient(State); AmazonDynamoDB client = (AmazonDynamoDB)State["DynamoDBClient"]; var request = new QueryRequest { TableName = tableName, HashKeyValue = new AttributeValue { S = PrimaryKeyValue }, // Optional parameters. RangeKeyCondition = new Condition { ComparisonOperator = "EQ", AttributeValueList = new List<AttributeValue>() { new AttributeValue { S = RangeKeyValue } } }, ConsistentRead = true }; var response = client.Query(request); foreach (Dictionary<string, AttributeValue> item in response.QueryResult.Items) { Hashtable map = new Hashtable(); foreach (string key in item.Keys) { AttributeValue value = item[key]; map[key] = value.S; } return map; } return null; }
/// <remarks/> public System.IAsyncResult BeginQuery(QueryRequest queryRequest, System.AsyncCallback callback, object asyncState) { return(this.BeginInvoke("Query", new object[] { queryRequest }, callback, asyncState)); }
public ArrayList GetItems(Hashtable State, string tableName, string PrimaryKeyValue) { ArrayList output = new ArrayList(); try { if (State["DynamoDBClient"] == null) SetupClient(State); AmazonDynamoDB client = (AmazonDynamoDB)State["DynamoDBClient"]; var request = new QueryRequest { TableName = tableName, HashKeyValue = new AttributeValue { S = PrimaryKeyValue } }; var response = client.Query(request); foreach (Dictionary<string, AttributeValue> item in response.QueryResult.Items) { Hashtable map = new Hashtable(); foreach (string key in item.Keys) { AttributeValue value = item[key]; map[key] = value.S; } output.Add(map); } } catch (Exception ex) { string error = ex.Message; return null; } return output; }
/// <summary> /// Initializes a new instance of the <see cref="QueryRequestTests"/> class. /// </summary> public QueryRequestTests() { var query = new QueryableSource <object>(Expression.Constant(this.query)); testClass = new QueryRequest(query); }
/// <summary> /// Overridden. Starts to create the requested object, /// either immediately or on a background thread, /// based on the value of the IsAsynchronous property. /// </summary> protected override void BeginQuery() { if (_init) return; if (_firstRun) { _firstRun = false; if (!IsInitialLoadEnabled) return; } if (_endInitError) { // this handles a case where the WPF form initilizer // invokes the data provider twice when an exception // occurs - we really don't want to try the query twice // or report the error twice _endInitError = false; OnQueryFinished(null); return; } if (this.IsRefreshDeferred) return; QueryRequest request = new QueryRequest(); request.ObjectType = _objectType; request.FactoryMethod = _factoryMethod; request.FactoryParameters = _factoryParameters; request.ManageObjectLifetime = _manageLifetime; IsBusy = true; if (IsAsynchronous) System.Threading.ThreadPool.QueueUserWorkItem(DoQuery, request); else DoQuery(request); }
public static async Task <PagingData <T> > AsPagingData <T>(this IAsyncEnumerable <T> data, QueryRequest query, QueryStatistic statistic) { return((await data.ToArrayAsync().ConfigureAwait(false)).AsPagingData(query, statistic)); }
/// <summary> /// Waits until that the schema version in all nodes is the same or the waiting time passed. /// This method blocks the calling thread. /// </summary> internal void WaitForSchemaAgreement(Connection connection) { if (Hosts.Count == 1) { //If there is just one node, the schema is up to date in all nodes :) return; } var start = DateTime.Now; var waitSeconds = _config.ProtocolOptions.MaxSchemaAgreementWaitSeconds; Logger.Info("Waiting for schema agreement"); try { var totalVersions = 0; while (DateTime.Now.Subtract(start).TotalSeconds < waitSeconds) { var schemaVersionLocalQuery = new QueryRequest(connection.ProtocolVersion, SelectSchemaVersionLocal, false, QueryProtocolOptions.Default); var schemaVersionPeersQuery = new QueryRequest(connection.ProtocolVersion, SelectSchemaVersionPeers, false, QueryProtocolOptions.Default); var queries = new [] { connection.Send(schemaVersionLocalQuery), connection.Send(schemaVersionPeersQuery) }; // ReSharper disable once CoVariantArrayConversion Task.WaitAll(queries, _config.ClientOptions.QueryAbortTimeout); var versions = new HashSet<Guid> { Cassandra.ControlConnection.GetRowSet(queries[0].Result).First().GetValue<Guid>("schema_version") }; var peerVersions = Cassandra.ControlConnection.GetRowSet(queries[1].Result).Select(r => r.GetValue<Guid>("schema_version")); foreach (var v in peerVersions) { versions.Add(v); } totalVersions = versions.Count; if (versions.Count == 1) { return; } Thread.Sleep(500); } Logger.Info(String.Format("Waited for schema agreement, still {0} schema versions in the cluster.", totalVersions)); } catch (Exception ex) { //Exceptions are not fatal Logger.Error("There was an exception while trying to retrieve schema versions", ex); } }
public async Task <IReadOnlyList <ResourceDto> > GetSqlResourcesAsync(string _subscriptionId) { if (string.IsNullOrWhiteSpace(_subscriptionId)) { return(null); } DefaultAzureCredential credential; if (_sqlResourceInventoryConfiguration.UseSystemAssignedManagedIdentity) { credential = new DefaultAzureCredential(); } else { credential = new DefaultAzureCredential(new DefaultAzureCredentialOptions { ManagedIdentityClientId = _sqlResourceInventoryConfiguration.UserAssignedManagedIdentityClientId }); } TokenRequestContext tokenRequestContext = new TokenRequestContext(new[] { Constants.AzureResourceManagerAPIDefaultScope }); AccessToken tokenRequestResult = await credential.GetTokenAsync(tokenRequestContext); ServiceClientCredentials serviceClientCreds = new TokenCredentials(tokenRequestResult.Token); ResourceGraphClient argClient = new ResourceGraphClient(serviceClientCreds); QueryRequest request = new QueryRequest(); request.Subscriptions = new List <string>() { _subscriptionId }; request.Query = "Resources |" + " where type in ('microsoft.sql/servers','microsoft.sqlvirtualmachine/sqlvirtualmachines','Microsoft.Sql/managedInstances') |" + " project id, name, type, location, resourceGroup, subscriptionId, tenantId"; request.Options = new QueryRequestOptions() { ResultFormat = ResultFormat.ObjectArray }; // Parameter to hold full list of returned resources List <ResourceDto> results = new List <ResourceDto>(); // Send query to the ResourceGraphClient and get response QueryResponse response = argClient.Resources(request); // IMPORTANT: The query must project the id field in order for pagination to work. // If it's missing from the query, the response won't include the $skipToken. if (response.Count > 0) { // Add response results to list results.AddRange(((JArray)response.Data).ToObject <List <ResourceDto> >()); // Continue till SkipToken is null while (!string.IsNullOrWhiteSpace(response.SkipToken)) { // Update request with new skip token returned from response request.Options.SkipToken = response.SkipToken; // Send query with SkipToken to the ResourceGraphClient and get response response = argClient.Resources(request); // Add response results to list results.AddRange(((JArray)response.Data).ToObject <List <ResourceDto> >()); } } IReadOnlyList <ResourceDto> returnList = results.ToList().AsReadOnly(); return(returnList); }
public List<Guid> GetMetadataIdList(QueryRequest request) { SearchResponse response = Solution.Instance.SearchService.Search(request); return response.Hits.Select(hit => new Guid(hit.Id)).ToList(); }
private void SetupBoosting(QuerySetup setup, QueryRequest request) { if (!setup.UseBoosting) { return; } List <Boost> boosting = GetBoosting(setup.Type, setup.BoostFields); if (boosting.Count > 0) { var searchText = request.Query.SearchText.Replace("*", String.Empty); if (!TextUtil.IsNumeric(searchText)) { boosting.RemoveAll(b => b.FieldName.Equals(DefaultFields.Id)); } request.Query.Bool.Should.AddRange( boosting.Select(b => new MatchWithBoost(b.FieldName, searchText, b.Weight, setup.Operator))); } // Boosting by type if (setup.BoostTypes.Count > 0) { request.Query.Bool.Should.AddRange( setup.BoostTypes.Select(b => new MatchWithBoost(DefaultFields.Types, b.Key.GetTypeName(), b.Value, setup.Operator))); // Direct match in Type gives higher score than match in Types, hence the +1 request.Query.Bool.Should.AddRange( setup.BoostTypes.Select(b => new MatchWithBoost(DefaultFields.Type, b.Key.GetTypeName(), b.Value + 1, setup.Operator))); } if (setup.BoostAncestors.Count > 0) { request.Query.Bool.Should.AddRange( setup.BoostAncestors.Select(b => new MatchWithBoost(DefaultFields.Path, b.Key.ToString(), b.Value, setup.Operator))); request.Query.Bool.Should.AddRange( setup.BoostAncestors.Select(b => new MatchWithBoost(DefaultFields.Id, b.Key.ToString(), b.Value, setup.Operator))); } // Best Bets if (setup.UseBestBets && !String.IsNullOrWhiteSpace(request.Query.SearchText)) { IEnumerable <string> terms = request.Query.SearchText .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries) .Select(t => t.Trim().Trim('*')); var key = setup.IndexName ?? _settings.GetDefaultIndexName(Language.GetLanguageCode(setup.Language)); if (!Conventions.Indexing.BestBets.TryGetValue(key, out var bestBetsForLanguage)) { return; } IEnumerable <BestBet> bestBets = bestBetsForLanguage .Where(b => b.Terms.Any(t => terms.Contains(t))); request.Query.Bool.Should.AddRange( bestBets.Select(_ => new MatchWithBoost( DefaultFields.BestBets, request.Query.SearchText.Trim('*'), BestBetMultiplier, setup.Operator))); } }
/// <summary> /// Gets <see cref="Metadata"/> with complete set of information. /// </summary> /// <param name="request">The request.</param> /// <param name="searchService">The search service.</param> /// <param name="permissionManager">The permission manager.</param> /// <param name="token">The token.</param> /// <returns></returns> public List<Metadata> GetMetadatas(QueryRequest request, Litium.Foundation.Modules.CMS.Security.PermissionManager permissionManager, SecurityToken token) { // Perform search SearchResponse response = Solution.Instance.SearchService.Search(request); if (response == null) { _log.Error("Search returned null instead of zero results."); return new List<Metadata>(); } List<Page> pages = GetPagesFromSearchResponse(response, permissionManager, token); List<Metadata> mds = new List<Metadata>(); foreach (Page page in pages) { mds.Add(new Metadata(page, this, token)); } return mds; }
public async Task <ActionResult> PerformQuery([FromBody] QueryRequest request) { QueryResponse res = await DomainService.ServiceGetData(request); return(new ChunkedResult <QueryResponse>(res, DomainService.Serializer)); }
public static async Task <QueryResponse <TModel> > QueryContent <TModel>(this ISquidexContentClient that, string app, string schema, QueryRequest request) { dynamic raw = await that.QueryContent(app, schema, request.Top, request.Skip, request.OrderBy, request.Search, request.Filter); var deserialized = JsonConvert.DeserializeObject <QueryResponse <TModel> >(raw.ToString()); return(deserialized); }
public virtual Task <IEnumerable <GrafanaAdapters.AlarmState> > GetDeviceAlarms(QueryRequest request, CancellationToken cancellationToken) { return(DataSource?.GetDeviceAlarms(request, cancellationToken) ?? Task.FromResult(new List <GrafanaAdapters.AlarmState>().AsEnumerable())); }
public IQueryResult <IQueryPlan> Prepare(string statementToPrepare) { IQueryRequest query = new QueryRequest(statementToPrepare); return(Prepare(query)); }
public virtual Task <List <GrafanaAlarm> > GetAlarms(QueryRequest request, CancellationToken cancellationToken) { return(DataSource?.GetAlarms(request, cancellationToken) ?? Task.FromResult(new List <GrafanaAlarm>())); }
public override void Query(Google.ProtocolBuffers.IRpcController controller, QueryRequest request, Action<QueryResponse> done) { throw new NotImplementedException(); }
public static void RetrieveData(PredictorTrainingContext ctx) { using (HeavyProfiler.Log("RetrieveData")) { ctx.ReportProgress($"Executing MainQuery for {ctx.Predictor}"); QueryRequest mainQueryRequest = GetMainQueryRequest(ctx.Predictor.MainQuery); ResultTable mainResult = QueryLogic.Queries.ExecuteQuery(mainQueryRequest); ctx.MainQuery = new MainQuery { QueryRequest = mainQueryRequest, ResultTable = mainResult, }; if (!mainQueryRequest.GroupResults) { ctx.MainQuery.GetParentKey = (ResultRow row) => new object[] { row.Entity }; } else { var rcs = mainResult.Columns.Where(a => !(a.Column.Token is AggregateToken)).ToArray(); ctx.MainQuery.GetParentKey = (ResultRow row) => row.GetValues(rcs); } var algorithm = PredictorLogic.Algorithms.GetOrThrow(ctx.Predictor.Algorithm); ctx.SubQueries = new Dictionary <PredictorSubQueryEntity, SubQuery>(); foreach (var sqe in ctx.Predictor.SubQueries) { ctx.ReportProgress($"Executing SubQuery {sqe}"); QueryRequest queryGroupRequest = ToMultiColumnQuery(ctx.Predictor.MainQuery, sqe); ResultTable groupResult = QueryLogic.Queries.ExecuteQuery(queryGroupRequest); var pairs = groupResult.Columns.Zip(sqe.Columns, (rc, sqc) => (rc, sqc)).ToList(); var parentKeys = pairs.Extract(a => a.sqc.Usage == PredictorSubQueryColumnUsage.ParentKey).Select(a => a.rc).ToArray(); var splitKeys = pairs.Extract(a => a.sqc.Usage == PredictorSubQueryColumnUsage.SplitBy).Select(a => a.rc).ToArray(); var values = pairs.Select(a => a.rc).ToArray(); var groupedValues = groupResult.Rows.AgGroupToDictionary( row => row.GetValues(parentKeys), gr => gr.ToDictionaryEx( row => row.GetValues(splitKeys), row => row.GetValues(values), ObjectArrayComparer.Instance)); ctx.SubQueries.Add(sqe, new SubQuery { SubQueryEntity = sqe, QueryGroupRequest = queryGroupRequest, ResultTable = groupResult, GroupedValues = groupedValues, SplitBy = splitKeys, ValueColumns = values, ColumnIndexToValueIndex = values.Select((r, i) => KeyValuePair.Create(r.Index, i)).ToDictionary() }); } ctx.ReportProgress($"Creating Columns"); var codifications = new List <PredictorCodification>(); using (HeavyProfiler.Log("MainQuery")) { for (int i = 0; i < mainResult.Columns.Length; i++) { var col = ctx.Predictor.MainQuery.Columns[i]; using (HeavyProfiler.Log("Columns", () => col.Token.Token.ToString())) { var mainCol = new PredictorColumnMain(col, i); var mainCodifications = algorithm.GenerateCodifications(col.Encoding, mainResult.Columns[i], mainCol); codifications.AddRange(mainCodifications); } } } foreach (var sq in ctx.SubQueries.Values) { using (HeavyProfiler.Log("SubQuery", () => sq.ToString() !)) { var distinctKeys = sq.GroupedValues.SelectMany(a => a.Value.Keys).Distinct(ObjectArrayComparer.Instance).ToList(); distinctKeys.Sort(ObjectArrayComparer.Instance); foreach (var ks in distinctKeys) { using (HeavyProfiler.Log("Keys", () => ks.ToString(k => k?.ToString(), ", "))) { foreach (var vc in sq.ValueColumns) { var col = sq.SubQueryEntity.Columns[vc.Index]; using (HeavyProfiler.Log("Columns", () => col.Token.Token.ToString())) { var subCol = new PredictorColumnSubQuery(col, vc.Index, sq.SubQueryEntity, ks); var subQueryCodifications = algorithm.GenerateCodifications(col.Encoding, vc, subCol); codifications.AddRange(subQueryCodifications); } } } } } } ctx.SetCodifications(codifications.ToArray()); } }
/// <summary> /// Get a metadata by its name. /// </summary> /// <param name="request">The request.</param> /// <param name="token">The security token.</param> /// <returns></returns> public Metadata GetMetadata(QueryRequest request, SecurityToken token) { SearchResponse response = Solution.Instance.SearchService.Search(request); if (response != null) { if (response.Hits.Count > 0) { foreach (Hit hit in response.Hits) { Guid pageId = new Guid(hit.Id); if (Page.ExistsPage(pageId)) { Page page = Page.GetFromID(pageId, token); return new Metadata(page, this, token); } } } } else { _log.Error("Search returned null instead of zero results."); } return null; }
public ResultTable ExecuteQuery(QueryRequest request) { return(Execute(ExecuteType.ExecuteQuery, request.QueryName, request, dqb => dqb.Core.Value.ExecuteQuery(request))); }
public ListResponse<PharmacyDto> GetMatchingPharmacies(QueryRequest<PharmacyQuery> request) { try { using (var dbContext = new AptekaNETDbContext()) { var pharmacies = dbContext.Pharmacies.AsEnumerable().Where(p => request.Query.IsMatch(p)).ToList(); if (pharmacies.Any()) { var pharmacyDtos = pharmacies.Select(p => _pharmacyAssembler.ToDto(p)).ToList(); return new ListResponse<PharmacyDto>(request.Id, pharmacyDtos) { Message = "Pobrano pomyślnie" }; } return new ListResponse<PharmacyDto>(request.Id, new List<PharmacyDto>()) { Message = "Nie ma apteki spełniającej powyższe warunki" }; } } catch (Exception e) { return new ListResponse<PharmacyDto>(request.Id, new List<PharmacyDto>()) { Message = "Błąd" }; } }
public ListResponse<OrderIngredientDTO> QueryIngredients(QueryRequest<IngredientsQuery> request) { if (request.Query.IngredientIds == null) throw PizzaServiceFault.Create(Messages.NO_DATA); return db.inTransaction(uow => { return ListResponse.Create(uow.Db.Ingredients.Find(request.Query.IngredientIds).ToList() .Select(ingAssembler.ToOrderIngredientDto).ToList()); }); }
public System.IAsyncResult BeginlistTemplates(QueryRequest listTemplates, System.AsyncCallback callback, object asyncState) { return this.BeginInvoke("listTemplates", new object[] { listTemplates}, callback, asyncState); }
public virtual async Task <IHttpActionResult> Query(HttpRequestMessage request, QueryRequest query) { var svc = DataService; if (svc == null) { var response = Request.CreateResponse(HttpStatusCode.NotFound, "Service not found"); throw new HttpResponseException(response); } var res = await svc.ServiceGetData(query).ConfigureAwait(false); return(new ChunkedActionResult <QueryResponse>(request, res, _serializer)); }
/// <summary> /// Queries the resources managed by Azure Resource Manager for all /// subscriptions specified in the request. /// <see href="https://aka.ms/resource-graph/learntoquery" /> /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='query'> /// Request specifying query and its options. /// </param> public static QueryResponse Resources(this IResourceGraphClient operations, QueryRequest query) { return(operations.ResourcesAsync(query).GetAwaiter().GetResult()); }
public static QueryResponse Query(this IAmazonDynamoDB client, QueryRequest request) { return(client.QueryAsync(request).GetResult()); }
/// <summary> /// Queries the resources managed by Azure Resource Manager for all /// subscriptions specified in the request. /// <see href="https://aka.ms/resource-graph/learntoquery" /> /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='query'> /// Request specifying query and its options. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <QueryResponse> ResourcesAsync(this IResourceGraphClient operations, QueryRequest query, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.ResourcesWithHttpMessagesAsync(query, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <remarks/> public void QueryAsync(QueryRequest queryRequest) { this.QueryAsync(queryRequest, null); }
public Task <HttpResponse <QueryTransactionResponse> > QueryTransactionAsync(QueryRequest requestModel) { return(_apiHttpClient.PostRequest <QueryTransactionResponse>(_configuration.ApiUrls.ReportingTransactions, _configuration.SecretKey, requestModel)); }
public QueryResult ExecuteQuery(QueryRequest gql, TContextType context, IServiceProvider serviceProvider, ClaimsIdentity claims, IMethodProvider methodProvider = null) { return(ExecuteQueryAsync(gql, context, serviceProvider, claims, methodProvider).Result); }
public Task <HttpResponse <QueryChargebackResponse> > QueryChargebackAsync(QueryRequest requestModel) { return(_apiHttpClient.PostRequest <QueryChargebackResponse>(_configuration.ApiUrls.ReportingChargebacks, _configuration.SecretKey, requestModel)); }
public static void Main(string[] args) { // connect to couchbase cluster and get a bucket // this example assumes a couchbase node running locally // this example assumes a bucket exists called 'default var client = new ClientConfiguration { Servers = new List <Uri> { new Uri("couchbase://localhost") } }; ClusterHelper.Initialize(client); var bucket = ClusterHelper.GetBucket("default"); // create some documents that *don't* have a 'processed' field // tag::createdocuments[] for (var i = 0; i < 5; i++) { var docKey = Guid.NewGuid().ToString(); var docContent = new { foo = "bar", type = "example", processed = false, dt = DateTime.Now }; var docContentJson = JsonConvert.SerializeObject(docContent); bucket.Insert(new Document <dynamic> { Id = docKey, Content = docContent }); Console.WriteLine($"Inserted: {docKey} - {docContentJson}"); } // end::createdocuments[] Console.WriteLine(); // update all 'example' documents, setting a 'processed' field to true // and use RETURNING keyword to get the documents that were processed // Note that you need (at least) a primary key index on the default // tag::updatereturning[] var n1ql = @"UPDATE `default` d SET processed = true WHERE d.type = 'example' AND d.processed = false RETURNING d.*, META().id AS docKey"; var query = QueryRequest.Create(n1ql); query.ScanConsistency(ScanConsistency.RequestPlus); var results = bucket.Query <dynamic>(query); // end::updatereturning[] if (!results.Success) { Console.WriteLine("There was an error."); Console.WriteLine(results.Message); results.Errors.ForEach(e => Console.WriteLine(e.Message)); } // the results should be the same five documents created initially (but with processed fields) // tag::showreturning[] foreach (var result in results.Rows) { var resultJson = JsonConvert.SerializeObject(result); Console.WriteLine($"Returned: {resultJson}"); } // end::showreturning[] }
/// <summary> /// Serializes QueryRequest to an XML stream. /// </summary> /// <param name="writer">XML stream to write.</param> /// <param name="queryRequest">QueryRequest.</param> /// <returns>XML stream with the QueryRequest.</returns> public static XmlWriter Serialize(XmlWriter writer, QueryRequest queryRequest) { writer.WriteStartElement(DTD.Request.TagQueryRequest); writer.WriteAttributeString(DTD.Request.QueryRequest.TagClass, queryRequest.Class); writer.WriteAttributeString(DTD.Request.QueryRequest.TagDisplaySet, queryRequest.DisplayItems); if (queryRequest.IsQueryInstance) { XMLQueryInstanceSerializer.Serialize(writer, queryRequest.QueryInstance); } else { if (queryRequest.IsQueryFilter) { XMLQueryFilterSerializer.Serialize(writer, queryRequest.QueryFilter); } else { if (queryRequest.IsQueryRelated) { XMLQueryRelatedSerializer.Serialize(writer, queryRequest.QueryRelated); } } } if (queryRequest.OrderCriteria.Length > 0) { writer.WriteStartElement(DTD.Request.QueryRequest.TagSort); writer.WriteAttributeString(DTD.Request.QueryRequest.TagSortCriterium, queryRequest.OrderCriteria); writer.WriteEndElement(); } if (queryRequest.NavigationalFiltering != null) { XMLNavigationFilteringSerializer.Serialize(writer, queryRequest.NavigationalFiltering); } writer.WriteEndElement(); return writer; }
/// <summary> /// Sets the keyspace of the connection. /// If the keyspace is different from the current value, it sends a Query request to change it /// </summary> public Task<bool> SetKeyspace(string value) { if (String.IsNullOrEmpty(value) || _keyspace == value) { //No need to switch return TaskHelper.Completed; } Task<bool> keyspaceSwitch; try { if (!_keyspaceSwitchSemaphore.Wait(0)) { //Could not enter semaphore //It is very likely that the connection is already switching keyspace keyspaceSwitch = _keyspaceSwitchTask; if (keyspaceSwitch != null) { return keyspaceSwitch.Then(_ => { //validate if the new keyspace is the expected if (_keyspace != value) { //multiple concurrent switches to different keyspace return SetKeyspace(value); } return TaskHelper.Completed; }); } _keyspaceSwitchSemaphore.Wait(); } } catch (ObjectDisposedException) { //The semaphore was disposed, this connection is closed return TaskHelper.FromException<bool>(new SocketException((int) SocketError.NotConnected)); } //Semaphore entered if (_keyspace == value) { //While waiting to enter the semaphore, the connection switched keyspace try { _keyspaceSwitchSemaphore.Release(); } catch (ObjectDisposedException) { //this connection is now closed but the switch completed successfully } return TaskHelper.Completed; } var request = new QueryRequest(ProtocolVersion, string.Format("USE \"{0}\"", value), false, QueryProtocolOptions.Default); _logger.Info("Connection to host {0} switching to keyspace {1}", Address, value); keyspaceSwitch = _keyspaceSwitchTask = Send(request).ContinueSync(r => { _keyspace = value; try { _keyspaceSwitchSemaphore.Release(); } catch (ObjectDisposedException) { //this connection is now closed but the switch completed successfully } _keyspaceSwitchTask = null; return true; }); return keyspaceSwitch; }
static async Task Main(string[] args) { var continueOp = true; var justFirstTime = true; int?trackId = null; var request = default(object); while (continueOp) { if (justFirstTime) { PrintInfo(); justFirstTime = false; } var trackIdText = trackId.HasValue ? $"(trackId = {trackId})" : ""; Write($"operation {trackIdText} -> "); var op = ReadLine(); switch (op.ToUpper()) { case "R": WriteLine("Reset traking Id", ConsoleColor.Cyan); trackId = null; break; case "U": WriteLine("Using a traking Id", ConsoleColor.Cyan); if (!TryInputInt("trackId", out int trackIdPased)) { break; } if (trackIdPased <= 0) { WriteLine("The trackId should be positive"); break; } trackId = trackIdPased; break; case "D": WriteLine("Divide", ConsoleColor.Cyan); if (!TryInputInt("dividend", out int dividend)) { break; } if (!TryInputInt("divisor", out int divisor)) { break; } request = new DivRequest() { Dividend = dividend, Divisor = divisor }; await PostAndPrint("div", request, trackId); break; case "M": WriteLine("Multiplication", ConsoleColor.Cyan); if (!TryInputListInt(out List <int> toSend)) { break; } request = new MultRequest() { Factors = toSend }; await PostAndPrint("mult", request, trackId); break; case "Q": WriteLine("Square", ConsoleColor.Cyan); if (!TryInputInt("number", out int number)) { break; } request = new SqrtRequest() { Number = number }; await PostAndPrint("sqrt", request, trackId); break; case "S": WriteLine("Substract", ConsoleColor.Cyan); if (!TryInputInt("minuend", out int minuend)) { break; } if (!TryInputInt("subtrahend", out int subtrahend)) { break; } request = new SubRequest() { Minuend = minuend, Subtrahend = subtrahend }; await PostAndPrint("sub", request, trackId); break; case "A": WriteLine("Sum", ConsoleColor.Cyan); if (!TryInputListInt(out toSend)) { break; } request = new SumRequest() { Addends = toSend }; await PostAndPrint("add", request, trackId); break; case "G": WriteLine("Query", ConsoleColor.Cyan); if (!TryInputInt("trackId", out int trackIdToSend)) { break; } request = new QueryRequest() { Id = trackIdToSend }; await PostAndPrint("query", request, trackId); break; case "O": WriteLine("Operations", ConsoleColor.Cyan); await GetAndPrint("operations"); break; case "E": continueOp = false; break; case "I": PrintInfo(); break; default: WriteLine("Invalid operation!", ConsoleColor.Red); break; } } WriteLine("Bye :)"); }
public override void Query(IRpcController controller, QueryRequest request, Action<QueryResponse> done) { ProtoOutputBuffer.Write(request.GetType(), request.ToString()); }
public ListResponse<OrderIngredientDTO> QueryIngredients(QueryRequest<IngredientsQuery> req) { if (req.Query.Login != "Admin") throw new FaultException<PizzaServiceFault>(new PizzaServiceFault("wrong user")); var list = new List<OrderIngredientDTO>(); foreach (var i in req.Query.IngredientIds) list.Add(new OrderIngredientDTO() { Name = String.Format("Ingredient {0}",i), IngredientID = i }); return new ListResponse<OrderIngredientDTO>(list); }