public void Concat()
{
var q1 = new SolrQuery("1");
var q2 = new SolrQuery("2");
var qm = new SolrMultipleCriteriaQuery(new[] {q1, q2});
Assert.AreEqual("(1 2)", Serialize(qm));
}
public async Task Facet1Async()
{
var termsFacetFor = new SolrQuery<TechProduct>().SearchFor("*", "lucene").Take(0).TermsFacetFor(x => x.Category);
termsFacetFor = termsFacetFor.RangeFacetFor(x => x.Popularity, x => x.Range(5, 10, "1"));
termsFacetFor = termsFacetFor.RangeFacetFor(x => x.ManufactureDate,
x =>
x.Range(DateTime.Now.AddYears(-20), DateTime.Now, "+1YEAR")
.TermsFacetFor(y => y.Category,
y => y.RangeFacetFor(z => z.Popularity, z => z.Range(5, 10, "1"))));
var searchResult = await _repository.SearchAsync(termsFacetFor);
var bucket = searchResult.Raw.Facets["R2"]["buckets"].ToList()[10]["T0"]["buckets"].ToList()[0]["R0"]["buckets"].ToList()[1];
Assert.AreEqual(6, bucket["val"]);
Assert.AreEqual(2, bucket["count"]);
//var facetC = new SolrQueryStatisticsFacet<TechProduct>("unique(cat)");
//var facetA = new SolrQueryTermsFacet<TechProduct>(x => x.Category).Facet("D", facetC);
//var facetB = new SolrQueryTermsFacet<TechProduct>(x => x.LastModified).Facet("D", facetC);
//var query = new SolrQuery<TechProduct>().Take(0).Facet("A", facetA).Facet("B", facetB).Facet("C", facetC);
//var r3 = await _repository.Get(query);
//Assert.AreEqual(0, r3.Response.Documents.Count());
//var facets = r3.GetFacets();
//Assert.AreEqual(37, (long)r3.Facets["count"]);
//var facetObject = (JObject)r3.Facets["A"];
//var dic = facetObject.ToObject<IDictionary>();
//Assert.AreNotEqual(null, dic);
}
public void AcceptsNulls()
{
var q1 = new SolrQuery("1");
ISolrQuery q2 = null;
var qm = new SolrMultipleCriteriaQuery(new[] {q1, q2});
Assert.AreEqual("(1)", Serialize(qm));
}
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 Concat_different_types() {
var q1 = new SolrQuery("1");
var q2 = new SolrQueryByField("f", "v");
var qm = new SolrMultipleCriteriaQuery(new ISolrQuery[] {q1, q2});
Console.WriteLine(Serialize(qm));
Assert.AreEqual("(1 f:(v))", Serialize(qm));
}
public void PlusEqualMany() {
AbstractSolrQuery q = new SolrQuery("first");
foreach (var _ in Enumerable.Range(0, 10)) {
q += new SolrQuery("others");
}
Assert.AreEqual("((((((((((first others) others) others) others) others) others) others) others) others) others)", Serialize(q));
}
public void AcceptsNulls()
{
var q1 = new SolrQuery("1");
ISolrQuery q2 = null;
var qm = new SolrMultipleCriteriaQuery(new[] { q1, q2 });
Assert.AreEqual("(1)", Serialize(qm));
}
public void Concat()
{
var q1 = new SolrQuery("1");
var q2 = new SolrQuery("2");
var qm = new SolrMultipleCriteriaQuery(new[] { q1, q2 });
Assert.AreEqual("(1 2)", Serialize(qm));
}
public bool DeleteByWebsiteId(int idWebsite)
{
var solr = GetSolrOperations();
SolrQuery solrQuery = new SolrQuery("website_id:" + idWebsite);
var response = solr.Delete(solrQuery);
return(response.Status == 0);
}
/// <summary>
/// Executes a query
/// </summary>
/// <typeparam name="T">Document type</typeparam>
/// <param name="query">Query</param>
/// <param name="orders">Sort orders</param>
/// <returns>Query results</returns>
public static SolrQueryResults <T> Query <T>(SolrQuery query, ICollection <SortOrder> orders)
{
var queryExecuter = NewQueryExecuter <T>();
return(queryExecuter.Execute(query, new QueryOptions {
OrderBy = orders
}));
}
public void SolrQuery_Boost()
{
var q = new SolrQuery("solr").Boost(12.2);
var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var query = serializer.Serialize(q);
Assert.Equal("(solr)^12.2", query);
}
public int DeleteByQuery(string query)
{
SolrQuery solrQuery = new SolrQuery(query);
var solr = GetSolrOperations();
var response = solr.Delete(solrQuery);
solr.Commit();
return(response.Status);
}
public TrackData ReadTrack(IModelReference trackReference)
{
var trackId = SolrModelReference.GetId(trackReference);
var query = new SolrQuery(string.Format("trackId:{0}", trackId));
var results = this.solrForTracksCore.Query(query);
return(FirstFromResultSet(results));
}
public AtomicUpdate()
{
InitializeComponent();
populateParametersUsedList();
populateUpdatedFieldsList();
form = null;
ip = null;
query = null;
}
public void Concat_different_types()
{
var q1 = new SolrQuery("1");
var q2 = new SolrQueryByField("f", "v");
var qm = new SolrMultipleCriteriaQuery(new ISolrQuery[] { q1, q2 });
testOutputHelper.WriteLine(Serialize(qm));
Assert.Equal("(1 f:(v))", Serialize(qm));
}
public void Concat_different_types()
{
var q1 = new SolrQuery("1");
var q2 = new SolrQueryByField("f", "v");
var qm = new SolrMultipleCriteriaQuery(new ISolrQuery[] { q1, q2 });
Console.WriteLine(Serialize(qm));
Assert.AreEqual("(1 f:v)", Serialize(qm));
}
/// <summary> </summary>
/// <param name="q">Query String</param>
/// <param name="categoryFilter">Options</param>
/// <returns></returns>
public ProductView Get(string q, string categoryFilter = null)
{
var query = new SolrQuery(SolrQuerySanitizer.Sanitize(q));
var queryOptions = CreateQueryOptions(categoryFilter);
var solrResult = _solrOperations.Query(q, queryOptions);
return(CreateSearchResultFromSolrResult(solrResult));
}
/// <summary>
/// 真正的检索方法，需要派生类进行实现
/// </summary>
/// <param name="condition">查询条件</param>
/// <param name="solr">Solr检索器对象</param>
/// <returns>检索结果</returns>
protected virtual Result GetSearchResult(SearchCondition condition, ISolrOperations <Record> solr)
{
QueryOptions queryOptions = BuildQueryOptions(condition);
ISolrQuery query = new SolrQuery(condition.KeyWord);
ISolrQueryResults <Record> result = solr.Query(query, queryOptions);
return(TransformSolrQueryResult(result, condition));
}
public void PlusEqualMany()
{
AbstractSolrQuery q = new SolrQuery("first");
foreach (var _ in Enumerable.Range(0, 10))
{
q += new SolrQuery("others");
}
Assert.AreEqual("((((((((((first others) others) others) others) others) others) others) others) others) others)", Serialize(q));
}
public ArchivingReportForm(frmMain frm, SolrQuery query, String core)
{
InitializeComponent();
hoursButton.Select();
customTimeBox.Text = defaultHours + "";
listView1.Columns[1].TextAlign = System.Windows.Forms.HorizontalAlignment.Left;
this.frm = frm;
this.query = query;
this.core = core;
this.reportType = "CORE";
}
public IPagedResult<IResult> Users(string name, uint pageIndex = 0, uint pageSize = 10)
{
var q = new SolrQuery
{
Query = string.Format("(Name:{0}*)(Name_split:{0}*)", name.ToLower().Replace(" ", "\\ ")),
PageIndex = pageIndex,
PageSize = pageSize
};
var results = ViewManager.GetView("UserSearch").Query(q);
return results;
}
public IEnumerable <QuoteHighlight> Search(String searchKey, out Int32 totalResults)
{
var query = new SolrQuery("text:" + searchKey);
var options = new QueryOptions()
{
//I don't need all the fields returned
Fields = new[] { "id", "title", "source", "score" },
//enable hit highlighting
Highlight = new HighlightingParameters()
{
Fields = new[] { "articleBody", "abstract" }
,
Fragsize = 200
,
AfterTerm = "</em></strong>"
,
BeforeTerm = "<em><strong>"
,
UsePhraseHighlighter = true
//, AlternateField = "source"
}
};
//issue the query
var results = _ctx.Query(query, options);
var highlights = results.Highlights;
var resultCount = results.Highlights.Count;
var searchResults = new List <QuoteHighlight>();
for (int i = 0; i < resultCount; i++)
{
//get the basic document information before dealing with highlights
var highlight = new QuoteHighlight()
{
Id = results[i].Id,
Title = results[i].Title,
Source = results[i].Source,
Score = results[i].Score.Value
};
//highlights are a separate array, and can be an array of hits...
foreach (var h in highlights[results[i].Id])
{
highlight.ArticleBodySnippet += String.Join(",", h.Value.ToArray());
}
searchResults.Add(highlight);
}
totalResults = results.NumFound;
return(searchResults);
}
public QueryResult Facet(string query, string facetField)
{
var q = new SolrQuery
{
Query = query,
Facet = string.Format("field:{0}", facetField)
};
var result = ViewManager.GetView("Search").FacetedQuery(q);
var fieldFacets = result.FacetFieldsResult.Select(item => new FieldFacet(item.Value, item.Facets.Select(facet => new Facet(facet.Value, facet.Count)).ToList()));
return new QueryResult { FieldFacets = fieldFacets.ToList() };
}
//Performs a query using the lucene/standard parser.
public List <Product> Search(string query)
{
try
{
SolrQuery q = new SolrQuery(query);
var r = solr.Ping();
List <Product> p = solr.Query(q);
return(p);
}
catch (Exception e)
{
e.ToString();
}
return(null);
}
public void Get_WithObjectTypeQuery_ShouldQueryViewWithObjectTypeIdAndFolders()
{
var extension = Make_ObjectV5Extension();
var folder = new Folder{ID = 1};
var user = Make_User();
var query = new SolrQuery {Query = "ObjectTypeID:1"};
PortalApplication.Setup(m => m.Log.Debug(It.IsAny<string>(), null));
ViewManager.Setup(m => m.GetView("Object").Query(It.Is<IQuery>(q => q.Query == "(ObjectTypeId:1)AND((FolderAncestors:1))"))).Returns(new PagedResult<IResult>(0, 0, new IResult[0]));
PortalRequest.SetupGet(p => p.User).Returns(user);
PermissionManager.Setup(m => m.GetFolders(FolderPermission.Read, user.Guid, It.IsAny<IEnumerable<Guid>>())).Returns(new[] { folder });
extension.Get(query, null, true, true, true, true);
ViewManager.Verify(m => m.GetView("Object").Query(It.Is<IQuery>(q => q.Query == "(ObjectTypeId:1)AND((FolderAncestors:1))")));
}
public IEnumerable <int> Get(string First_Name = null, string Dept = null)
{
string strQuery = string.Empty;
// SolrNet.Startup.Init<Employee>("http://localhost:8983/solr/Sample");
ISolrOperations <Employee> _solr = ServiceLocator.Current.GetInstance <ISolrOperations <Employee> >();
if (!string.IsNullOrWhiteSpace(First_Name))
{
strQuery = "First_Name:" + First_Name;
}
if (!string.IsNullOrWhiteSpace(strQuery) && !string.IsNullOrWhiteSpace(Dept))
{
strQuery += " AND " + "Dept:" + Dept;
}
else if (!string.IsNullOrWhiteSpace(Dept) && string.IsNullOrWhiteSpace(strQuery))
{
strQuery += "Dept:" + Dept;
}
if (string.IsNullOrWhiteSpace(strQuery))
{
strQuery += "*:*";
}
//string strQuery = (("First_Name:" + First_Name));
var query = new SolrQuery(strQuery);
SortOrder sortOrder = new SortOrder("First_Name");
var solrQueryResult = _solr.Query(query, new QueryOptions
{
Rows = 5000, //Max Rows returned
Start = 0,
OrderBy = new[] { sortOrder },
Fields = new[] { "Emp_ID" }
});
var list = solrQueryResult.ToList();
//if (list.Count != 0)
//{
// return (IEnumerable<Employee>)NotFound();
//}
//else
//{
// return list;
//}
return(list.Select(x => x.Emp_ID));
}
public Security(string address1, SolrQuery querier1, frmMain form1)
{
superUser = querier1.superUser;
address = address1;
querier = querier1;
mainForm = form1;
userCreds = querier.userCreds;
webServerName = querier1.webServerName;
token = querier1.token;
coreNames = querier.coreNames;
getAPIDs(address);
if (!superUser)
{
getValidApids();
}
}
public void ShouldSpecifyFilterQueries()
{
solrQueryBuilder.Setup(bld => bld.BuildReadQueryForHashes(It.IsAny <long[]>())).Returns("query");
solrQueryBuilder.Setup(bld => bld.BuildQueryForClusters(It.IsAny <IEnumerable <string> >())).Returns(
"filter-query");
solr.Setup(opr => opr.Query(It.IsAny <SolrQuery>(), It.IsAny <QueryOptions>())).Returns(new SolrQueryResults <SubFingerprintDTO>())
.Callback((SolrQuery q, QueryOptions opts) =>
{
Assert.AreEqual("query", q.Query);
SolrQuery filter = (SolrQuery)opts.FilterQueries.First();
Assert.AreEqual("filter-query", filter.Query);
});
subFingerprintDao.ReadSubFingerprints(new long[25], 5, new[] { "CA", "LA" });
}
public void DeleteByQuery() {
const string queryString = "someQuery";
var q = new SolrQuery(queryString);
var xml = string.Format("<delete><query>{0}</query></delete>", queryString);
var conn = new Mocks.MSolrConnection();
conn.post = conn.post.Args("/update", xml);
var querySerializer = new Mocks.MSolrQuerySerializer();
querySerializer.serialize += _ => queryString;
var cmd = new DeleteCommand(new DeleteByIdAndOrQueryParam(null, q, querySerializer), null);
cmd.Execute(conn);
Assert.AreEqual(1, conn.post.Calls);
}
public void DeleteByIdAndQuery()
{
var ids = new[] { "123", "456" };
const string queryString = "someQuery";
var xml = string.Format("<delete><id>{0}</id><id>{1}</id><query>{2}</query></delete>", ids[0], ids[1], queryString);
var conn = new Mocks.MSolrConnection();
conn.post = conn.post.Args("/update", xml);
var q = new SolrQuery(queryString);
var querySerializer = new Mocks.MSolrQuerySerializer();
querySerializer.serialize += _ => queryString;
var cmd = new DeleteCommand(new DeleteByIdAndOrQueryParam(ids, q, querySerializer));
cmd.Execute(conn);
Assert.AreEqual(1, conn.post.Calls);
}
public void DeleteIndex()
{
try
{
Log.Info("Deletes intire index for reindexing");
SolrQuery sq = new SolrQuery("*:*");
_solr.Delete(sq);
_solr.Commit();
}
catch (SolrNet.Exceptions.SolrConnectionException)
{
Log.Error("Connection to solr failed");
}
catch (Exception ex)
{
Log.Error("Error:" + ex.Message);
}
}
// Delete a singe document matched by the query
public string DeleteDoc(string q)
{
string res = "Didnt run..";
try
{
SolrQuery query = new SolrQuery(q);
res = solr.Delete(query).Status.ToString();
Commit();
}
catch (Exception e)
{
solr.Rollback();
res = e.ToString();
}
return(res);
}
public QueryResponse DoSearch(MovieQuery query)
{
//Create an object to hold results
FiltersFacets filtersFacets = new FiltersFacets();
Highlights highlights = new Highlights();
ExtraParameters extraParameters = new ExtraParameters();
SolrQueryResults <Movie> solrResults;
QueryResponse queryResponse = new QueryResponse
{
//Echo back the original query
OriginalQuery = query
};
//Get a connection
ISolrOperations <Movie> solr = connection.GetSolrInstance();
QueryOptions queryOptions = new QueryOptions
{
Rows = query.Rows,
StartOrCursor = new StartOrCursor.Start(query.Start),
FilterQueries = filtersFacets.BuildFilterQueries(query),
Facet = filtersFacets.BuildFacets(),
Highlight = highlights.BuildHighlightParameters(),
ExtraParams = extraParameters.BuildExtraParameters()
};
//Execute the query
ISolrQuery solrQuery = new SolrQuery(query.Query);
solrResults = solr.Query(solrQuery, queryOptions);
//Set response
ResponseExtraction extractResponse = new ResponseExtraction();
extractResponse.SetHeader(queryResponse, solrResults);
extractResponse.SetBody(queryResponse, solrResults);
extractResponse.SetSpellcheck(queryResponse, solrResults);
extractResponse.SetFacets(queryResponse, solrResults);
//Return response;
return(queryResponse);
}
public void DeleteByQuery()
{
const string queryString = "someQuery";
var q = new SolrQuery(queryString);
var xml = string.Format("<delete><query>{0}</query></delete>", queryString);
var conn = new Mocks.MSolrConnection();
conn.post = conn.post.Args("/update", xml);
var querySerializer = new Mocks.MSolrQuerySerializer();
querySerializer.serialize += _ => queryString;
var cmd = new DeleteCommand(new DeleteByIdAndOrQueryParam(null, q, querySerializer));
cmd.Execute(conn);
Assert.AreEqual(1, conn.post.Calls);
}
public string Results()
{
StringBuilder sb = new StringBuilder();
Startup.Init <T>(solrUrl);
var solr = ServiceLocator.Current.GetInstance <ISolrOperations <T> >();
var query = new SolrQuery(queryAll);
var options = new QueryOptions {
Rows = 10
};
var results = solr.Query(query, options);
foreach (var item in results)
{
sb.AppendLine(item.ToString());
}
return(sb.ToString());
}
public IPagedResult<IResult> Get(IEnumerable<Guid> objectGuids, uint? folderId = null, Guid? accessPointGuid = null, bool includeAccessPoints = false, bool includeMetadata = false, bool includeFiles = false, bool includeObjectRelations = false, bool includeFolders = false, uint pageSize = 10, uint pageIndex = 0)
{
var query = new SolrQuery
{
Query = "*:*",
PageIndex = pageIndex,
PageSize = pageSize
};
if (objectGuids.Any()) query.Query = string.Format("Id:{0}", string.Join(" ", objectGuids));
var folderFilter = GetFoldersWithAccess(folderId);
if(accessPointGuid == null && !folderFilter.Any()) throw new InsufficientPermissionsException("No folders with access");
return ObjectQueryHelper.GetObjects(query, accessPointGuid, folderFilter,
includeAccessPoints, includeMetadata,
includeFiles, includeObjectRelations,
includeFolders);
}
public void DeleteByIdAndQuery()
{
var ids = new[] { "123", "456" };
const string queryString = "someQuery";
var xml = string.Format("<delete><id>{0}</id><id>{1}</id><query>{2}</query></delete>", ids[0], ids[1], queryString);
var conn = new Mocks.MSolrConnection();
conn.post = conn.post.Args("/update", xml);
var q = new SolrQuery(queryString);
var querySerializer = new Mocks.MSolrQuerySerializer();
querySerializer.serialize += _ => queryString;
var cmd = new DeleteCommand(new DeleteByIdAndOrQueryParam(ids, q, querySerializer), null);
cmd.Execute(conn);
Assert.AreEqual(1, conn.post.Calls);
}
public void customPage(object sender, KeyPressEventArgs e)
{
formMain.listView1.Items.Clear();
try
{
formMain.start = Int32.Parse((sender as TextBox).Text) - 1;
}
catch
{
MessageBox.Show("Invalid Page Number");
formMain.customPageLink(sender, e);
}
SolrQuery newQuery = new SolrQuery(formMain.ip, formMain);
List <ServerResult> mails;
if (formMain.jidFilter)
{
mails = new XMLParser(newQuery.getMailsForOneSubfolder(formMain.selectedItemGuid, formMain.start, formMain.jid)).results;
}
else
{
mails = new XMLParser(newQuery.getMailsForOneSubfolder(formMain.selectedItemGuid, formMain.start, formMain.mailSort)).results;
}
formMain.currentPage = mails;
formMain.listView1.Items.Clear();
formMain.writeMailsInList(mails);
if ((mails.Count == 0) || (mails == null))
{
MessageBox.Show("No messages found on page " + (formMain.start + 1));
}
else
{
try
{
formMain.AppendTextBox("Now displaying page " + formMain.start);
}
catch (Exception ex)
{
}
}
}
public QueryResponse DoSearch(EhsQuery query)
{
FiltersFacets filtersFacets = new FiltersFacets();
Highlights highlights = new Highlights();
//Create an object to hold results
SolrQueryResults <EHSDoc> solrResults;
QueryResponse queryResponse = new QueryResponse();
//Echo back the original query
queryResponse.QueryText = query;
//Create method for increased readibility.
//Move to some sort of application start or build eveuntally.
bool initialize = Connection.Initialized;
ISolrOperations <EHSDoc> solr = Connection.SolrOperations;
QueryOptions queryOptions = new QueryOptions
{
Rows = query.Rows,
Facet = filtersFacets.BuildFacets(),
FilterQueries = filtersFacets.BuildFilterQueries(query),
Highlight = highlights.BuildHighlightParameters(),
};
//Execute the query
ISolrQuery solrQuery = new SolrQuery(query.QueryText);
solrResults = solr.Query(solrQuery, queryOptions);
//Set response
ResponseExtraction extractResponse = new ResponseExtraction();
extractResponse.SetHeader(queryResponse, solrResults);
extractResponse.SetBody(queryResponse, solrResults);
extractResponse.SetFacets(queryResponse, solrResults);
//Return response;
return(queryResponse);
}
public MetadataIndexDoc GetMetadata(string uuid)
{
MetadataIndexDoc metadata = null;
var solrInstance = MvcApplication.indexContainer.Resolve <ISolrOperations <MetadataIndexDoc> >(CultureHelper.GetIndexCore(SolrCores.Metadata));
ISolrQuery query = new SolrQuery("uuid:" + uuid);
try
{
SolrQueryResults <MetadataIndexDoc> queryResults = solrInstance.Query(query, new SolrNet.Commands.Parameters.QueryOptions
{
Fields = new[] { "uuid", "title", "abstract", "purpose", "type", "theme", "organization", "organization_seo_lowercase", "placegroups", "organizationgroup",
"topic_category", "organization_logo_url", "thumbnail_url", "distribution_url", "distribution_protocol", "distribution_name", "product_page_url", "date_published", "date_updated", "nationalinitiative",
"score", "ServiceDistributionProtocolForDataset", "ServiceDistributionUrlForDataset", "ServiceDistributionNameForDataset", "DistributionProtocols", "legend_description_url", "product_sheet_url", "product_specification_url", "area", "datasetservice", "popularMetadata", "bundle", "servicelayers", "accessconstraint", "servicedataset", "otherconstraintsaccess", "dataaccess", "ServiceDistributionUuidForDataset", "ServiceDistributionAccessConstraint", "parentidentifier", "serie", "seriedatasets", "distributions" }
});
metadata = queryResults.FirstOrDefault();
}
catch (Exception) { }
return(metadata);
}
static void SimpleExample()
{
// Initialize the query
SolrQuery solrQuery = new SolrQuery(SOLR_DB_NAME, SOLR_URL, SOLR_PORT);
// Set the query
solrQuery.Common.SetResponseWriter(SolrCommon.ResponseWriter.json); // Json format
solrQuery.Common.BindValue(SolrCommon.Parameter.q, "*", "*"); // Set the following query: q=*:*
solrQuery.Common.BindValue(SolrCommon.Parameter.fl, QueryOperator.AND, "id", "/name"); // Set filters
// Get and print results
SolrResults solrResults = solrQuery.Execute();
foreach (SolrItemResult i in solrResults.Response.docs)
{
Console.WriteLine(i.ToString()); // Print all the results
Console.WriteLine(i["id"]); // Print the "id" value
Console.WriteLine(i["/name"]); // Print the "/name" field
}
Console.ReadKey();
}
public AtomicUpdate(MonitorFolderActivity.frmMain form, String ip)
{
InitializeComponent();
populateParametersUsedList();
populateUpdatedFieldsList();
this.form = form;
this.ip = ip;
this.query = new SolrQuery(ip, form);
//coreComboBox.Items.Add("usermbx");
try
{
coreComboBox.Items.AddRange(query.coreNames.ToArray());
}
catch (Exception e) {
form.logToFile(e.Message, MonitorFolderActivity.frmMain.DEBUG_HIGH);
}
if (coreComboBox.Items.Count == 0)
{
this.DialogResult = System.Windows.Forms.DialogResult.Abort;
this.Close();
}
}
public void SimpleQuery()
{
var q = new SolrQuery("desc:samsung");
var notq = new SolrNotQuery(q);
Assert.AreEqual("-desc:samsung", Serialize(notq));
}
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
}
});
}
public void SolrQuery_Boost()
{
var q = new SolrQuery("solr").Boost(12.2);
Assert.AreEqual("(solr)^12.2", q.Query);
}
public void SimpleQuery() {
var q = new SolrQuery("desc:samsung");
var requiredq = new SolrRequiredQuery(q);
Assert.AreEqual("+desc:samsung", Serialize(requiredq));
}
static SolrQuery()
{
All = new SolrQuery("*:*");
}
public void MultipleOr()
{
var q = new SolrQuery("solr") || new SolrQuery("name:desc") || new SolrQueryByField("id", "123456");
Assert.AreEqual("((solr OR name:desc) OR id:(123456))", Serialize(q));
}
public void RequiredQuery_is_AbstractSolrQuery() {
AbstractSolrQuery q = new SolrQuery("").Required();
}
public void MixedAndOrs_obeys_operator_precedence()
{
var q = new SolrQuery("solr") || new SolrQuery("name:desc") && new SolrQueryByField("id", "123456");
Assert.AreEqual("(solr OR (name:desc AND id:(123456)))", Serialize(q));
}
public void MultipleAnd()
{
var q = new SolrQuery("solr") && new SolrQuery("name:desc") && new SolrQueryByField("id", "123456");
Assert.AreEqual("((solr AND name:desc) AND id:(123456))", Serialize(q));
}
public void AndNot()
{
var q = new SolrQuery("a") && !new SolrQuery("b");
Console.WriteLine(Serialize(q));
Assert.AreEqual("(a AND -b)", Serialize(q));
}
public void Minus()
{
var q = new SolrQuery("solr") - new SolrQuery("name:desc");
Assert.AreEqual("(solr -name:desc)", Serialize(q));
}
public void Add()
{
var q = new SolrQuery("solr") + new SolrQuery("name:desc");
Assert.AreEqual("(solr name:desc)", Serialize(q));
}
public void OneOr()
{
var q = new SolrQuery("solr") || new SolrQuery("name:desc");
Assert.AreEqual("(solr OR name:desc)", Serialize(q));
}
public void OneAnd()
{
var q = new SolrQuery("solr") && new SolrQuery("name:desc");
Assert.AreEqual("(solr AND name:desc)", Serialize(q));
}
public void Add()
{
var q = new SolrQuery("solr") + new SolrQuery("name:desc");
Assert.AreEqual("(solr name:desc)", q.Query);
}
public void NotQuery_is_AbstractSolrQuery()
{
AbstractSolrQuery q = new SolrQuery("").Not();
}
