public DeleteByQueryParam(ISolrQuery q)
{
query = q;
}
public void ByQuery(ISolrQuery q)
{
var cmd = new DeleteCommand(new DeleteByQueryParam(q));
cmd.Execute(connection);
}
/// <summary>
/// Creates a Solr query
/// </summary>
/// <param name="query">Solr query</param>
/// <returns>query object</returns>
public INHSolrQuery CreateSolrQuery(ISolrQuery query)
{
var serializer = (ISolrQuerySerializer) provider.GetService(typeof (ISolrQuerySerializer));
return CreateSolrQuery(serializer.Serialize(query));
}
public Task <SolrQueryResults <T> > QueryAsync(ISolrQuery query, QueryOptions options) => PerformBasicOperation(operations => operations.QueryAsync(query, options));
public ResponseHeader Delete(IEnumerable <string> ids, ISolrQuery q, DeleteParameters parameters)
{
return(PerformBasicOperation(operations => operations.Delete(ids, q, parameters)));
}
/// <summary>
/// Negates a query
/// </summary>
/// <param name="q"></param>
public SolrNotQuery(ISolrQuery q)
{
query = q;
}
public SolrFacetQuery(ISolrQuery q)
{
query = q;
}
public ResponseHeader Delete(ISolrQuery q, DeleteParameters parameters)
{
throw new NotImplementedException();
}
public Task <ResponseHeader> DeleteAsync(ISolrQuery q, DeleteParameters parameters)
{
throw new NotImplementedException();
}
/// <summary>
/// Requires a query
/// </summary>
/// <param name="q"></param>
public SolrRequiredQuery(ISolrQuery q)
{
query = q;
}
/// <summary>
/// Returns the Solr Uri that would be executed
/// </summary>
/// <param name="query"></param>
/// <param name="options"></param>
/// <returns></returns>
public Uri GetQuery(ISolrQuery query, QueryOptions options)
{
var param = GetAllParameters(query, options);
return(connection.GetQuery(Handler, param));
}
/// <summary>
/// Executes a query
/// </summary>
/// <param name="q"></param>
/// <returns></returns>
public SolrQueryResults <T> Query(ISolrQuery q)
{
return(Query(q, new QueryOptions()));
}
/// <summary>
/// Executes a query
/// </summary>
/// <param name="query"></param>
/// <param name="options"></param>
/// <returns></returns>
public SolrQueryResults <T> Query(ISolrQuery query, QueryOptions options)
{
return(basicServer.Query(query, options));
}
ResponseHeader ISolrOperations <T> .Delete(IEnumerable <string> ids, ISolrQuery q)
{
return(basicServer.Delete(ids, q));
}
public SolrFacetQuery(ISolrQuery q)
{
query = q.Query;
}
public Task <ResponseHeader> DeleteAsync(IEnumerable <string> ids, ISolrQuery q, DeleteParameters parameters)
{
throw new NotImplementedException();
}
public DeleteByIdAndOrQueryParam(IEnumerable<string> ids, ISolrQuery query, ISolrQuerySerializer querySerializer)
{
this.ids = ids;
this.query = query;
this.querySerializer = querySerializer;
}
public Task <SolrQueryResults <T> > QueryAsync(ISolrQuery query, QueryOptions options)
{
throw new NotImplementedException();
}
ResponseHeader ISolrOperations <T> .Delete(ISolrQuery q)
{
return(basicServer.Delete(null, q));
}
/// <summary>
/// Applies a boost to a query or query fragment
/// </summary>
/// <param name="query">Query to boost</param>
/// <param name="factor">Boost factor</param>
public SolrQueryBoost(ISolrQuery query, double factor)
{
this.query = query;
this.factor = factor;
}
public Task <ResponseHeader> DeleteAsync(IEnumerable <string> ids, ISolrQuery q, DeleteParameters parameters) => PerformBasicOperation(operations => operations.DeleteAsync(ids, q, parameters));
public SolrQueryResults <T> Query(ISolrQuery q, QueryOptions options)
{
return(query.Invoke(q, options));
}
public SolrQueryResults <T> Query(ISolrQuery query, QueryOptions options)
{
return(PerformBasicOperation(operations => operations.Query(query, options)));
}
public DSLQueryBy(string fieldName, ISolrConnection connection, ISolrQuery query)
{
this.fieldName = fieldName;
this.connection = connection;
this.query = query;
}
/// <summary>
/// Executes a query
/// </summary>
/// <typeparam name="T">Document type</typeparam>
/// <param name="q">Query</param>
/// <returns>Query results</returns>
public static SolrQueryResults <T> Query <T>(ISolrQuery q)
{
var queryExecuter = NewQueryExecuter <T>();
return(queryExecuter.Execute(q, null));
}
/// <summary>
/// Gets Solr parameters for all defined query options
/// </summary>
/// <param name="Query"></param>
/// <param name="options"></param>
/// <returns></returns>
public IEnumerable <KeyValuePair <string, string> > GetAllParameters(ISolrQuery Query, QueryOptions options)
{
yield return(KV.Create("q", querySerializer.Serialize(Query)));
if (options == null)
{
yield break;
}
foreach (var p in GetCommonParameters(options))
{
yield return(p);
}
if (options.OrderBy != null && options.OrderBy.Count > 0)
{
yield return(KV.Create("sort", string.Join(",", options.OrderBy.Select(x => x.ToString()).ToArray())));
}
foreach (var p in GetHighlightingParameters(options))
{
yield return(p);
}
foreach (var p in GetSpellCheckingParameters(options))
{
yield return(p);
}
foreach (var p in GetTermsParameters(options))
{
yield return(p);
}
if (options.MoreLikeThis != null)
{
foreach (var p in GetMoreLikeThisParameters(options.MoreLikeThis))
{
yield return(p);
}
}
foreach (var p in GetStatsQueryOptions(options))
{
yield return(p);
}
foreach (var p in GetCollapseQueryOptions(options))
{
yield return(p);
}
foreach (var p in GetTermVectorQueryOptions(options))
{
yield return(p);
}
foreach (var p in GetGroupingQueryOptions(options))
{
yield return(p);
}
foreach (var p in GetCollapseExpandOptions(options.CollapseExpand, querySerializer.Serialize))
{
yield return(p);
}
foreach (var p in GetClusteringParameters(options))
{
yield return(p);
}
}
public Uri GetQuery(ISolrConnection connection, ISolrQuery query, Commands.Parameters.QueryOptions options)
{
var executor = new SolrQueryExecuter<object>(null, connection, querySerializer, facetQuerySerializer, null);
var param = executor.GetAllParameters(query, options);
return connection.GetQuery(SolrQueryExecuter<object>.DefaultHandler, param);
}
public ResponseHeader Delete(ISolrQuery q)
{
throw new NotImplementedException();
}
/// <summary>
/// Requires a query
/// </summary>
/// <param name="q"></param>
public SolrRequiredQuery(ISolrQuery q) {
query = q;
}
public ResponseHeader Delete(IEnumerable <string> ids, ISolrQuery q)
{
throw new NotImplementedException();
}
/// <summary>
/// Applies a boost to a query or query fragment
/// </summary>
/// <param name="query">Query to boost</param>
/// <param name="factor">Boost factor</param>
public SolrQueryBoost(ISolrQuery query, double factor) {
this.query = query;
this.factor = factor;
}
public Uri GetQuery(ISolrQuery query, QueryOptions options)
{
throw new NotImplementedException();
}
public void ByQuery(ISolrQuery q)
{
var cmd = new DeleteCommand(new DeleteByIdAndOrQueryParam(null, q, GetQuerySerializer()));
cmd.Execute(connection);
}
public SolrQueryResults <T> Query(ISolrQuery q)
{
throw new NotImplementedException();
}
public INHSolrQuery CreateSolrQuery(ISolrQuery query)
{
return CreateSolrQuery(query.Query);
}
public SolrQueryResults <T> Query(ISolrQuery query, ICollection <SortOrder> orders)
{
throw new NotImplementedException();
}
public DeleteByIdAndOrQueryParam(IEnumerable<string> ids, ISolrQuery q)
{
this.ids = ids;
query = q;
}
/// <summary>
/// Executes a query
/// </summary>
/// <param name="query"></param>
/// <param name="orders"></param>
/// <returns></returns>
public SolrQueryResults <T> Query(ISolrQuery query, ICollection <SortOrder> orders)
{
return(Query(query, new QueryOptions {
OrderBy = orders
}));
}
