public static IEnumerable <KeyValuePair <string, string> > GetCollapseOptions(CollapseExpandParameters options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
yield return(KV.Create("field", options.Field));
if (options.NullPolicy != null)
{
yield return(KV.Create("nullPolicy", options.NullPolicy.Policy));
}
if (options.MinOrMaxField != null)
{
yield return(options.MinOrMaxField.Switch <KeyValuePair <string, string> >(
min: x => KV.Create("min", x.Field),
max: x => KV.Create("max", x.Field)));
}
}
public static IEnumerable <object[]> getTestParams()
{
yield return(new object[] { KV.Create(new Dictionary <string, string> {
{ "type", "spatial" },
}, "{!type=spatial}") });
yield return(new object[] { KV.Create(new Dictionary <string, string> {
{ "type", "spatial" },
{ "a", "b" },
}, "{!type=spatial a=b}") });
yield return(new object[] { KV.Create(new Dictionary <string, string> {
{ "type", "spatial" },
{ "a", "1 2 3" },
}, "{!type=spatial a='1 2 3'}") });
yield return(new object[] { KV.Create(new Dictionary <string, string> {
{ "type", "spatial" },
{ "a", "1 2 '3" },
}, "{!type=spatial a='1 2 \\'3'}") });
}
public void MoreLikeThis()
{
var mocks = new MockRepository();
var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >();
var conn = mocks.DynamicMock <ISolrConnection>();
var querySerializer = new SolrQuerySerializerStub("apache");
var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, null, null);
var p = queryExecuter.GetAllParameters(new SolrQuery("apache"), new QueryOptions {
MoreLikeThis = new MoreLikeThisParameters(new[] { "manu", "cat" })
{
MinDocFreq = 1,
MinTermFreq = 1,
},
}).ToList();
Assert.Contains(p, KV.Create("mlt", "true"));
Assert.Contains(p, KV.Create("mlt.mindf", "1"));
Assert.Contains(p, KV.Create("mlt.fl", "manu,cat"));
Assert.Contains(p, KV.Create("mlt.mintf", "1"));
Assert.Contains(p, KV.Create("q", "apache"));
}
public string Execute(ISolrConnection connection)
{
var xml = new XmlDocument();
var deleteNode = xml.CreateElement("delete");
var param = new[] {
KV.Create(FromPending, "fromPending"),
KV.Create(FromCommitted, "fromCommitted")
};
foreach (var p in param)
{
if (p.Key.HasValue)
{
var att = xml.CreateAttribute(p.Value);
att.InnerText = p.Key.Value.ToString().ToLower();
deleteNode.Attributes.Append(att);
}
}
deleteNode.InnerXml = string.Join("", deleteParam.ToXmlNode().Select(n => n.OuterXml).ToArray());
return(connection.Post("/update", deleteNode.OuterXml));
}
public void StatsOptions()
{
var queryExecuter = new SolrQueryExecuter <TestDocument>(null, null, null, null, null);
var statsOptions = queryExecuter.GetStatsQueryOptions(new QueryOptions {
Stats = new StatsParameters()
.AddField("popularity")
.AddFieldWithFacet("price", "inStock")
.AddFieldWithFacets("afield", "facet1", "facet2")
.AddFacet("globalfacet")
}).ToList();
Assert.AreEqual(8, statsOptions.Count);
Assert.Contains(statsOptions, KV.Create("stats", "true"));
Assert.Contains(statsOptions, KV.Create("stats.field", "popularity"));
Assert.Contains(statsOptions, KV.Create("stats.field", "price"));
Assert.Contains(statsOptions, KV.Create("f.price.stats.facet", "inStock"));
Assert.Contains(statsOptions, KV.Create("stats.field", "afield"));
Assert.Contains(statsOptions, KV.Create("f.afield.stats.facet", "facet1"));
Assert.Contains(statsOptions, KV.Create("f.afield.stats.facet", "facet2"));
Assert.Contains(statsOptions, KV.Create("stats.facet", "globalfacet"));
}
public void TermsMultipleFields()
{
var queryExecuter = new SolrQueryExecuter <TestDocument>(null, null, null, null, null);
var p = queryExecuter.GetTermsParameters(new QueryOptions {
Terms = new TermsParameters(new List <string> {
"text", "text2", "text3"
})
{
Limit = 10,
Lower = "lower",
LowerInclude = true,
MaxCount = 10,
MinCount = 0,
Prefix = "pre",
Raw = true,
Regex = "regex",
RegexFlag = new[] { RegexFlag.CanonEq, RegexFlag.CaseInsensitive },
Sort = TermsSort.Count,
Upper = "upper",
UpperInclude = true
},
}).ToList();
Assert.Contains(p, KV.Create("terms", "true"));
Assert.Contains(p, KV.Create("terms.fl", "text"));
Assert.Contains(p, KV.Create("terms.fl", "text2"));
Assert.Contains(p, KV.Create("terms.fl", "text3"));
Assert.Contains(p, KV.Create("terms.lower", "lower"));
Assert.Contains(p, KV.Create("terms.lower.incl", "true"));
Assert.Contains(p, KV.Create("terms.maxcount", "10"));
Assert.Contains(p, KV.Create("terms.mincount", "0"));
Assert.Contains(p, KV.Create("terms.prefix", "pre"));
Assert.Contains(p, KV.Create("terms.raw", "true"));
Assert.Contains(p, KV.Create("terms.regex", "regex"));
Assert.Contains(p, KV.Create("terms.regex.flag", RegexFlag.CanonEq.ToString()));
Assert.Contains(p, KV.Create("terms.regex.flag", RegexFlag.CaseInsensitive.ToString()));
Assert.Contains(p, KV.Create("terms.sort", "count"));
Assert.Contains(p, KV.Create("terms.upper", "upper"));
Assert.Contains(p, KV.Create("terms.upper.incl", "true"));
}
/// <summary>
/// Gets solr parameters for defined spell-checking
/// </summary>
public IEnumerable <KeyValuePair <string, string> > GetSpellCheckingParameters(QueryOptions Options)
{
var spellCheck = Options.SpellCheck;
if (spellCheck == null)
{
yield break;
}
yield return(KV.Create("spellcheck", "true"));
if (!string.IsNullOrEmpty(spellCheck.Query))
{
yield return(KV.Create("spellcheck.q", spellCheck.Query));
}
if (spellCheck.Build.HasValue)
{
yield return(KV.Create("spellcheck.build", spellCheck.Build.ToString().ToLowerInvariant()));
}
if (spellCheck.Collate.HasValue)
{
yield return(KV.Create("spellcheck.collate", spellCheck.Collate.ToString().ToLowerInvariant()));
}
if (spellCheck.Count.HasValue)
{
yield return(KV.Create("spellcheck.count", spellCheck.Count.ToString()));
}
if (!string.IsNullOrEmpty(spellCheck.Dictionary))
{
yield return(KV.Create("spellcheck.dictionary", spellCheck.Dictionary));
}
if (spellCheck.OnlyMorePopular.HasValue)
{
yield return(KV.Create("spellcheck.onlyMorePopular", spellCheck.OnlyMorePopular.ToString().ToLowerInvariant()));
}
if (spellCheck.Reload.HasValue)
{
yield return(KV.Create("spellcheck.reload", spellCheck.Reload.ToString().ToLowerInvariant()));
}
}
public void TermsSingleField()
{
var mocks = new MockRepository();
var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >();
var conn = mocks.DynamicMock <ISolrConnection>();
var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, null, null, null);
var p = queryExecuter.GetTermsParameters(new QueryOptions {
Terms = new TermsParameters("text")
{
Limit = 10,
Lower = "lower",
LowerInclude = true,
MaxCount = 10,
MinCount = 0,
Prefix = "pre",
Raw = true,
Regex = "regex",
RegexFlag = new[] { RegexFlag.CanonEq, RegexFlag.CaseInsensitive },
Sort = TermsSort.Count,
Upper = "upper",
UpperInclude = true
},
}).ToList();
Assert.Contains(p, KV.Create("terms", "true"));
Assert.Contains(p, KV.Create("terms.fl", "text"));
Assert.Contains(p, KV.Create("terms.lower", "lower"));
Assert.Contains(p, KV.Create("terms.lower.incl", "true"));
Assert.Contains(p, KV.Create("terms.maxcount", "10"));
Assert.Contains(p, KV.Create("terms.mincount", "0"));
Assert.Contains(p, KV.Create("terms.prefix", "pre"));
Assert.Contains(p, KV.Create("terms.raw", "true"));
Assert.Contains(p, KV.Create("terms.regex", "regex"));
Assert.Contains(p, KV.Create("terms.regex.flag", RegexFlag.CanonEq.ToString()));
Assert.Contains(p, KV.Create("terms.regex.flag", RegexFlag.CaseInsensitive.ToString()));
Assert.Contains(p, KV.Create("terms.sort", "count"));
Assert.Contains(p, KV.Create("terms.upper", "upper"));
Assert.Contains(p, KV.Create("terms.upper.incl", "true"));
}
/// <summary>
/// Gets the Query
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
private string GetQuery(IEnumerable <KeyValuePair <string, string> > parameters)
{
var param = new List <KeyValuePair <string, string> >();
if (parameters != null)
{
param.AddRange(parameters);
}
param.Add(KV.Create("version", version));
if (param.All(x => x.Key != "wt"))
{
// only set wt=xml if wt wasn't already set by the caller
param.Add(KV.Create("wt", "xml"));
}
return(string.Join("&", param
.Select(kv => KV.Create(WebUtility.UrlEncode(kv.Key), WebUtility.UrlEncode(kv.Value)))
.Select(kv => string.Format("{0}={1}", kv.Key, kv.Value))
.ToArray()));
}
/// <summary>
/// Serializes common query parameters
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public IEnumerable <KeyValuePair <string, string> > GetCommonParameters(CommonQueryOptions options)
{
if (options == null)
{
yield break;
}
if (options.Start.HasValue)
{
yield return(KV.Create("start", options.Start.ToString()));
}
var rows = options.Rows.HasValue ? options.Rows.Value : DefaultRows;
yield return(KV.Create("rows", rows.ToString()));
if (options.Fields != null && options.Fields.Count > 0)
{
yield return(KV.Create("fl", string.Join(",", options.Fields.ToArray())));
}
foreach (var p in GetFilterQueries(options.FilterQueries))
{
yield return(p);
}
foreach (var p in GetFacetFieldOptions(options.Facet))
{
yield return(p);
}
if (options.ExtraParams != null)
{
foreach (var p in options.ExtraParams)
{
yield return(p);
}
}
}
public void Intercept(IInvocation invocation)
{
if (currentElement.Value.Value != null)
{
currentElement.Value.Value.Stop();
}
var sw = new Stopwatch();
var newChild = currentElement.AddChild(KV.Create(invocation.MethodInvocationTarget, sw));
currentElement = newChild;
sw.Start();
try {
invocation.Proceed();
} finally {
sw.Stop();
currentElement = currentElement.Parent;
if (currentElement.Value.Value != null)
{
currentElement.Value.Value.Start();
}
}
}
public override IEnumerable <KeyValuePair <string, string> > Serialize(SolrFacetFieldQuery q)
{
yield return(KV.Create("facet.field", q.Field));
var fieldWithoutLocalParams = localParamsRx.Replace(q.Field, "");
if (q.Prefix != null)
{
yield return(KV.Create(string.Format("f.{0}.facet.prefix", fieldWithoutLocalParams), q.Prefix));
}
if (q.Sort.HasValue)
{
yield return(KV.Create(string.Format("f.{0}.facet.sort", fieldWithoutLocalParams), q.Sort.ToString().ToLowerInvariant()));
}
if (q.Limit.HasValue)
{
yield return(KV.Create(string.Format("f.{0}.facet.limit", fieldWithoutLocalParams), q.Limit.ToString()));
}
if (q.Offset.HasValue)
{
yield return(KV.Create(string.Format("f.{0}.facet.offset", fieldWithoutLocalParams), q.Offset.ToString()));
}
if (q.MinCount.HasValue)
{
yield return(KV.Create(string.Format("f.{0}.facet.mincount", fieldWithoutLocalParams), q.MinCount.ToString()));
}
if (q.Missing.HasValue)
{
yield return(KV.Create(string.Format("f.{0}.facet.missing", fieldWithoutLocalParams), q.Missing.ToString().ToLowerInvariant()));
}
if (q.EnumCacheMinDf.HasValue)
{
yield return(KV.Create(string.Format("f.{0}.facet.enum.cache.minDf", fieldWithoutLocalParams), q.EnumCacheMinDf.ToString()));
}
if (q.Threads.HasValue)
{
yield return(KV.Create(string.Format("f.{0}.facet.threads", fieldWithoutLocalParams), q.Threads.ToString()));
}
}
/// <summary>
/// Gets the Solr parameters for collapse queries
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public IEnumerable <KeyValuePair <string, string> > GetCollapseQueryOptions(QueryOptions options)
{
if (options.Collapse == null || string.IsNullOrEmpty(options.Collapse.Field))
{
yield break;
}
yield return(KV.Create("collapse.field", options.Collapse.Field));
if (options.Collapse.Threshold.HasValue)
{
yield return(KV.Create("collapse.threshold", options.Collapse.Threshold.ToString()));
}
yield return(KV.Create("collapse.type", options.Collapse.Type.ToString()));
yield return(KV.Create("collapse.facet", options.Collapse.FacetMode.ToString().ToLowerInvariant()));
if (options.Collapse.MaxDocs.HasValue)
{
yield return(KV.Create("collapse.maxdocs", options.Collapse.MaxDocs.ToString()));
}
}
/// <summary>
/// Serializes More Like This handler specific parameters
/// </summary>
/// <param name="mlt"></param>
/// <returns></returns>
public IEnumerable <KeyValuePair <string, string> > GetMoreLikeThisHandlerParameters(MoreLikeThisHandlerParameters mlt)
{
if (mlt.MatchInclude != null)
{
yield return(KV.Create("mlt.match.include", mlt.MatchInclude.Value.ToString().ToLowerInvariant()));
}
if (mlt.MatchOffset != null)
{
yield return(KV.Create("mlt.match.offset", mlt.MatchOffset.Value.ToString()));
}
if (mlt.ShowTerms != null)
{
yield return(KV.Create("mlt.interestingTerms", mlt.ShowTerms.ToString().ToLowerInvariant()));
}
foreach (var p in GetMoreLikeThisParameters(mlt))
{
yield return(p);
}
}
/// <summary>
/// Serializes all More Like This handler parameters
/// </summary>
/// <param name="query"></param>
/// <param name="options"></param>
/// <returns></returns>
public IEnumerable <KeyValuePair <string, string> > GetAllMoreLikeThisHandlerParameters(SolrMLTQuery query, MoreLikeThisHandlerQueryOptions options)
{
yield return
(query.Switch <KeyValuePair <string, string> >(
query: q => KV.Create("q", querySerializer.Serialize(q)),
streamBody: body => KV.Create("stream.body", body),
streamUrl: url => KV.Create("stream.url", url.ToString())));
if (options == null)
{
yield break;
}
foreach (var p in GetCommonParameters(options))
{
yield return(p);
}
foreach (var p in GetMoreLikeThisHandlerParameters(options.Parameters))
{
yield return(p);
}
}
/// <summary>
/// Gets the Solr parameters for collapse queries
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public static IEnumerable <KeyValuePair <string, string> > GetTermVectorQueryOptions(QueryOptions options)
{
if (options.TermVector == null || !options.TermVector.Fields.Any())
{
yield break;
}
yield return(KV.Create("tv", "true"));
if (options.TermVector.Fields != null)
{
var fields = string.Join(",", options.TermVector.Fields.ToArray());
if (!string.IsNullOrEmpty(fields))
{
yield return(KV.Create("tv.fl", fields));
}
}
foreach (var o in GetTermVectorParameterOptions(options.TermVector.Options).Distinct())
{
yield return(KV.Create(o, "true"));
}
}
public void FilterQuery()
{
var mocks = new MockRepository();
var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >();
var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var conn = new MockConnection(new[] {
KV.Create("q", "*:*"),
KV.Create("rows", "10"),
KV.Create("fq", "id:0"),
KV.Create("fq", "id:2"),
});
var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, null, null)
{
DefaultRows = 10,
};
queryExecuter.Execute(SolrQuery.All, new QueryOptions {
FilterQueries = new[] {
new SolrQuery("id:0"),
new SolrQuery("id:2"),
},
});
}
public void GetAllParameters_mlt_with_stream_url_query()
{
var mocks = new MockRepository();
var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >();
var conn = mocks.DynamicMock <ISolrConnection>();
var qe = new SolrQueryExecuter <TestDocument>(parser, conn, null, null, null);
var p = qe.GetAllMoreLikeThisHandlerParameters(
new SolrMoreLikeThisHandlerStreamUrlQuery("http://wiki.apache.org/solr/MoreLikeThisHandler"),
new MoreLikeThisHandlerQueryOptions(
new MoreLikeThisHandlerParameters(new[] { "one", "three" })
{
MatchInclude = false,
MatchOffset = 5,
ShowTerms = InterestingTerms.None,
})
{
Start = 0,
Rows = 5,
Fields = new[] { "one", "two", "three" },
}).ToList();
Assert.Contains(p, KV.Create("stream.url", "http://wiki.apache.org/solr/MoreLikeThisHandler"));
}
public void Extract()
{
var parameters = new ExtractParameters(null, "1", "test.doc");
var connection = new MSolrConnection();
connection.postStream += (url, contentType, content, param) => {
Assert.AreEqual("/update/extract", url);
Assert.AreEqual(parameters.Content, content);
var expectedParams = new[] {
KV.Create("literal.id", parameters.Id),
KV.Create("resource.name", parameters.ResourceName),
};
CollectionAssert.AreEquivalent(expectedParams, param);
return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.responseWithExtractContent.xml"));
};
var docSerializer = new SolrDocumentSerializer <TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
var extractResponseParser = new MSolrExtractResponseParser {
parse = _ => new ExtractResponse(null)
};
var ops = new SolrBasicServer <TestDocumentWithoutUniqueKey>(connection, null, docSerializer, null, null, null, null, extractResponseParser);
ops.Extract(parameters);
Assert.AreEqual(1, connection.postStream.Calls);
}
public void MultipleFacetFields()
{
var conn = new MockConnection(new[] {
KV.Create("q", ""),
KV.Create("rows", SolrQueryExecuter <TestDocument> .ConstDefaultRows.ToString()),
KV.Create("facet", "true"),
KV.Create("facet.field", "Id"),
KV.Create("facet.field", "OtherField"),
});
var mocks = new MockRepository();
var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >();
var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var facetQuerySerializer = new DefaultFacetQuerySerializer(serializer, new DefaultFieldSerializer());
var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, serializer, facetQuerySerializer, null);
queryExecuter.Execute(new SolrQuery(""), new QueryOptions {
Facet = new FacetParameters {
Queries = new ISolrFacetQuery[] {
new SolrFacetFieldQuery("Id"),
new SolrFacetFieldQuery("OtherField"),
}
}
});
}
public void SpellChecking()
{
var queryExecuter = new SolrQueryExecuter <TestDocument>(null, null, null, null, null);
var p = queryExecuter.GetSpellCheckingParameters(new QueryOptions {
SpellCheck = new SpellCheckingParameters {
Query = "hell",
Build = true,
Collate = true,
Count = 4,
Dictionary = "spanish",
OnlyMorePopular = true,
Reload = true,
},
}).ToList();
Assert.Contains(p, KV.Create("spellcheck", "true"));
Assert.Contains(p, KV.Create("spellcheck.q", "hell"));
Assert.Contains(p, KV.Create("spellcheck.build", "true"));
Assert.Contains(p, KV.Create("spellcheck.collate", "true"));
Assert.Contains(p, KV.Create("spellcheck.count", "4"));
Assert.Contains(p, KV.Create("spellcheck.dictionary", "spanish"));
Assert.Contains(p, KV.Create("spellcheck.onlyMorePopular", "true"));
Assert.Contains(p, KV.Create("spellcheck.reload", "true"));
}
public void StatsOptions()
{
var mocks = new MockRepository();
var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >();
var conn = mocks.DynamicMock <ISolrConnection>();
var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, null, null, null);
var statsOptions = queryExecuter.GetStatsQueryOptions(new QueryOptions {
Stats = new StatsParameters()
.AddField("popularity")
.AddFieldWithFacet("price", "inStock")
.AddFieldWithFacets("afield", "facet1", "facet2")
.AddFacet("globalfacet")
}).ToList();
Assert.AreEqual(8, statsOptions.Count);
Assert.Contains(statsOptions, KV.Create("stats", "true"));
Assert.Contains(statsOptions, KV.Create("stats.field", "popularity"));
Assert.Contains(statsOptions, KV.Create("stats.field", "price"));
Assert.Contains(statsOptions, KV.Create("f.price.stats.facet", "inStock"));
Assert.Contains(statsOptions, KV.Create("stats.field", "afield"));
Assert.Contains(statsOptions, KV.Create("f.afield.stats.facet", "facet1"));
Assert.Contains(statsOptions, KV.Create("f.afield.stats.facet", "facet2"));
Assert.Contains(statsOptions, KV.Create("stats.facet", "globalfacet"));
}
public override IEnumerable <KeyValuePair <string, string> > Serialize(SolrFacetDateQuery q)
{
var fieldWithoutLocalParams = localParamsRx.Replace(q.Field, "");
yield return(KV.Create("facet.date", q.Field));
yield return(KV.Create(string.Format("f.{0}.facet.date.start", fieldWithoutLocalParams), SerializeSingle(q.Start)));
yield return(KV.Create(string.Format("f.{0}.facet.date.end", fieldWithoutLocalParams), SerializeSingle(q.End)));
yield return(KV.Create(string.Format("f.{0}.facet.date.gap", fieldWithoutLocalParams), q.Gap));
if (q.HardEnd.HasValue)
{
yield return(KV.Create(string.Format("f.{0}.facet.date.hardend", fieldWithoutLocalParams), SerializeSingle(q.HardEnd.Value)));
}
if (q.Other != null && q.Other.Count > 0)
{
foreach (var o in q.Other)
{
yield return(KV.Create(string.Format("f.{0}.facet.date.other", fieldWithoutLocalParams), o.ToString()));
}
}
}
/// <summary>
/// Gets solr parameters for terms component
/// </summary>
/// <param name="Options"></param>
/// <returns></returns>
public static IEnumerable <KeyValuePair <string, string> > GetTermsParameters(QueryOptions Options)
{
var terms = Options.Terms;
if (terms == null)
{
yield break;
}
if (terms.Fields == null || !terms.Fields.Any())
{
throw new SolrNetException("Terms field can't be empty or null");
}
yield return(KV.Create("terms", "true"));
foreach (var field in terms.Fields)
{
yield return(KV.Create("terms.fl", field));
}
if (!string.IsNullOrEmpty(terms.Prefix))
{
yield return(KV.Create("terms.prefix", terms.Prefix));
}
if (terms.Sort != null)
{
yield return(KV.Create("terms.sort", terms.Sort.ToString()));
}
if (terms.Limit.HasValue)
{
yield return(KV.Create("terms.limit", terms.Limit.ToString()));
}
if (!string.IsNullOrEmpty(terms.Lower))
{
yield return(KV.Create("terms.lower", terms.Lower));
}
if (terms.LowerInclude.HasValue)
{
yield return(KV.Create("terms.lower.incl", terms.LowerInclude.ToString().ToLowerInvariant()));
}
if (!string.IsNullOrEmpty(terms.Upper))
{
yield return(KV.Create("terms.upper", terms.Upper));
}
if (terms.UpperInclude.HasValue)
{
yield return(KV.Create("terms.upper.incl", terms.UpperInclude.ToString().ToLowerInvariant()));
}
if (terms.MaxCount.HasValue)
{
yield return(KV.Create("terms.maxcount", terms.MaxCount.ToString()));
}
if (terms.MinCount.HasValue)
{
yield return(KV.Create("terms.mincount", terms.MinCount.ToString()));
}
if (terms.Raw.HasValue)
{
yield return(KV.Create("terms.raw", terms.Raw.ToString().ToLowerInvariant()));
}
if (!string.IsNullOrEmpty(terms.Regex))
{
yield return(KV.Create("terms.regex", terms.Regex));
}
if (terms.RegexFlag != null)
{
foreach (var flag in terms.RegexFlag)
{
yield return(KV.Create("terms.regex.flag", flag.ToString()));
}
}
}
/// <summary>
/// Gets the Solr parameters for collapse queries
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public IEnumerable <KeyValuePair <string, string> > GetGroupingQueryOptions(QueryOptions options)
{
if (options.Grouping == null)
{
yield break;
}
yield return(KV.Create("group", true.ToString().ToLowerInvariant()));
if (options.Grouping.Fields != null)
{
foreach (var groupfield in options.Grouping.Fields)
{
if (string.IsNullOrEmpty(groupfield))
{
continue;
}
yield return(KV.Create("group.field", groupfield));
}
}
if (options.Grouping.Limit.HasValue)
{
yield return(KV.Create("group.limit", options.Grouping.Limit.ToString()));
}
if (options.Grouping.Offset.HasValue)
{
yield return(KV.Create("group.offset", options.Grouping.Offset.ToString()));
}
if (options.Grouping.Main.HasValue)
{
yield return(KV.Create("group.main", options.Grouping.Main.ToString().ToLowerInvariant()));
}
if (options.Grouping.Query != null)
{
foreach (var query in options.Grouping.Query.Where(query => query != null))
{
yield return(KV.Create("group.query", querySerializer.Serialize(query)));
}
}
if (!string.IsNullOrEmpty(options.Grouping.Func))
{
yield return(KV.Create("group.func", options.Grouping.Func));
}
if (options.Grouping.OrderBy != null && options.Grouping.OrderBy.Count > 0)
{
yield return(KV.Create("group.sort", string.Join(",", options.Grouping.OrderBy.Select(x => x.ToString()).ToArray())));
}
if (options.Grouping.Ngroups.HasValue)
{
yield return(KV.Create("group.ngroups", options.Grouping.Ngroups.ToString().ToLowerInvariant()));
}
if (options.Grouping.Truncate.HasValue)
{
yield return(KV.Create("group.truncate", options.Grouping.Truncate.ToString().ToLowerInvariant()));
}
if (options.Grouping.Facet.HasValue)
{
yield return(KV.Create("group.facet", options.Grouping.Facet.ToString().ToLowerInvariant()));
}
if (options.Grouping.CachePercent.HasValue)
{
yield return(KV.Create("group.cache.percent", options.Grouping.CachePercent.ToString()));
}
yield return(KV.Create("group.format", options.Grouping.Format.ToString().ToLowerInvariant()));
}
private IEnumerable <KeyValuePair <string, string> > ConvertToQueryParameters()
{
var param = new List <KeyValuePair <string, string> > {
KV.Create("literal.id", parameters.Id),
KV.Create("resource.name", parameters.ResourceName)
};
if (parameters.Fields != null)
{
foreach (var f in parameters.Fields)
{
if (f.FieldName == "id")
{
throw new ArgumentException("ExtractField named 'id' is not permitted in ExtractParameters.Fields - use ExtractParameters.Id instead");
}
param.Add(KV.Create("literal." + f.FieldName, f.Value));
}
}
if (parameters.StreamType != null)
{
param.Add(new KeyValuePair <string, string>("stream.type", parameters.StreamType));
}
if (parameters.AutoCommit)
{
param.Add(KV.Create("commit", "true"));
}
if (!string.IsNullOrEmpty(parameters.Prefix))
{
param.Add(KV.Create("uprefix", parameters.Prefix));
}
if (!string.IsNullOrEmpty(parameters.DefaultField))
{
param.Add(KV.Create("defaultField", parameters.DefaultField));
}
if (parameters.ExtractOnly)
{
param.Add(KV.Create("extractOnly", "true"));
if (parameters.ExtractFormat == ExtractFormat.Text)
{
param.Add(KV.Create("extractFormat", "text"));
}
}
if (!string.IsNullOrEmpty(parameters.Capture))
{
param.Add(KV.Create("capture", parameters.Capture));
}
if (parameters.CaptureAttributes)
{
param.Add(KV.Create("captureAttr", "true"));
}
if (!string.IsNullOrEmpty(parameters.XPath))
{
param.Add(KV.Create("xpath", parameters.XPath));
}
if (parameters.LowerNames)
{
param.Add(KV.Create("lowernames", "true"));
}
return(param);
}
/// <summary>
/// Gets the Solr parameters for stats queries
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public IEnumerable <KeyValuePair <string, string> > GetStatsQueryOptions(QueryOptions options)
{
if (options.Stats == null)
{
yield break;
}
yield return(KV.Create("stats", "true"));
if (options.Stats.Distinct)
{
yield return(KV.Create("stats.calcdistinct", "true"));
}
if (options.Stats.Fields != null)
{
foreach (var field in options.Stats.Fields)
{
if (string.IsNullOrEmpty(field))
{
continue;
}
yield return(KV.Create("stats.field", field));
}
}
if (options.Stats.FieldsWithFacets != null)
{
foreach (var fieldAndFacet in options.Stats.FieldsWithFacets)
{
var field = fieldAndFacet.Key;
if (string.IsNullOrEmpty(field))
{
continue;
}
var facets = fieldAndFacet.Value;
yield return(KV.Create("stats.field", field));
if (facets != null && facets.Count > 0)
{
foreach (var facet in facets)
{
if (string.IsNullOrEmpty(facet))
{
continue;
}
yield return(KV.Create(string.Format("f.{0}.stats.facet", field), facet));
}
}
}
}
if (options.Stats.Facets == null || options.Stats.Facets.Count == 0)
{
yield break;
}
foreach (var facet in options.Stats.Facets)
{
if (string.IsNullOrEmpty(facet))
{
continue;
}
yield return(KV.Create("stats.facet", facet));
}
}
/// <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)
{
var q = querySerializer.Serialize(Query);
if (q.Length > 0)
{
yield return(KV.Create("q", q));
}
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);
}
}