public void Facets()
{
var q = new Dictionary <string, string>();
q["q"] = "";
q["rows"] = SolrQueryExecuter <TestDocument> .ConstDefaultRows.ToString();
q["facet"] = "true";
q["facet.field"] = "Id";
q["facet.query"] = "id:[1 TO 5]";
var conn = new MockConnection(q);
var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var parser = new MSolrAbstractResponseParser <TestDocument>();
parser.parse &= x => x.Stub();
var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer());
var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, facetQuerySerializer, null);
queryExecuter.Execute(new SolrQuery(""), new QueryOptions {
Facet = new FacetParameters {
Queries = new ISolrFacetQuery[] {
new SolrFacetFieldQuery("Id"),
new SolrFacetQuery(new SolrQuery("id:[1 TO 5]")),
}
}
});
}
public void GetAllParameters_mlt_with_field_query()
{
var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var qe = new SolrQueryExecuter <TestDocument>(null, null, serializer, null, null);
var p = qe.GetAllMoreLikeThisHandlerParameters(
new SolrMoreLikeThisHandlerQuery(new SolrQueryByField("id", "1234")),
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("q", "(id:1234)"));
Assert.Contains(p, KV.Create("start", "0"));
Assert.Contains(p, KV.Create("rows", "5"));
Assert.Contains(p, KV.Create("fl", "one,two,three"));
Assert.Contains(p, KV.Create("mlt.fl", "one,three"));
Assert.Contains(p, KV.Create("mlt.match.include", "false"));
Assert.Contains(p, KV.Create("mlt.match.offset", "5"));
Assert.Contains(p, KV.Create("mlt.interestingTerms", "none"));
}
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 serializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var facetQuerySerializer = new DefaultFacetQuerySerializer(serializer, new DefaultFieldSerializer());
var parser = new MSolrAbstractResponseParser <TestDocument>();
parser.parse &= x => x.Stub();
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 FilterQuery()
{
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 parser = new MSolrAbstractResponseParser <TestDocument>();
parser.parse &= x => x.Stub();
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 FacetQuery()
{
var mocks = new MockRepository();
var query = new Dictionary <string, string>();
query["q"] = "";
query["rows"] = SolrQueryExecuter <TestDocumentWithUniqueKey> .ConstDefaultRows.ToString();
query["facet"] = "true";
query["facet.query"] = "id:1";
var connection = new MockConnection(query);
var parser = mocks.StrictMock <ISolrQueryResultParser <TestDocumentWithUniqueKey> >();
var docSerializer = mocks.StrictMock <ISolrDocumentSerializer <TestDocumentWithUniqueKey> >();
var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer());
With.Mocks(mocks).Expecting(() => {
Expect.On(parser)
.Call(parser.Parse(null))
.IgnoreArguments()
.Return(new SolrQueryResults <TestDocumentWithUniqueKey>());
}).Verify(() => {
var executer = new SolrQueryExecuter <TestDocumentWithUniqueKey>(parser, connection, querySerializer, facetQuerySerializer);
var solr = new SolrBasicServer <TestDocumentWithUniqueKey>(connection, executer, docSerializer, null, null, null, null, null);
var r = solr.Query(new SolrQuery(""), new QueryOptions {
Facet = new FacetParameters {
Queries = new ISolrFacetQuery[] {
new SolrFacetQuery(new SolrQuery("id:1")),
},
}
});
});
}
public void FacetQuery()
{
var connection = new MSolrConnection();
connection.get += (url, param) => {
Assert.AreEqual("/select", url);
var expectedParams = new Dictionary <string, string> {
{ "q", "" },
{ "rows", SolrQueryExecuter <TestDocumentWithUniqueKey> .ConstDefaultRows.ToString() },
{ "facet", "true" },
{ "facet.query", "id:1" },
};
CollectionAssert.AreEquivalent(expectedParams, param);
return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
};
var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer());
var parser = new MSolrAbstractResponseParser <TestDocumentWithUniqueKey>();
parser.parse &= x => x.Stub();
var executer = new SolrQueryExecuter <TestDocumentWithUniqueKey>(parser, connection, querySerializer, facetQuerySerializer, null);
var solr = new SolrBasicServer <TestDocumentWithUniqueKey>(connection, executer, null, null, null, null, null, null);
var r = solr.Query(new SolrQuery(""), new QueryOptions {
Facet = new FacetParameters {
Queries = new ISolrFacetQuery[] {
new SolrFacetQuery(new SolrQuery("id:1")),
},
}
});
Assert.AreEqual(1, connection.get.Calls);
}
public void Facets()
{
var q = new Dictionary <string, string>();
q["q"] = "";
q["rows"] = SolrQueryExecuter <TestDocument> .ConstDefaultRows.ToString();
q["facet"] = "true";
q["facet.field"] = "Id";
q["facet.query"] = "id:[1 TO 5]";
var conn = new MockConnection(q);
var mocks = new MockRepository();
var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >();
var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer());
var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, facetQuerySerializer);
queryExecuter.Execute(new SolrQuery(""), new QueryOptions {
Facet = new FacetParameters {
Queries = new ISolrFacetQuery[] {
new SolrFacetFieldQuery("Id"),
new SolrFacetQuery(new SolrQuery("id:[1 TO 5]")),
}
}
});
}
public void ConstantScore_with_high_value()
{
var q = new SolrConstantScoreQuery(new SolrQuery("solr"), 34.2E10);
var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var query = serializer.Serialize(q);
Assert.Equal("(solr)^=342000000000", query);
}
public void Boost_with_high_value()
{
var q = new SolrQueryBoost(new SolrQuery("solr"), 34.2E10);
var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var query = serializer.Serialize(q);
Assert.AreEqual("(solr)^342000000000", query);
}
public void SolrQuery_Boost()
{
var q = new SolrQuery("solr").Boost(12.2);
var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var query = serializer.Serialize(q);
Assert.AreEqual("(solr)^12.2", query);
}
public void Boost()
{
var q = new SolrQueryBoost(new SolrQuery("solr"), 34.2);
var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var query = serializer.Serialize(q);
Assert.Equal("(solr)^34.2", query);
}
public void Query()
{
var q = new SolrHasValueQuery("name");
var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var query = serializer.Serialize(q);
Assert.AreEqual("name:[* TO *]", query);
}
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();
Assert.Contains(p, KV.Create("fq", "{!collapse field=somefield}"));
}
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();
Assert.Contains(p, KV.Create("fq", "{!collapse field=somefield nullPolicy=collapse max=maxfield}"));
}
public static ISolrBasicOperations <T> GetBasicServer <T>(ISolrConnection connection)
{
ISolrFieldParser fieldParser = new DefaultFieldParser();
IReadOnlyMappingManager mapper = new MemoizingMappingManager(new AttributesMappingManager());
ISolrDocumentPropertyVisitor visitor = new DefaultDocumentVisitor(mapper, fieldParser);
ISolrDocumentResponseParser <T> parser;
if (typeof(T) == typeof(Dictionary <string, object>))
{
parser = (ISolrDocumentResponseParser <T>) new SolrDictionaryDocumentResponseParser(fieldParser);
}
else
{
parser = new SolrDocumentResponseParser <T>(mapper, visitor, new SolrDocumentActivator <T>());
}
ISolrAbstractResponseParser <T> resultParser = new DefaultResponseParser <T>(parser);
ISolrFieldSerializer fieldSerializer = new DefaultFieldSerializer();
;
ISolrQuerySerializer querySerializer = new DefaultQuerySerializer(fieldSerializer);
ISolrFacetQuerySerializer facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, fieldSerializer);
// validate why only this?
ISolrMoreLikeThisHandlerQueryResultsParser <T> mlthResultParser = new SolrMoreLikeThisHandlerQueryResultsParser <T>(new[] { resultParser });
ISolrQueryExecuter <T> executor = new SolrQueryExecuter <T>(resultParser, connection, querySerializer, facetQuerySerializer, mlthResultParser);
ISolrDocumentSerializer <T> documentSerializer;
if (typeof(T) == typeof(Dictionary <string, object>))
{
documentSerializer = (ISolrDocumentSerializer <T>) new SolrDictionarySerializer(fieldSerializer);
}
else
{
documentSerializer = new SolrDocumentSerializer <T>(mapper, fieldSerializer);
}
ISolrSchemaParser schemaParser = new SolrSchemaParser();
ISolrHeaderResponseParser headerParser = new HeaderResponseParser <T>();
ISolrDIHStatusParser dihStatusParser = new SolrDIHStatusParser();
ISolrExtractResponseParser extractResponseParser = new ExtractResponseParser(headerParser);
ISolrBasicOperations <T> basicServer = new SolrBasicServer <T>(connection, executor, documentSerializer, schemaParser, headerParser, querySerializer, dihStatusParser, extractResponseParser);
return(basicServer);
}
public static AuthAdminSolrServer <T> CreateSolrServer(string connectionString, string coreIndex, IndexType indexType = IndexType.Solr)
{
var connection = BuildConnection.CreateSolrConnection(connectionString + coreIndex, indexType);
var docSerializer = new SolrDocumentSerializer <T>(new AttributesMappingManager(), new DefaultFieldSerializer());
var headerResponseParser = new HeaderResponseParser <T>();
var solrFieldSerializer = new DefaultFieldSerializer();
var mapper = new AttributesMappingManager();
var dparser = new SolrDocumentResponseParser <T>(mapper, new DefaultDocumentVisitor(mapper, new DefaultFieldParser()), new SolrDocumentActivator <T>());
var parser = new DefaultResponseParser <T>(dparser);
var querySerializer = new DefaultQuerySerializer(solrFieldSerializer);
var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer());
var executer = new SolrQueryExecuter <T>(parser, connection, querySerializer, facetQuerySerializer, null);
var basesolr = new SolrBasicServer <T>(connection, executer, docSerializer, null, headerResponseParser, null, null, null);
return(new AuthAdminSolrServer <T>(basesolr, null, null));
}
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();
Assert.Contains(p, KV.Create("fq", "{!collapse field=somefield}"));
Assert.Contains(p, KV.Create("expand.sort", "sortField asc"));
Assert.Contains(p, KV.Create("expand.rows", "100"));
Assert.Contains(p, KV.Create("expand.q", "aquery"));
}
public void FacetFieldQuery()
{
var mocks = new MockRepository();
var query = new Dictionary <string, string>();
query["q"] = "*:*";
query["facet"] = "true";
query["facet.field"] = "cat";
query["rows"] = "0";
var connection = new MockConnection(query);
var resultParser = mocks.StrictMock <ISolrQueryResultParser <TestDocumentWithUniqueKey> >();
var mapper = mocks.StrictMock <IReadOnlyMappingManager>();
var validationManager = mocks.StrictMock <IMappingValidator>();
var docSerializer = mocks.StrictMock <ISolrDocumentSerializer <TestDocumentWithUniqueKey> >();
With.Mocks(mocks).Expecting(() => {
Expect.On(resultParser)
.Call(resultParser.Parse(""))
.IgnoreArguments()
.Repeat.Once()
.Return(new SolrQueryResults <TestDocumentWithUniqueKey> {
FacetFields = new Dictionary <string, ICollection <KeyValuePair <string, int> > > {
{
"cat", new List <KeyValuePair <string, int> > {
new KeyValuePair <string, int>("electronics", 5),
new KeyValuePair <string, int>("hard drive", 3),
}
}
}
});
}).Verify(() => {
var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer());
var queryExecuter = new SolrQueryExecuter <TestDocumentWithUniqueKey>(resultParser, connection, querySerializer, facetQuerySerializer);
var basicSolr = new SolrBasicServer <TestDocumentWithUniqueKey>(connection, queryExecuter, docSerializer, null, null, null, null, null);
var solr = new SolrServer <TestDocumentWithUniqueKey>(basicSolr, mapper, validationManager);
var r = solr.FacetFieldQuery(new SolrFacetFieldQuery("cat"));
Assert.AreEqual(2, r.Count);
Assert.AreEqual("electronics", r.First().Key);
});
}
public DefaultSolrLocator()
{
MappingManager = new MemoizingMappingManager(new AttributesMappingManager());
FieldParser = new DefaultFieldParser();
DocumentPropertyVisitor = new DefaultDocumentVisitor(MappingManager, FieldParser);
if (typeof(T) == typeof(Dictionary <string, object>))
{
DocumentResponseParser =
(ISolrDocumentResponseParser <T>) new SolrDictionaryDocumentResponseParser(FieldParser);
}
else
{
DocumentResponseParser = new SolrDocumentResponseParser <T>(MappingManager, DocumentPropertyVisitor,
new SolrDocumentActivator <T>());
}
ResponseParser = new DefaultResponseParser <T>(DocumentResponseParser);
SchemaParser = new SolrSchemaParser();
HeaderParser = new HeaderResponseParser <string>();
DihStatusParser = new SolrDIHStatusParser();
ExtractResponseParser = new ExtractResponseParser(HeaderParser);
FieldSerializer = new DefaultFieldSerializer();
QuerySerializer = new DefaultQuerySerializer(FieldSerializer);
FacetQuerySerializer = new DefaultFacetQuerySerializer(QuerySerializer, FieldSerializer);
MlthResultParser = new SolrMoreLikeThisHandlerQueryResultsParser <T>(new[] { ResponseParser });
StatusResponseParser = new SolrStatusResponseParser();
if (typeof(T) == typeof(Dictionary <string, object>))
{
DocumentSerializer = (ISolrDocumentSerializer <T>) new SolrDictionarySerializer(FieldSerializer);
}
else
{
DocumentSerializer = new SolrDocumentSerializer <T>(MappingManager, FieldSerializer);
}
HttpCache = new NullCache();
}
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 MultipleFacetFields()
{
var conn = new MockConnection(new[] {
KVP("q", ""),
KVP("rows", SolrQueryExecuter <TestDocument> .ConstDefaultRows.ToString()),
KVP("facet", "true"),
KVP("facet.field", "Id"),
KVP("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);
queryExecuter.Execute(new SolrQuery(""), new QueryOptions {
Facet = new FacetParameters {
Queries = new ISolrFacetQuery[] {
new SolrFacetFieldQuery("Id"),
new SolrFacetFieldQuery("OtherField"),
}
}
});
}
public string SerializeQuery(object q)
{
var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
return(serializer.Serialize(q));
}
public void Highlighting()
{
const string highlightedField = "field1";
const string afterTerm = "after";
const string beforeTerm = "before";
const int snippets = 3;
const string alt = "alt";
const int fragsize = 7;
const string query = "mausch";
var highlightQuery = new SolrQuery(query);
var q = new Dictionary <string, string>();
q["q"] = "";
q["rows"] = SolrQueryExecuter <TestDocument> .ConstDefaultRows.ToString();
q["hl"] = "true";
q["hl.q"] = query;
q["hl.fl"] = highlightedField;
q["hl.snippets"] = snippets.ToString();
q["hl.fragsize"] = fragsize.ToString();
q["hl.requireFieldMatch"] = "true";
q["hl.alternateField"] = alt;
q["hl.tag.pre"] = beforeTerm;
q["hl.tag.post"] = afterTerm;
q["hl.regex.slop"] = "4.12";
q["hl.regex.pattern"] = "\\.";
q["hl.regex.maxAnalyzedChars"] = "8000";
q["hl.usePhraseHighlighter"] = "true";
q["hl.useFastVectorHighlighter"] = "true";
q["hl.highlightMultiTerm"] = "true";
q["hl.mergeContiguous"] = "true";
q["hl.maxAnalyzedChars"] = "12";
q["hl.maxAlternateFieldLength"] = "22";
q["hl.fragmenter"] = "regex";
var conn = new MockConnection(q);
var querySerializer = new DefaultQuerySerializer(new MSolrFieldSerializer());
var parser = new MSolrAbstractResponseParser <TestDocument>();
parser.parse &= x => x.Stub();
var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, null, null);
queryExecuter.Execute(new SolrQuery(""), new QueryOptions {
Highlight = new HighlightingParameters {
Fields = new[] { highlightedField },
AfterTerm = afterTerm,
BeforeTerm = beforeTerm,
Query = highlightQuery,
Snippets = snippets,
AlternateField = alt,
Fragsize = fragsize,
RequireFieldMatch = true,
RegexSlop = 4.12,
RegexPattern = "\\.",
RegexMaxAnalyzedChars = 8000,
UsePhraseHighlighter = true,
UseFastVectorHighlighter = true,
MergeContiguous = true,
MaxAnalyzedChars = 12,
HighlightMultiTerm = true,
MaxAlternateFieldLength = 22,
Fragmenter = SolrHighlightFragmenter.Regex
}
});
}
