[
https://issues.apache.org/jira/browse/LUCENE-1518?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12663134#action_12663134
]
thetaphi edited comment on LUCENE-1518 at 1/12/09 2:41 PM:
----------------------------------------------------------------
In my opinion, both approches could be combined. I do not know how the scoring
and the whole BooleanQery works, I did only the merging of the API. If we have
consensus, that this may be good, I could remove the rest of deprecated
ConstantScoreQuery. The new code then works without any problems and backwards
compatible as before, but with no optimization.
Then Paul could adapt his patch to not create new methods to add Filter clauses
to BooleanQueries, but do just some difference in the whole BooleanQuery logic
like that:
if (clause.query instanceof Filter) { do only filter optimization from Paul's
patch } else { do conventional boolean scoring }
If he cannot do the optimization (because the Filter is alone in BooleanQuery)
he could just fall back to the standard query logic (that uses implicit the
current ConstantScoreQuery algorithm).
But before start implementing more for removing the deprecated class, I wanted
to hear some more ideas, maybe something completely different (like every query
can also automatically be a filter): Only one superclass "Query" no filter
anymore, every query clause can implement a filter and/or a query with always a
Fallback to the other side (if no filter implementation provided, a filter is
provided by a algorithm like QueryFilter; if no weight/rewrite, constant score
weight is provided).
Just ideas...
was (Author: thetaphi):
In my opinion, both approches could be combined. I do not know how the
scoring and the whole BooleanQery works, I did only the merging of the API. If
we have consensus, that this may be good, I could remove the rest of deprecated
ConstantScoreQuery. The merge then works without any problems and backwards
compatible.
Then Paul could adapt his patch to not create new methods to add Filter clauses
to boolean queries, but do just some difference like that:
if (clause.query instanceof Filter) { do only filter optimization } else { do
conventional boolean scoring }
If he cannot do the optimization (because the Filter is alone in BooleanQuery)
he could just fall back to the standard query logic (that uses implicit the
current ConstantScoreQuery algorithm).
But before start implementing more for removing the deprecated class, I wanted
to hear some more ideas, maybe something completely different (like every query
can also automatically be a filter): Only one superclass "Query" no filter
anymore, every query clause can implement a filter and/or a query with always a
Fallback to the other side (if no filter implementation provided, a filter is
provided by a algorithm like QueryFilter; if no weight/rewrite, constant score
weight is provided).
Just ideas...
> Merge Query and Filter classes
> ------------------------------
>
> Key: LUCENE-1518
> URL: https://issues.apache.org/jira/browse/LUCENE-1518
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Search
> Affects Versions: 2.4
> Reporter: Uwe Schindler
> Attachments: LUCENE-1518.patch
>
>
> This issue presents a patch, that merges Queries and Filters in a way, that
> the new Filter class extends Query. This would make it possible, to use every
> filter as a query.
> The new abstract filter class would contain all methods of
> ConstantScoreQuery, deprecate ConstantScoreQuery. If somebody implements the
> Filter's getDocIdSet()/bits() methods he has nothing more to do, he could
> just use the filter as a normal query.
> I do not want to completely convert Filters to ConstantScoreQueries. The idea
> is to combine Queries and Filters in such a way, that every Filter can
> automatically be used at all places where a Query can be used (e.g. also
> alone a search query without any other constraint). For that, the abstract
> Query methods must be implemented and return a "default" weight for Filters
> which is the current ConstantScore Logic. If the filter is used as a real
> filter (where the API wants a Filter), the getDocIdSet part could be directly
> used, the weight is useless (as it is currently, too). The constant score
> default implementation is only used when the Filter is used as a Query (e.g.
> as direct parameter to Searcher.search()). For the special case of
> BooleanQueries combining Filters and Queries the idea is, to optimize the
> BooleanQuery logic in such a way, that it detects if a BooleanClause is a
> Filter (using instanceof) and then directly uses the Filter API and not take
> the burden of the ConstantScoreQuery (see LUCENE-1345).
> Here some ideas how to implement Searcher.search() with Query and Filter:
> - User runs Searcher.search() using a Filter as the only parameter. As every
> Filter is also a ConstantScoreQuery, the query can be executed and returns
> score 1.0 for all matching documents.
> - User runs Searcher.search() using a Query as the only parameter: No change,
> all is the same as before
> - User runs Searcher.search() using a BooleanQuery as parameter: If the
> BooleanQuery does not contain a Query that is subclass of Filter (the new
> Filter) everything as usual. If the BooleanQuery only contains exactly one
> Filter and nothing else the Filter is used as a constant score query. If
> BooleanQuery contains clauses with Queries and Filters the new algorithm
> could be used: The queries are executed and the results filtered with the
> filters.
> For the user this has the main advantage: That he can construct his query
> using a simplified API without thinking about Filters oder Queries, you can
> just combine clauses together. The scorer/weight logic then identifies the
> cases to use the filter or the query weight API. Just like the query
> optimizer of a RDB.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscr...@lucene.apache.org
For additional commands, e-mail: java-dev-h...@lucene.apache.org
