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); } }