C# SolrQueryExecuter.GetAllParameters方法代码示例

 public void ExtraParams()
 {
     var querySerializer = new SolrQuerySerializerStub("123123");
     var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, null, null);
     var p = queryExecuter.GetAllParameters(new SolrQuery("123123"), new QueryOptions {
         ExtraParams = new Dictionary<string, string> {
                     {"qt", "geo"},
                     {"lat", "40.75141843299745"},
                     {"long", "-74.0093994140625"},
                     {"radius", "1"},
                 }
     }).ToDictionary(x => x.Key, x => x.Value);
     Assert.AreEqual("123123", p["q"]);
     Assert.AreEqual("geo", p["qt"]);
     Assert.AreEqual("1", p["radius"]);
 }

 public void MoreLikeThis()
 {
     var querySerializer = new SolrQuerySerializerStub("apache");
     var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, 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 void GetAllParameters_with_spelling()
 {
     var querySerializer = new SolrQuerySerializerStub("*:*");
     var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, null, null);
     var p = queryExecuter.GetAllParameters(SolrQuery.All, 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 GetClusteringParameters()
 {
     var querySerializer = new SolrQuerySerializerStub("apache");
     var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, null, null);
     var p = queryExecuter.GetAllParameters(new SolrQuery("apache"), new QueryOptions {
         Clustering = new ClusteringParameters {
             Title = "headline",
             FragSize = 10,
             LexicalResources = "fakedir",
             ProduceSummary = true,
             Algorithm = "org.carrot2.clustering.lingo.LingoClusteringAlgorithm",
             Url = "none",
             Collection = false,
             Engine = "default",
             SubClusters = false,
             Snippet = "synopsis",
             NumDescriptions = 20
         },
     }).ToList();
     Assert.Contains(p, KV.Create("carrot.title", "headline"));
     Assert.Contains(p, KV.Create("clustering.engine", "default"));
     Assert.Contains(p, KV.Create("clustering.collection", "false"));
     Assert.Contains(p, KV.Create("carrot.algorithm", "org.carrot2.clustering.lingo.LingoClusteringAlgorithm"));
     Assert.Contains(p, KV.Create("carrot.url", "none"));
     Assert.Contains(p, KV.Create("carrot.snippet", "synopsis"));
     Assert.Contains(p, KV.Create("carrot.produceSummary", "true"));
     Assert.Contains(p, KV.Create("carrot.fragSize", "10"));
     Assert.Contains(p, KV.Create("carrot.numDescriptions", "20"));
     Assert.Contains(p, KV.Create("carrot.outputSubClusters", "false"));
     Assert.Contains(p, KV.Create("carrot.lexicalResourcesDir", "fakedir"));
 }

        public void GetCollapseExpandParameters_Expand()
        {
            var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
            var e = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, null, null);
            var expand = new ExpandParameters(
                sort: new SortOrder("sortField", Order.ASC),
                rows: 100,
                query: new SolrQuery("aquery"),
                filterQuery: null);

            var p = e.GetAllParameters(SolrQuery.All, new QueryOptions {
                Rows = 1,
                CollapseExpand = new CollapseExpandParameters("somefield", expand, null, null),
            }).ToList();
            CollectionAssert.Contains(p, KV.Create("fq", "{!collapse field=somefield}"));
            CollectionAssert.Contains(p, KV.Create("expand.sort", "sortField asc"));
            CollectionAssert.Contains(p, KV.Create("expand.rows", "100"));
            CollectionAssert.Contains(p, KV.Create("expand.q", "aquery"));
        }

 public void GetCollapseExpandParameters_min_policy()
 {
     var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
     var e = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, null, null);
     var max = new CollapseExpandParameters.MinOrMax.Max("maxfield");
     var policy = CollapseExpandParameters.NullPolicyType.Collapse;
     var p = e.GetAllParameters(SolrQuery.All, new QueryOptions {
         Rows = 1,
         CollapseExpand = new CollapseExpandParameters("somefield", null, max, policy),
     }).ToList();
     CollectionAssert.Contains(p, KV.Create("fq", "{!collapse field=somefield nullPolicy=collapse max=maxfield}"));
 }

 public void GetAllParameters_with_multiple_group_queries()
 {
     var querySerializer = new SolrQuerySerializerStub("*:*");
     var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, null, null);
     var p = queryExecuter.GetAllParameters(SolrQuery.All, new QueryOptions {
         Grouping = new GroupingParameters {
             Query = new Collection<string> { "apple", "banana", "cherry" }
         }
     }).ToList();
     Assert.Contains(p, KV.Create("group.query", "apple") );
     Assert.Contains(p, KV.Create("group.query", "banana"));
     Assert.Contains(p, KV.Create("group.query", "cherry"));
 }

 public void GetCollapseExpandParameters()
 {
     var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
     var e = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, null, null);
     var p = e.GetAllParameters(SolrQuery.All, new QueryOptions {
         Rows = 1,
         CollapseExpand = new CollapseExpandParameters("somefield", null, null, null),
     }).ToList();
     CollectionAssert.Contains(p, KV.Create("fq", "{!collapse field=somefield}"));
 }

 public void GetAllParameters_with_multiple_group_fields()
 {
     var querySerializer = new SolrQuerySerializerStub("*:*");
     var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, null, null);
     var p = queryExecuter.GetAllParameters(SolrQuery.All, new QueryOptions
     {
         Grouping = new GroupingParameters
         {
             Fields = new Collection<string> { "fieldx", "fieldy", "fieldz" }
         }
     }).ToList();
     Assert.Contains(p, KV.Create("group.field", "fieldx"));
     Assert.Contains(p, KV.Create("group.field", "fieldy"));
     Assert.Contains(p, KV.Create("group.field", "fieldz"));
 }

        public void GetAllParameters_with_both_group_fields_and_group_queries()
        {
            var querySerializer = new SolrQuerySerializerStub("*:*");
            var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, null, null);
            var p = queryExecuter.GetAllParameters(SolrQuery.All, new QueryOptions
            {
                Grouping = new GroupingParameters
                {
                    Query = new Collection<string> { "apple", "banana", "cherry" },
                    Fields = new Collection<string> { "fieldx", "fieldy", "fieldz" }
                }
            }).ToList();

            IEnumerable<string> groupParameters = p.Where(param => param.Key.StartsWith("group.")).Select(param => param.Key);
            Assert.IsEmpty(groupParameters, "The invalid combination of group.fields and group.query should not have generated any group parameters.");
        }

 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 void ExtraParams()
 {
     var mocks = new MockRepository();
     var parser = mocks.DynamicMock<ISolrQueryResultParser<TestDocument>>();
     var conn = mocks.DynamicMock<ISolrConnection>();
     var serializer = mocks.StrictMock<ISolrQuerySerializer>();
     With.Mocks(mocks)
         .Expecting(() => Expect.On(serializer)
                              .Call(serializer.Serialize(null))
                              .IgnoreArguments()
                              .Return("123123"))
         .Verify(() => {
             var queryExecuter = new SolrQueryExecuter<TestDocument>(parser, conn, serializer, null, null);
             var p = queryExecuter.GetAllParameters(new SolrQuery("123123"), new QueryOptions {
                 ExtraParams = new Dictionary<string, string> {
                     {"qt", "geo"},
                     {"lat", "40.75141843299745"},
                     {"long", "-74.0093994140625"},
                     {"radius", "1"},
                 }
             }).ToDictionary(x => x.Key, x => x.Value);
             Assert.AreEqual("123123", p["q"]);
             Assert.AreEqual("geo", p["qt"]);
             Assert.AreEqual("1", p["radius"]);
         });
 }

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