public DeleteByQueryRequestTests()
{
QueryContainer query = new TermQuery()
{
Field = Property.Path<ElasticsearchProject>(p=>p.Name),
Value = "value"
} && new PrefixQuery()
{
Field = "prefix_field",
Value = "prefi",
Rewrite = RewriteMultiTerm.ConstantScoreBoolean
};
var request = new DeleteByQueryRequest()
{
AllowNoIndices = true,
ExpandWildcards = ExpandWildcards.Closed,
Query = query,
DefaultOperator = DefaultOperator.And
};
var response = this._client.DeleteByQuery(request);
this._status = response.ConnectionStatus;
}
public DeleteByQueryRequestTests()
{
QueryContainer query = new TermQuery()
{
Field = Property.Path <ElasticsearchProject>(p => p.Name),
Value = "value"
} && new PrefixQuery()
{
Field = "prefix_field",
Value = "prefi",
Rewrite = RewriteMultiTerm.ConstantScoreBoolean
};
var request = new DeleteByQueryRequest()
{
AllIndices = true,
AllowNoIndices = true,
ExpandWildcards = ExpandWildcards.Closed,
Query = query,
DefaultOperator = DefaultOperator.And
};
var response = this._client.DeleteByQuery(request);
this._status = response.ConnectionStatus;
}
public virtual async Task DeleteAllByProjectIdAsync(Guid projectId, CancellationToken cancellationToken = default)
{
ValidateElasticSearchEnabled();
var request = new DeleteByQueryRequest(_options.IndexName)
{
Query = new BoolQuery
{
Filter = new QueryContainer[]
{
new BoolQuery
{
Must = new QueryContainer[]
{
new TermQuery
{
Field = "projectId",
Value = NormalizeField(projectId)
}
}
}
}
},
};
HandleError(await _clientProvider.GetClient()
.DeleteByQueryAsync(request, cancellationToken));
}
/// <summary>
/// 按照指定条件删除
/// </summary>
/// <param name="option"></param>
/// <returns></returns>
public bool Delete(ESDeleteOption option)
{
var queryCondations = BuildQueryContainer(option.Where, option.Analyzer);
var shouldQuerys = queryCondations.Should;
var mustQuerys = queryCondations.Must;
var mustNotQuerys = queryCondations.MustNot;
if (mustQuerys.Count <= 0 && shouldQuerys.Count <= 0 && mustNotQuerys.Count <= 0)
{
return(false);
}
var request = new DeleteByQueryRequest <T>(option.IndexName, option.TypeName);
var query = new BoolQuery();
if (mustQuerys.Count > 0)
{
query.Must = mustQuerys;
}
if (shouldQuerys.Count > 0)
{
query.Should = shouldQuerys;
}
if (mustNotQuerys.Count > 0)
{
query.MustNot = mustNotQuerys;
}
request.Query = query;
var res = _es.DeleteByQuery(request);
return(res.Deleted > 0);
}
/// <summary>
/// Clear Index Logs with string
/// </summary>
public Task <DeleteByQueryResponse> ClearIndexData(string indexName)
{
DeleteByQueryRequest r = new DeleteByQueryRequest(indexName);
r.QueryOnQueryString = "*";
return(elasticClient.DeleteByQueryAsync(r));
}
/// <summary>
/// Deletes all documents in the index
/// </summary>
public async Task ClearIndex()
{
var req = new DeleteByQueryRequest(_indexName)
{
Query = EverythingQuery()
};
await _esClient.DeleteByQueryAsync(req);
}
/// <summary>
/// 通过条件删除
/// </summary>
public static async Task <DeleteByQueryResponse> DeleteByQueryAsync_ <T>(this IElasticClient client, string indexName, QueryContainer where) where T : class, IESIndex
{
var query = new DeleteByQueryRequest <T>(indexName)
{
Query = where
};
var response = await client.DeleteByQueryAsync(query);
return(response);
}
/// <summary>
/// 通过条件删除
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="indexName"></param>
/// <param name="where"></param>
/// <returns></returns>
public static async Task DeleteByQueryAsync_ <T>(this IElasticClient client, string indexName, QueryContainer where) where T : class, IElasticSearchIndex
{
var query = new DeleteByQueryRequest <T>(indexName)
{
Query = where
};
var response = await client.DeleteByQueryAsync(query);
response.ThrowIfException();
}
/// <summary>
/// 删除指定数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="deleteRequest"></param>
/// <returns></returns>
public IDeleteByQueryResponse DeleteByQuery <T>(DeleteByQueryRequest <T> deleteRequest) where T : class
{
var response = ElasticClient.DeleteByQuery(deleteRequest);
if (!response.IsValid)
{
throw new ElasticsearchException("删除失败:" +
response.OriginalException.Message);
}
return(response);
}
public virtual async Task DeleteAllAsync(CancellationToken cancellationToken = default)
{
ValidateElasticSearchEnabled();
var request = new DeleteByQueryRequest(_options.IndexName)
{
Query = new MatchAllQuery()
};
HandleError(await _clientProvider.GetClient()
.DeleteByQueryAsync(request, cancellationToken));
}
/// <summary>
/// 删除指定数据
/// </summary>
public void DeleteByQuery(string key)
{
var request = new DeleteByQueryRequest <Content>("content_test");
var predicateList = new List <IPredicate>
{
Predicates.Field <Content>(x => x.Key, ExpressOperator.Eq, key)
};
var predicate = Predicates.Group(GroupOperator.And, predicateList.ToArray());
request.InitDelteQueryContainer(predicate);
_deleteProvider.DeleteByQuery(request);
}
public async Task <bool> Remove(Guid entryId)
{
var request = new DeleteByQueryRequest <T>(_Index)
{
Query = new TermQuery()
{
Field = "_id", Value = entryId.ToString(), IsStrict = true
}
};
var response = await _Client.DeleteByQueryAsync(request);
return(response.Took > 0);
}
/// <summary>
/// 删除此日期之前的数据
/// 由定时任务调用，不用异步
/// </summary>
/// <param name="time"></param>
/// <returns></returns>
public static void DeleteDataBefore(DateTime time)
{
var req = new DeleteByQueryRequest <ESLogLine>(IndexName);
req.Query = new QueryContainer();
req.Query &= new DateRangeQuery()
{
Field = nameof(temp.UpdateTime), LessThan = time
};
//delete by query
var client = new ElasticClient(ElasticsearchClientManager.Instance.DefaultClient);
var response = client.DeleteByQuery(req);
response.ThrowIfException();
}
public async Task <DeleteByQueryResponse> DeleteByQuery <T>(Expression <Func <T, bool> > expression, string index = "")
where T : class, new()
{
var indexName = index.GetIndex <T>();
var request = new DeleteByQueryRequest <T>(indexName);
var build = new QueryBuilder <T>();
request.Query = build.GetQueryContainer(expression);
var response = await _elasticClient.DeleteByQueryAsync(request);
if (!response.IsValid)
{
throw new Exception("删除失败:" + response.OriginalException.Message);
}
return(response);
}
public void BulkDelete(IEnumerable <object> keys)
{
if (keys == null || !keys.Any())
{
return;
}
var skeys = keys.Cast <string>();
var request = new DeleteByQueryRequest <TEntity>()
{
Query = new QueryContainer(new IdsQuery()
{
Values = skeys
})
};
var response = _client.DeleteByQuery(request);
ValidateElasticSearchResponse(response);
}
/// <summary>
/// 删除
/// </summary>
/// <param name="type"></param>
/// <param name="wherestr"></param>
public long DeleteDataByWhere(string type, string wherestr)
{
IDeleteByQueryRequest request = new DeleteByQueryRequest(_indexName, type);
request.Query = new ScriptQuery
{
Inline = wherestr
};
var result = Client.DeleteByQuery(request);
if (result.ServerError != null)
{
_log.Error("删除失败:" + result.ServerError.Error.Reason);
return(0);
}
if (result.Indices != null && result.Indices.ContainsKey("_all"))
{
return(result.Indices["_all"].Deleted);
}
return(0);
}
public async Task <IActionResult> Delete(string id, [FromServices] IElasticClient elasticClient)
{
var result = await elasticClient.GetAsync <Log>(id);
if (result.Source == null)
{
return(NotFound());
}
var request = new DeleteByQueryRequest <Log>
{
Query = new QueryContainer(new TermQuery
{
Field = "id",
Value = id
})
};
await elasticClient.DeleteByQueryAsync(request);
return(Ok());
}
/// <summary>
/// 删除（需要自己构建request对象）
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public bool Delete(DeleteByQueryRequest <T> request)
{
var res = _es.DeleteByQuery(request);
return(res.Deleted > 0);
}
private static void Index(DocumentModel document, String operation)
{
var uriString = ConfigurationManager.AppSettings["SEARCHBOX_URL"];
var searchBoxUri = new Uri(uriString);
var settings = new ConnectionSettings(searchBoxUri);
settings.SetDefaultIndex(indexName);
var client = new ElasticClient(settings);
if (!client.IndexExists(indexName).Exists)
{
// Create a new "sample" index with default settings
ICreateIndexRequest iCreateIndexReq = new CreateIndexRequest(indexName);
iCreateIndexReq.IndexSettings = new IndexSettings();
iCreateIndexReq.IndexSettings.NumberOfReplicas = 10;
//iCreateIndexReq.IndexSettings.Mappings = new List<RootObjectMapping>();
//RootObjectMapping rootObjectMapping = new RootObjectMapping();
//rootObjectMapping.AllFieldMapping()
//iCreateIndexReq.IndexSettings.Mappings.
//client.CreateIndex(iCreateIndexReq);
//client.CreateIndex(indexName,s=>s.)
var resCreate = client.CreateIndex(indexName, s => s.AddMapping<DocumentModel>(f => f.MapFromAttributes()).NumberOfReplicas(1).NumberOfShards(10));
//client.CreateIndex(indexName, new IndexSettings());
//client.create
}
if (operation.Equals("delete"))
{
//client.DeleteById(indexName, "documents", document.DocumentId);
IDeleteByQueryRequest iDeleteByQueryRequest = new DeleteByQueryRequest();
//IDeleteIndexRequest delReq = new DeleteIndexRequest(indexName);
//client.DeleteIndex()
//client.DeleteByQuery(new DeleteByQueryRequest())
client.Delete<DocumentModel>(f => f.Id(document.DocumentId).Index(indexName).Refresh());
//var response = this.Client.Delete<ElasticsearchProject>(f=>f.Id(newDocument.Id).Index(newIndex).Refresh());
}
else
{
//IIndexRequest<DocumentModel> indexRequest = IndexRequest<DocumentModel>();
//client.Index(i)
//client.Index(document, indexName, "documents", document.DocumentId);
//IndexDescriptor indexDesc = IndexDescriptor;
//IndexRequestParameters indexParameter = new IndexRequestParameters();
// indexParameter.Replication(1);
client.Index(document, i => i.Id(document.DocumentId).Index(indexName));
//client.Index();
//client.Index()
}
}
