public void BulkIndexTest() { var objs = new[] { new Variable { PackageId = "pack", Name = "name1" }, new Variable { PackageId = "pack", Name = "name2" }, new Variable { PackageId = "pack", Name = "name3" }, new Variable { PackageId = "pack", Name = "name4" }, new Variable { PackageId = "pack2", Name = "black" } }; var bulk = new BulkDescriptor(); bulk.IndexMany(objs, (d, v) => d .Index("test") //.Type("variable") .Document(v)); var objs2 = new[] { new Variable { PackageId = "pack4", Name = "name1" }, new Variable { PackageId = "pack4", Name = "name2" }, }; bulk.IndexMany(objs2, (d, v) => d .Index("test") //.Type("variable") .Document(v)); bulk.DeleteMany(new Variable[0], (d, v) => d.Index("test").Id("1")); client.Bulk(bulk); }
/// <summary> /// Synchronize mediaRef picons /// </summary> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task <IBulkResponse> SynkPiconsAsync(CancellationToken cancellationToken) { var response = await _elasticConnectionClient.Client.Value.SearchAsync <MediaRef>(s => s .Index(_elasticConnectionClient.ElasticConfig.MediaRefIndex) .Size(_elasticConnectionClient.ElasticConfig.MaxResultWindow) .From(0) .Query(q => q.MatchAll()) , cancellationToken); var tasks = response.Documents.Select(async m => { //Match all displaynames with boost var findLogoResponse = await _elasticConnectionClient.Client.Value.SearchAsync <Picon>(x => x.Query(q => q.Match(fz => fz.Field(f => f.Name) .Query(m.DisplayNames.FirstOrDefault().RemoveDiacritics().RemoveChars(new char[] { ' ' })))).Size(1), cancellationToken); if (findLogoResponse.Documents.Any()) { m.Tvg.Logo = findLogoResponse.Documents.First().RawUrl; } }); await Task.WhenAll(tasks); var descriptor = new BulkDescriptor(); descriptor.IndexMany(response.Documents); return(await _elasticConnectionClient.Client.Value.BulkAsync(descriptor, cancellationToken)); }
private BulkDescriptor CreateBulk(IEnumerable <G> entities) { var bulkDescriptor = new BulkDescriptor(); bulkDescriptor.IndexMany <G>(entities, (descriptor, s) => descriptor.Index(indexName).Id(s.Id.ToString())); return(bulkDescriptor); }
public void IndexJsonObject(IEnumerable <Dictionary <string, object> > obj1, string indexName, string type) { var bdesc = new BulkDescriptor(); bdesc.IndexMany(obj1, (f, g) => f.Index(indexName).Type(type)); var x = _elasticClient.Bulk(bdesc); }
public async Task <IBulkResponse> SaveAsync(List <MediaRef> mediasRef, CancellationToken cancellationToken) { var descriptor = new BulkDescriptor(); descriptor.IndexMany(mediasRef); descriptor.Refresh(Elasticsearch.Net.Refresh.True); return(await _elasticConnectionClient.Client.Value.BulkAsync(descriptor, cancellationToken)); }
private BulkDescriptor CreateBulk(IEnumerable <T> documents, string index, List <string> ids) { var bulkDescriptor = new BulkDescriptor(); int idx = 0; bulkDescriptor.IndexMany(documents, (descriptor, s) => descriptor.Index(index).Id(ids[idx++])); return(bulkDescriptor); }
public async Task <IBulkResponse> SaveAsync(List <SitePackChannel> sitepacks, CancellationToken cancellationToken) { var descriptor = new BulkDescriptor(); descriptor.Pipeline(ElasticConnectionClient.SITE_PACK_PIPELINE); descriptor.IndexMany(sitepacks); descriptor.Refresh(Elasticsearch.Net.Refresh.True); return(await _elasticConnectionClient.Client.Value.BulkAsync(descriptor, cancellationToken)); }
private async Task<BulkResponse> IndexMany(IEnumerable<T> models) { var descriptor = new BulkDescriptor(); descriptor.IndexMany(models, (bd, q) => bd .Index(_indexName) .Id(q.Id.ToString()) ); return await _client.BulkAsync(descriptor); }
protected virtual BulkDescriptor BuildQueryCore(BulkDescriptor descriptor, string index, bool refreshOnSave) { descriptor = descriptor .IndexMany(_documents, (d, i) => d .Type(i.GetType()) .Index(index) ) .Refresh(refreshOnSave); return(BuildQuery(descriptor)); }
public void BulkIndex <T>(IEnumerable <T> data, string indexName) where T : class { var descriptor = new BulkDescriptor(); descriptor.IndexMany(data, (desc, content) => desc.Type(content.GetType()).Index(indexName)); var response = _client.Bulk(descriptor); if (response.Errors) { throw new Exception("Failed while indexing items.", response.OriginalException); } }
public void RecordChanges(INestedAspect compareTo, BulkDescriptor bulk) { var correlation = byLocalName.CorrelateWith((compareTo as VariableSet)?.byLocalName); bulk.IndexMany( correlation.SourceItems.Where(t => t.Item.IsChanged(t.PairedWith)).Select(t => t.Item), (d, v) => d.Index(Constants.ControlIndex).Document(v)); bulk.DeleteMany( correlation.NonSourceItems.Select(v => v.Item), (d, v) => d.Index(Constants.ControlIndex).Id(v.Id)); }
public async Task <IBulkResponse> SynkAsync(CancellationToken cancellationToken) { var response = await _elasticConnectionClient.Client.Value.SearchAsync <SitePackChannel>(s => s .Index(_elasticConnectionClient.ElasticConfig.SitePackIndex) .Size(_elasticConnectionClient.ElasticConfig.MaxResultWindow) .From(0) .Aggregations(a => a .Terms("unique", te => te .Field(f => f.Channel_name.Suffix(ElasticConfig.ELK_KEYWORD_SUFFIX)) .Order(o => o .KeyAscending() .CountDescending()) ) ) , cancellationToken); var mediasRef = response.Documents.Select(x => new MediaRef(x.Channel_name, x.Site, x.Country, x.Xmltv_id, x.Id)).ToList(); //var qc = new QueryContainerDescriptor<Picon>(); //var query = mediasRef.SelectMany(x => x.DisplayNames.Take(2)) // .Select(val => qc.Fuzzy(fz => fz.Field(f => f.Name).Value(val.Replace("+", "plus")))).Aggregate((a, b) => a || b); //var query = mediasRef.Select(x => x.DisplayNames.FirstOrDefault()) // .Select(val => qc.Fuzzy(fz => fz.Field(f => f.Name).Value(val.Replace("+", "plus")))).FirstOrDefault(); //var searchPiconDisc = new SearchDescriptor<Picon>() // .Size(1) // .Query(x => query); var tasks = mediasRef.Select(async m => { var findLogoResponse = await _elasticConnectionClient.Client.Value.SearchAsync <Picon>(x => x.Query(q => q.Match(fz => fz.Field(f => f.Name) .Query(m.DisplayNames.FirstOrDefault()))).Size(1), cancellationToken); if (findLogoResponse.Documents.Any()) { m.Tvg.Logo = findLogoResponse.Documents.First().RawUrl; } }); await Task.WhenAll(tasks); var descriptor = new BulkDescriptor(); descriptor.IndexMany(mediasRef); return(await _elasticConnectionClient.Client.Value.BulkAsync(descriptor, cancellationToken)); }
/// <summary> /// Force update country field /// </summary> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task <IBulkResponse> SyncCountrySitePackAsync(CancellationToken cancellationToken = default) { _logger.LogInformation($"Lister les SitePackChannels"); var tvgSites = await _elasticConnectionClient.Client.Value.SearchAsync <SitePackChannel>(s => s .Index(_elasticConnectionClient.ElasticConfig.SitePackIndex) .Size(_elasticConnectionClient.ElasticConfig.MaxResultWindow) .From(0) , cancellationToken); var descriptor = new BulkDescriptor(); descriptor.Pipeline(ElasticConnectionClient.SITE_PACK_PIPELINE); descriptor.IndexMany(tvgSites.Documents); descriptor.Refresh(Elasticsearch.Net.Refresh.True); return(await _elasticConnectionClient.Client.Value.BulkAsync(descriptor, cancellationToken)); }
public virtual async Task <IndexingResult> IndexAsync(string documentType, IList <IndexDocument> documents) { var indexName = GetIndexName(documentType); var providerFields = await GetMappingAsync(indexName, documentType); var oldFieldsCount = providerFields.Count(); var providerDocuments = documents.Select(document => ConvertToProviderDocument(document, providerFields, documentType)).ToList(); var updateMapping = providerFields.Count() != oldFieldsCount; var indexExits = await IndexExistsAsync(indexName); if (!indexExits) { await CreateIndexAsync(indexName, documentType); } if (!indexExits || updateMapping) { await UpdateMappingAsync(indexName, documentType, providerFields); } var bulkDefinition = new BulkDescriptor(); bulkDefinition.IndexMany(providerDocuments).Index(indexName).Type(documentType); var bulkResponse = await Client.BulkAsync(bulkDefinition); await Client.RefreshAsync(indexName); var result = new IndexingResult { Items = bulkResponse.Items.Select(i => new IndexingResultItem { Id = i.Id, Succeeded = i.IsValid, ErrorMessage = i.Error?.Reason, }).ToArray(), }; return(result); }
/// <summary> /// 添加一个文档集合到索引中(此方法查询数据会有延时) /// </summary> /// <typeparam name="TEntity"></typeparam> /// <param name="entities"></param> /// <param name="indexName"></param> /// <returns></returns> public virtual async Task <bool> BulkAsync <TEntity>(IEnumerable <TEntity> entities, string indexName = null) where TEntity : class { BulkDescriptor bulkDescriptor = new BulkDescriptor(); if (!string.IsNullOrWhiteSpace(indexName)) { bulkDescriptor.Index(indexName); } bulkDescriptor.Refresh(Elasticsearch.Net.Refresh.True); var response = await Context.BulkAsync(bulkDescriptor.IndexMany(entities)); if (!response.IsValid) { Logger.LogError($"[Success:{response.ApiCall.Success}]\t{response.ApiCall.Uri}"); Logger.LogError(response.ApiCall.DebugInformation); Logger.LogError(response.ApiCall.OriginalException?.Message); } return(response.ApiCall.Success); }
/// <summary> /// 批量索引 /// </summary> /// <param name="entities">实体集合</param> /// <param name="routing">路由键</param> /// <returns></returns> public async Task <HttpResponseResultModel <bool> > IndexBatchAsync <T>(InsertUpdateModel <IList <T> > insertUpdateModel) where T : class, new() { HttpResponseResultModel <bool> httpResponseResultModel = new HttpResponseResultModel <bool>(); string indexName = insertUpdateModel.IndexName?.ToLower(); if (string.IsNullOrEmpty(indexName)) { indexName = PocoIndexName; } BulkDescriptor bulkDescriptor = new BulkDescriptor(); bulkDescriptor.IndexMany(insertUpdateModel.Entity); bulkDescriptor.Index(indexName); if (!string.IsNullOrEmpty(insertUpdateModel.Routing)) { bulkDescriptor.Routing(new Routing(insertUpdateModel.Routing)); } var result = await client.BulkAsync(bulkDescriptor).ConfigureAwait(false); GetDebugInfo(result); //if (result.Errors || !result.ItemsWithErrors.IsNullOrEmpty()) //{ // Task.Run(() => // { // var json = JsonHelper.SerializeObject(insertUpdateModel.Entity); // WriteLog.WriteLogsAsync(json, "batchError"); // }); //} var isSuccess = result.ItemsWithErrors.IsListNullOrEmpty(); string errorMessage = ""; if (!isSuccess) { var errorIdList = result.ItemsWithErrors.Select(t => t.Id); errorMessage = string.Join(",", errorIdList); } httpResponseResultModel.IsSuccess = isSuccess; httpResponseResultModel.ErrorMessage = errorMessage; return(httpResponseResultModel); }
/// <summary> /// Synk picons /// </summary> /// <param name="picons"></param> /// <param name="reset">Delete the index and recreate it</param> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task <IBulkResponse> SynkAsync(IEnumerable <Picon> picons, bool reset = false, CancellationToken cancellationToken = default) { if (reset) { var res = await _elasticConnectionClient.Client.Value.DeleteByQueryAsync <Picon>(r => r.Query(rq => rq.Wildcard(f => f.Name, "*")), cancellationToken); if (!res.IsValid) { if (res.ServerError.Status != 404) { throw new ApplicationException(res.ServerError.Error.Reason, res.OriginalException); } } } var descriptor = new BulkDescriptor(); descriptor.Pipeline(ElasticConnectionClient.PICONS_RETREIVE_CHANNEL_NUMBER_PIPELINE); descriptor.IndexMany(picons); descriptor.Refresh(Elasticsearch.Net.Refresh.True); _logger.LogInformation($"Sync picons count : {picons.Count()}"); return(await _elasticConnectionClient.Client.Value.BulkAsync(descriptor, cancellationToken)); }