IntersectionQueryOperation.java
| Index Score | ||
|---|---|---|
 |
 |
com.zimbra.cs.index |
 |
 |
Zimbra Collaboration Suite |
View: Reasons, Metrics, Source Code
These are the metrics that contribute to the Enerjy Score for this file, ranked by impact. So the metrics listed at the top influence the score to a greater extent that the metrics listed at the bottom.
| Metric | Description | |
|---|---|---|
| LINE_COMMENT | Number of line comments |  |
| LOOPS | Number of loops | |
| EXEC_COMMENTS | Comments in executable code | |
| SIZE | Size of the file in bytes | |
| RETURNS | Number of return points from functions | |
| BLOCKS | Number of blocks | |
| CYCLOMATIC | Cyclomatic complexity | |
| JAVA0082 | JAVA0082 Unnecessary widening cast | |
| COMPARISONS | Number of comparison operators | |
| LOGICAL_LINES | Number of statements | |
| OPERATORS | Number of operators | |
| JAVA0125 | JAVA0125 Continue statement with label | |
| EXITS | Procedure exits | |
| LINES | Number of lines in the source file | |
| PROGRAM_LENGTH | Halstead program length | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| LOC | Lines of code | |
| JAVA0254 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| NEST_DEPTH | Maximum nesting depth | |
| ELOC | Effective lines of code | |
| JAVA0039 | JAVA0039 Break statement with label | |
| OPERANDS | Number of operands | |
| COMMENTS | Comment lines | |
| JAVA0083 | JAVA0083 Unnecessary instanceof test | |
| JAVA0119 | JAVA0119 Control variable changed within body of for loop | |
| UNIQUE_OPERANDS | Number of unique operands | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
| JAVA0049 | JAVA0049 Nested block at depth N (maximum: M) | |
| FUNCTIONS | Number of function declarations | |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| UNIQUE_OPERATORS | Number of unique operators | |
| WHITESPACE | Number of whitespace lines | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0136 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0123 | JAVA0123 Use all three components of for loop | |
| JAVA0067 | JAVA0067 Array descriptor on identifier name | |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0270 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| JAVA0145 | JAVA0145 Tab character used in source file | |
/*
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 ("License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.zimbra.com/license
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* The Original Code is: Zimbra Collaboration Suite Server.
*
* The Initial Developer of the Original Code is Zimbra, Inc.
* Portions created by Zimbra are Copyright (C) 2004, 2005, 2006 Zimbra, Inc.
* All Rights Reserved.
*
* Contributor(s):
*
* ***** END LICENSE BLOCK *****
*/
/*
* Created on Oct 29, 2004
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package com.zimbra.cs.index;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import com.zimbra.cs.index.MailboxIndex.SortBy;
import com.zimbra.cs.mailbox.Mailbox;
import com.zimbra.common.service.ServiceException;
import com.zimbra.common.util.SetUtil;
import com.zimbra.common.util.Log;
import com.zimbra.common.util.LogFactory;
/*******************************************************************************
*
* IntersectionQueryOperation
*
* Set of query results ANDed together
*
******************************************************************************/
class IntersectionQueryOperation extends QueryOperation {
boolean noHits = false;
private static Log mLog = LogFactory.getLog(IntersectionQueryOperation.class);
/***************************************************************************
*
* Hits iteration
*
**************************************************************************/
public void resetIterator() throws ServiceException {
if (mLog.isDebugEnabled()) {
mLog.debug("Intersection.resetIterator()");
}
mBufferedNext.clear();
for (int i = 0; i < mMessageGrouper.length; i++) {
mMessageGrouper[i].resetIterator();
}
}
public ZimbraHit getNext() throws ServiceException {
if (noHits || !hasNext()) {
return null;
}
return (ZimbraHit) (mBufferedNext.remove(0));
}
ArrayList<ZimbraHit>mBufferedNext = new ArrayList<ZimbraHit>(1);
/**
* There can be multiple Hits with the same exact sort-field. This function does
* a complete N^2 intersection of all of the hits for a particular sort field.
*
* FIXME: this function is hideous, do _something_ with it.
*
* @throws ServiceException
*/
void bufferNextHits() throws ServiceException {
if (mBufferedNext.size() == 0) {
TryAgain: while (true)
{
if (!this.mMessageGrouper[0].bufferNextHits()) {
return;
}
if (mLog.isDebugEnabled()) {
mLog.debug("\nMsgGrp0: "+mMessageGrouper[0].toString());
}
ZimbraHit curHit = mMessageGrouper[0].getGroupHit();
int msgId = mMessageGrouper[0].getCurMsgId();
// for every other op, buffer all the hits for this
// step....
for (int i = 1; i < mMessageGrouper.length; i++)
{
//
// TODO check if this group is FINISHED and if so,
// quick return out
//
if (!(mMessageGrouper[i].bufferNextHits(curHit))) {
// no matches this grouper for that
// timestamp...go to top and try again
continue TryAgain;
}
if (mLog.isDebugEnabled()) {
mLog.debug("MsgGrp"+i+": "+ mMessageGrouper[i].toString());
}
}
ArrayList<Integer>seenMsgs = new ArrayList<Integer>();
do {
if (curHit != null && msgId > 0) {
// okay, do the big intersection
for (int i = 0; i < mMessageGrouper.length; i++) {
mMessageGrouper[i].setMsgId(msgId);
ZimbraHit hit = mMessageGrouper[i].getNextHit();
while (hit != null) {
if (!mBufferedNext.contains(hit)) {
boolean ok = true;
for (int j = 0; ok
&& j < mMessageGrouper.length; j++) {
if (j != i) {
if (hit instanceof MessageHit) {
if (!mMessageGrouper[j]
.intersectWithBuffer((MessageHit) hit)) {
ok = false;
}
} else if (hit instanceof MessagePartHit) {
if (!mMessageGrouper[j]
.intersectWithBuffer((MessagePartHit) hit)) {
ok = false;
}
}
}
} // intersect against every other group
if (ok) {
mBufferedNext.add(hit);
}
} // contained in mBufferedNext?
hit = mMessageGrouper[i].getNextHit();
} // for each hit within group
} // for each group
} // assuming the first one isn't empty
seenMsgs.add(new Integer(msgId));
msgId = mMessageGrouper[0].getNextMessageId(seenMsgs);
} while (msgId > 0);
if (mBufferedNext.size() > 0) {
// we've got some hits -- so we can leave now...
break TryAgain;
}
// no hits -- go back to the top and try again.
} // while true (for easy retry)
for (int i = 0; i < mBufferedNext.size(); i++) {
ZimbraHit hit = (ZimbraHit)(mBufferedNext.get(i));
if (mLog.isDebugEnabled()) {
mLog.debug("BUFFERED: "+hit.toString());
}
}
}
}
public ZimbraHit peekNext() throws ServiceException {
if (noHits) {
return null;
} else {
bufferNextHits();
if (mBufferedNext.size() > 0) {
return (ZimbraHit) (mBufferedNext.get(0));
} else {
return null;
}
}
}
public void doneWithSearchResults() throws ServiceException {
for (int i = 0; i < mQueryOperations.size(); i++) {
QueryOperation op = (QueryOperation) mQueryOperations.get(i);
op.doneWithSearchResults();
}
}
public ZimbraHit skipToHit(int hitNo) throws ServiceException {
if (noHits) {
return null;
}
return super.skipToHit(hitNo);
}
/**
* @author tim
*
* Responsible for grouping sub-results with the same sort value into a chunk
* so that they can then be combined
*
* 1) Call buffer() to buffer the next timestamp, or buffer(timestamp) to
* buffer a particular timestamp
*
* 2) Iterate through all the messageId's in the current timestamp
*
* 3) call getNextHit() to iterate the hits within the current message OR
* call intersectWithBuffer() to tell you if the a particular hit intersects
* with something within our buffer
*
* Note: this class is somewhat confusing because there are really two completely
* different paths through it: the first Grouper which gathers a bunch of hits and
* then is iterated using getNextHit() and then the other groupers which gather hits
* and then use intersectWithBuffer.....this is because we're using an N^2
* intersection instead of an insertion intersection.....this should be fixed.
*/
private static class HitGrouper {
private QueryOperation mSubOp = null;
private SortBy mSortOrder;
public String toString() {
StringBuffer toRet = new StringBuffer(mSubOp.toString()+"\n\t");
for (int i = 0; i < mBufferedHit.size(); i++) {
ZimbraHit hit = (ZimbraHit) (mBufferedHit.get(i));
toRet.append(hit.toString()).append("\n\t");
}
return toRet.toString();
}
HitGrouper(QueryOperation subOperation, SortBy sortOrder) {
mSubOp = subOperation;
mSortOrder = sortOrder;
}
void resetIterator() throws ServiceException {
mBufferedHit.clear();
mSubOp.resetIterator();
mCurMsgId = -1;
mGroupHit = null;
mCurBufPos = 0;
}
private ArrayList <ZimbraHit>mBufferedHit = new ArrayList<ZimbraHit>();
int getNextMessageId(ArrayList seenMsgs) throws ServiceException {
for (int i = 1; i < mBufferedHit.size(); i++) {
Integer checkId = new Integer(
((ZimbraHit) (mBufferedHit.get(i))).getItemId());
if (!seenMsgs.contains(checkId)) {
return checkId.intValue();
}
}
return -1;
}
/**
* Advance to the next timestamp and buffer one or more hits for that timestamp.
*
* @return
* @throws ServiceException
*/
boolean bufferNextHits() throws ServiceException {
mBufferedHit.clear();
//
// step 1: establish the current stamp
//
if (!mSubOp.hasNext()) {
return false;
}
mGroupHit = mSubOp.getNext();
setMsgId(mGroupHit.getItemId());
mBufferedHit.add(mGroupHit);
//
// step 2: buffer all hits with the current stamp
//
while (mSubOp.hasNext()) {
ZimbraHit hit = mSubOp.peekNext();
if (hit.compareBySortField(mSortOrder, mGroupHit) == 0) {
mBufferedHit.add(hit);
// go to next one:
ZimbraHit check = mSubOp.getNext();
assert (check == hit);
} else {
return !mBufferedHit.isEmpty();
}
}
return !mBufferedHit.isEmpty();
}
private int mCurMsgId = -1;
private ZimbraHit mGroupHit = null; /*
* ALL hits in this group will have the same
* sort-order as this one
*/
private int mCurBufPos = 0; // for iterating the current buffer
int getCurMsgId() {
return mCurMsgId;
}
/**
* Returns a hit from the current message group. This is useful because
* the hit's SORT FIELD is guaranteed to be the same as the sort field
* in every other hit in this group (that's what the Message Grouper
* does, after all)
*
* @return current hit
*/
ZimbraHit getGroupHit() {
return mGroupHit;
}
// ZimbraHit peekNext() {
// return mGroupHit;
// }
void setMsgId(int msgId) {
mCurMsgId = msgId;
mCurBufPos = 0;
}
ZimbraHit getNextHit() throws ServiceException {
while (mCurBufPos < mBufferedHit.size()) {
if (((ZimbraHit) mBufferedHit.get(mCurBufPos)).getItemId() == mCurMsgId) {
mCurBufPos++;
return (ZimbraHit) mBufferedHit.get(mCurBufPos - 1);
}
mCurBufPos++;
}
return null;
}
boolean intersectWithBuffer(MessageHit hit) throws ServiceException {
int hitMsgId = hit.getItemId();
for (int i = 0; i < mBufferedHit.size(); i++) {
if (((ZimbraHit) mBufferedHit.get(i)).getItemId() == hitMsgId) {
return true;
}
}
return false;
}
/**
* Return TRUE if passed-in Hit intersects with something within my group.
*
* @param hit
* @return
* @throws ServiceException
*/
boolean intersectWithBuffer(MessagePartHit hit) throws ServiceException {
int hitMsgId = hit.getItemId();
for (int i = 0; i < mBufferedHit.size(); i++) {
ZimbraHit bufHit = (ZimbraHit) mBufferedHit.get(i);
if (bufHit.getItemId() == hitMsgId) {
if (bufHit instanceof MessagePartHit) {
MessagePartHit mph = (MessagePartHit) bufHit;
if (mph == hit) {
return true;
}
} else {
// msgID's must be equal
return true;
}
}
}
return false;
}
/**
* Buffer a bunch of hits from SubOp, all hits must have a SortField
* EQUAL TO curHit's SortField
*
* @param curHit
* @return
* @throws ServiceException
*/
boolean bufferNextHits(ZimbraHit curHit) throws ServiceException {
mGroupHit = curHit;
mBufferedHit.clear();
if (!mSubOp.hasNext()) {
return false;
}
ZimbraHit newStamp = null;
while ((newStamp = mSubOp.peekNext()) != null) {
int result = newStamp.compareBySortField(mSortOrder, mGroupHit);
if (mLog.isDebugEnabled()) {
// System.out.println("...newstamp=\""+newStamp.toString()+" result="+result); //+"\n\t\t\tcurhit=\""+mGroupHit.toString()+"\" result="+result);
}
if (result == 0) {
mBufferedHit.add(newStamp);
// go to nex thit
ZimbraHit check = mSubOp.getNext();
assert (check == newStamp);
} else if (result < 0) {
// newstamp is logically "Before" current...skip it
// mNextHit = null;
mSubOp.getNext(); // skip next hit
} else {
// newstamp is after us. Current doesn't match, but don't
// skip newStamp,
// we might still get to it.
//mNextHit = newStamp;
return mBufferedHit.size() > 0;
}
// if (mSubOp.hasNext()) {
// newStamp = mSubOp.getNext();
// } else {
// newStamp = null;
// }
}
return mBufferedHit.size() > 0;
}
}
/***************************************************************************
*
* Internals
*
**************************************************************************/
/**
* a SORTED (sorted at add time) list of query operations which are ANDed together
*/
List<QueryOperation>mQueryOperations = null;
boolean hasSpamTrashSetting() {
boolean hasOne = false;
for (Iterator iter = mQueryOperations.iterator(); !hasOne
&& iter.hasNext();) {
QueryOperation op = (QueryOperation) iter.next();
hasOne = op.hasSpamTrashSetting();
}
return hasOne;
}
void forceHasSpamTrashSetting() {
assert(false); // not called, but if it were, it would go:
for (Iterator iter = mQueryOperations.iterator(); iter.hasNext();) {
QueryOperation op = (QueryOperation) iter.next();
op.forceHasSpamTrashSetting();
}
}
QueryTargetSet getQueryTargets() {
QueryTargetSet toRet = new QueryTargetSet();
for (Iterator qopIter = mQueryOperations.iterator(); qopIter.hasNext();)
{
toRet = ((QueryOperation)qopIter.next()).getQueryTargets();
// loop through rest of ops add to toRet if it is in every other set
while (qopIter.hasNext()) {
QueryTargetSet curSet = ((QueryOperation)qopIter.next()).getQueryTargets();
// so this gets wacky:
// -- If both sides have an UNSPECIFIED, then the result is
// (RHS union LHS) including UNSPECIFIED
// -- If only LHS has an UNSPECIFIED, then the result is (RHS)
// If RHS then the result is LHS
if (toRet.contains(QueryTarget.UNSPECIFIED)) {
if (curSet.contains(QueryTarget.UNSPECIFIED)) {
toRet = (QueryTargetSet)SetUtil.union(toRet, curSet);
} else {
toRet = curSet;
}
} else if (curSet.contains(QueryTarget.UNSPECIFIED)) {
// toRet stays as it is...
} else {
toRet = (QueryTargetSet)SetUtil.intersect(new QueryTargetSet(), toRet, curSet);
}
}
}
return toRet;
}
boolean hasNoResults() {
return false;
}
boolean hasAllResults() {
return false;
}
QueryOperation ensureSpamTrashSetting(Mailbox mbox, boolean includeTrash, boolean includeSpam) throws ServiceException {
// just tack it on -- presumably this will be combined in the optimize()
// step...
if (!hasSpamTrashSetting()) {
boolean addedOne = false;
// first, try to add it to the DB operations...Note that this is a bit of a
// heuristic hack here: We could conceivably push the trash/spam setting
// down onto ALL our subOps, and you could argue that would be faster...EXCEPT
// that we know that when we do the "ensure trash/spam" pushdown, it always
// becomes a DB op (only the DB knows the answer).....and soooooo, since most
// of the time when we've got a non-DBQueryOp child, there is NOT a DB operation
// already, pushing the trash/spam setting down would actually create most work.
for (Iterator iter = mQueryOperations.iterator(); iter.hasNext();) {
QueryOperation op = (QueryOperation) iter.next();
if (op instanceof DBQueryOperation) {
op.ensureSpamTrashSetting(mbox, includeTrash, includeSpam);
addedOne = true;
}
}
// okay, we had no DB operations below us...so just push it down to everyone
//
// hmmm....perhaps we should only be pushing it down to one operation here? That could
// very well be a bit faster....
if (!addedOne) {
// ensureSpamTrashSetting might very well return a new root node...so we need
// to build a new mQueryOperations list using the result of ensureSpamTrashSetting
List<QueryOperation> newList = new ArrayList<QueryOperation>();
for (QueryOperation op : mQueryOperations) {
newList.add(op.ensureSpamTrashSetting(mbox, includeTrash, includeSpam));
}
mQueryOperations = newList;
}
}
return this;
}
void addQueryOp(QueryOperation op) {
assert(op!=null);
if (mQueryOperations == null) {
mQueryOperations = new ArrayList<QueryOperation>();
}
mQueryOperations.add(op);
}
void addQueryOps(List<QueryOperation>ops) {
mQueryOperations.addAll(ops);
}
void pruneIncompatibleTargets(QueryTargetSet targets) {
for (QueryOperation op : mQueryOperations) {
if (op instanceof UnionQueryOperation) {
((UnionQueryOperation)op).pruneIncompatibleTargets(targets);
} else if (op instanceof IntersectionQueryOperation) {
assert(false); // shouldn't be here, should have optimized already
((IntersectionQueryOperation)op).pruneIncompatibleTargets(targets);
} else {
// do nothing, must be part of the right set
QueryTargetSet qts = op.getQueryTargets();
assert(qts.size() == 1);
assert(qts.contains(QueryTarget.UNSPECIFIED) || qts.isSubset(targets));
}
}
}
/**
* If this is set, then we always transform
* a AND (b OR c)
* into
* (a AND b) OR (a AND c)
*
* If b or c have different targets (servers they execute on) then we *must* distribute
* but otherwise we have a choice.
*
* Tim: setting this to ALWAYS for now. I think in most cases it will be a win, even
* though it appears to create 4 executable terms instead of 3. It will be a win
* because (from the example above) in the 2nd case, it is almost certain that one both
* terms will combine thereby reducing the number of operations to 3 with no ANDs,
* which is always faster.
*
* The ideal solution would be to try both ways and compare the final # of executable
* ops. TODO, maybe.
*
*/
private static final boolean ALWAYS_DISTRIBUTE_AND_OVER_OR = true;
QueryOperation optimize(Mailbox mbox) throws ServiceException
{
//
// Step 1: optimize each individual sub-operation we have
//
restartSubOpt: do {
for (Iterator iter = mQueryOperations.iterator(); iter.hasNext();) {
QueryOperation q = (QueryOperation) iter.next();
QueryOperation newQ = q.optimize(mbox);
if (newQ != q) {
iter.remove();
if (newQ != null) {
addQueryOp(newQ);
}
continue restartSubOpt;
}
}
break;
} while (true);
// if all of our sub-ops optimized-away, then we're golden!
if (mQueryOperations.size() == 0) {
return new NoTermQueryOperation();
}
//
// Step 2: do an N^2 combine() of all of our subops
//
outer: do {
for (int i = 0; i < mQueryOperations.size(); i++) {
QueryOperation lhs = (QueryOperation) mQueryOperations.get(i);
// if one of our direct children is an and, then promote all of
// its elements to our level -- this can happen if a subquery has
// ANDed terms at the top level
if (lhs instanceof IntersectionQueryOperation) {
combineOps(lhs, false);
mQueryOperations.remove(i);
continue outer;
}
for (int j = i + 1; j < mQueryOperations.size(); j++) {
QueryOperation rhs = (QueryOperation) mQueryOperations.get(j);
QueryOperation joined = lhs.combineOps(rhs, false);
if (joined != null) {
mQueryOperations.remove(j);
mQueryOperations.remove(i);
addQueryOp(joined);
continue outer;
}
}
}
break outer;
} while (true);
//
// Step 2.5: now we want to eliminate any subtrees that have query targets
// which aren't compatible (ie (AorBorC) and (BorC) means we elim A
//
QueryTargetSet targets = getQueryTargets();
if (targets.size() == 0) {
mLog.debug("ELIMINATING "+toString()+" b/c of incompatible QueryTargets");
return new NullQueryOperation();
}
pruneIncompatibleTargets(targets);
//
// Step 2.6
//
// incompat targets are pruned, now distribute as necessary
//
// at this point we can assume that all the invalid targets have been pruned
//
// We only have to distribute if there is more than one explicit target,
// otherwise we know we can be executed on one server so we're golden.
//
if (ALWAYS_DISTRIBUTE_AND_OVER_OR || targets.size() > 1) {
int distributeLhs = -1;
for (int i = 0; i < mQueryOperations.size(); i++) {
QueryOperation lhs = (QueryOperation) mQueryOperations.get(i);
if ((ALWAYS_DISTRIBUTE_AND_OVER_OR && lhs instanceof UnionQueryOperation)
|| (lhs.getQueryTargets().size() > 1)) {
// need to distribute!
distributeLhs = i;
break;
}
}
if (distributeLhs >= 0) {
// if lhs has >1 explicit target at this point, it MUST be a union...
UnionQueryOperation lhs = (UnionQueryOperation)(mQueryOperations.remove(distributeLhs));
assert(lhs instanceof UnionQueryOperation);
UnionQueryOperation topOp = new UnionQueryOperation();
for (QueryOperation lhsCur : lhs.mQueryOperations)
{
IntersectionQueryOperation newAnd = new IntersectionQueryOperation();
topOp.add(newAnd);
newAnd.addQueryOp(lhsCur);
for (QueryOperation rhsCur : mQueryOperations) {
newAnd.addQueryOp((QueryOperation)(rhsCur.clone()));
}
}
// recurse!
return topOp.optimize(mbox);
}
}
// at this point, we know that the entire query has one and only one QueryTarget.
assert(getQueryTargets().countExplicitTargets() <= 1);
//
// Step 3: hacky special case for Lucene Ops and DB Ops: Lucene and DB don't
// combine() like other operations -- if they did, then we'd run the risk of
// failing to combine OR'ed Lucene terms (OR'ed DB terms don't combine) -- instead
// we wait until here to combine those terms. Weird, but functional.
//
// WARNING: Lucene ops ALWAYS combine, so we assume there is only one!
{
LuceneQueryOperation lop = null;
for (Iterator iter = mQueryOperations.iterator(); iter.hasNext();) {
QueryOperation op = (QueryOperation) iter.next();
if (op instanceof LuceneQueryOperation) {
lop = (LuceneQueryOperation)op;
iter.remove();
break;
}
}
if (lop != null) {
boolean foundIt = false;
for (Iterator iter = mQueryOperations.iterator(); iter.hasNext();) {
QueryOperation op = (QueryOperation) iter.next();
if (op instanceof DBQueryOperation) {
((DBQueryOperation)op).addLuceneOp(lop);
foundIt = true;
}
}
if (!foundIt) {
// add the lucene op back in!
addQueryOp(lop);
}
}
}
// now - check to see if we have only one child -- if so, then WE can be
// eliminated, so push the child up
if (mQueryOperations.size() == 1) {
return (QueryOperation) mQueryOperations.get(0);
}
return this;
}
String toQueryString() {
StringBuilder ret = new StringBuilder("(");
boolean atFirst = true;
for (QueryOperation op : mQueryOperations) {
if (!atFirst)
ret.append(" AND ");
ret.append(op.toQueryString());
atFirst = false;
}
ret.append(')');
return ret.toString();
}
public String toString() {
StringBuilder retval = new StringBuilder("INTERSECTION[");
boolean atFirst = true;
for (Iterator iter = mQueryOperations.iterator(); iter.hasNext();) {
QueryOperation op = (QueryOperation) iter.next();
if (atFirst)
atFirst = false;
else
retval.append(" AND ");
retval.append(op.toString());
}
retval.append("]");
return retval.toString();
}
public Object clone() {
IntersectionQueryOperation toRet = (IntersectionQueryOperation)super.clone();
assert(mMessageGrouper == null);
toRet.mBufferedNext = new ArrayList<ZimbraHit>(1);
toRet.mQueryOperations = new ArrayList<QueryOperation>(mQueryOperations.size());
for (QueryOperation q : mQueryOperations)
toRet.mQueryOperations.add(q);
return toRet;
}
protected QueryOperation combineOps(QueryOperation other, boolean union) {
if (!union && other instanceof IntersectionQueryOperation) {
addQueryOps(((IntersectionQueryOperation) other).mQueryOperations);
return this;
}
return null;
}
private HitGrouper mMessageGrouper[] = null;
protected void prepare(Mailbox mbx, ZimbraQueryResultsImpl res,
MailboxIndex mbidx, SearchParams params, int chunkSize) throws ServiceException, IOException {
// scale up the chunk size since we are doing an intersection...
chunkSize = (chunkSize+1) * 3;
mParams = params;
mMessageGrouper = new HitGrouper[mQueryOperations.size()];
this.setupResults(mbx, res);
for (int i = 0; i < mQueryOperations.size(); i++) {
QueryOperation op = (QueryOperation) mQueryOperations.get(i);
op.prepare(mbx, res, mbidx, params, chunkSize);
mMessageGrouper[i] = new HitGrouper(op, res.getSortBy());
if (!op.hasNext()) {
//
// This operation has no terms at all. Since we're an
// Intersection query, that means that
// this entire query has no results. Sooo, lets release all of
// the operations we've already
// prepare()d and create a single operation, a
// NullQueryOperation below us.
//
if (mLog.isDebugEnabled()) {
mLog.debug("*Dropping out of intersect query since we got to 0 results on execution "
+ Integer.toString(i + 1)
+ " out of "
+ mQueryOperations.size());
}
// first, we need to be DONE with all unused query operations..
for (int j = 0; j <= i; j++) {
((QueryOperation) mQueryOperations.get(j))
.doneWithSearchResults();
}
mQueryOperations.clear();
mMessageGrouper = new HitGrouper[1];
QueryOperation nullOp = new NullQueryOperation();
addQueryOp(nullOp);
mMessageGrouper[0] = new HitGrouper(nullOp, res
.getSortBy());
return;
}
}
}
public List<QueryInfo> getResultInfo() {
List<QueryInfo> toRet = new ArrayList<QueryInfo>();
for (QueryOperation op : mQueryOperations) {
toRet.addAll(op.getResultInfo());
}
return toRet;
}
public int estimateResultSize() throws ServiceException {
if (mQueryOperations.size() == 0)
return 0;
int maxValue = Integer.MAX_VALUE;
for (QueryOperation qop : mQueryOperations) {
// assume half of the entries match?
maxValue = Math.min(maxValue, qop.estimateResultSize())/2;
}
return maxValue;
}
}
The table below shows all metrics for IntersectionQueryOperation.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 141.00 | Number of blocks | |
| BLOCK_COMMENT | 33.00 | Number of block comment lines | |
| COMMENTS | 237.00 | Comment lines | |
| COMMENT_DENSITY | 0.59 | Comment density | |
| COMPARISONS | 92.00 | Number of comparison operators | |
| CYCLOMATIC | 134.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 14.00 | Comments in declarations | |
| DOC_COMMENT | 97.00 | Number of javadoc comment lines | |
| ELOC | 404.00 | Effective lines of code | |
| EXEC_COMMENTS | 41.00 | Comments in executable code | |
| EXITS | 84.00 | Procedure exits | |
| FUNCTIONS | 35.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 104.42 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 115.00 | Interface complexity | |
| JAVA0001 | 0.00 | JAVA0001 Package name does not contain only lower case letters | |
| JAVA0002 | 0.00 | JAVA0002 Package name does not begin with a top level domain name or country code | |
| JAVA0003 | 0.00 | JAVA0003 Minimize use of on-demand (.*) imports | |
| JAVA0004 | 0.00 | JAVA0004 Unnecessary import from java.lang | |
| JAVA0005 | 1.00 | JAVA0005 Imports not in specified order | |
| JAVA0006 | 0.00 | JAVA0006 Empty finally block | |
| JAVA0007 | 0.00 | JAVA0007 Should not declare public field | |
| JAVA0008 | 0.00 | JAVA0008 Empty catch block | |
| JAVA0009 | 0.00 | JAVA0009 Protected member in final class | |
| JAVA0010 | 0.00 | JAVA0010 Non-instantiable class does not contain a non-private static member | |
| JAVA0011 | 0.00 | JAVA0011 Abstract class does not contain an abstract method | |
| JAVA0012 | 0.00 | JAVA0012 Non-constructor method with same name as declaring class | |
| JAVA0013 | 0.00 | JAVA0013 Non-blank final field is not static | |
| JAVA0014 | 0.00 | JAVA0014 Class with only static members has non-private constructor | |
| JAVA0015 | 0.00 | JAVA0015 Package class contains public nested type | |
| JAVA0016 | 0.00 | JAVA0016 Abstract class contains public constructor | |
| JAVA0017 | 0.00 | JAVA0017 Class name does not have required form | |
| JAVA0018 | 0.00 | JAVA0018 Method name does not have required form | |
| JAVA0019 | 0.00 | JAVA0019 Interface name does not have required form | |
| JAVA0020 | 0.00 | JAVA0020 Field name does not have required form | |
| JAVA0021 | 0.00 | JAVA0021 Interface method name does not have required form | |
| JAVA0022 | 0.00 | JAVA0022 Static final field name does not have required form | |
| JAVA0023 | 0.00 | JAVA0023 Empty finalize method | |
| JAVA0024 | 0.00 | JAVA0024 Empty class | |
| JAVA0025 | 0.00 | JAVA0025 Method override is empty | |
| JAVA0026 | 0.00 | JAVA0026 Finalize method with parameters | |
| JAVA0029 | 0.00 | JAVA0029 Private method not used | |
| JAVA0030 | 0.00 | JAVA0030 Private field not used | |
| JAVA0031 | 0.00 | JAVA0031 Case statement not properly closed | |
| JAVA0032 | 0.00 | JAVA0032 Switch statement missing default | |
| JAVA0033 | 0.00 | JAVA0033 default: not last case in switch statement | |
| JAVA0034 | 4.00 | JAVA0034 Missing braces in if statement | |
| JAVA0035 | 0.00 | JAVA0035 Missing braces in for statement | |
| JAVA0036 | 0.00 | JAVA0036 Missing braces in while statement | |
| JAVA0038 | 0.00 | JAVA0038 Non-case label in switch statement | |
| JAVA0039 | 2.00 | JAVA0039 Break statement with label | |
| JAVA0040 | 0.00 | JAVA0040 Switch statement contains N cases (maximum: M) | |
| JAVA0041 | 0.00 | JAVA0041 Nested synchronized block | |
| JAVA0042 | 0.00 | JAVA0042 Empty synchronized statement | |
| JAVA0043 | 0.00 | JAVA0043 Inner class does not use outer class | |
| JAVA0044 | 0.00 | JAVA0044 Serializable class with no instance variables | |
| JAVA0045 | 0.00 | JAVA0045 Serializable class with only transient fields | |
| JAVA0046 | 0.00 | JAVA0046 Name of class not derived from Exception ends with 'Exception' | |
| JAVA0047 | 0.00 | JAVA0047 Serializable class derives from invalid base class | |
| JAVA0048 | 0.00 | JAVA0048 Name of class derived from Exception does not end with 'Exception' | |
| JAVA0049 | 3.00 | JAVA0049 Nested block at depth N (maximum: M) | |
| JAVA0050 | 0.00 | JAVA0050 Class derives from java.lang.Error | |
| JAVA0051 | 0.00 | JAVA0051 Class derives from java.lang.RuntimeException | |
| JAVA0052 | 0.00 | JAVA0052 Class derives from java.lang.Throwable | |
| JAVA0053 | 0.00 | JAVA0053 Unused label | |
| JAVA0054 | 0.00 | JAVA0054 Inheritance depth N exceeds maximum M | |
| JAVA0055 | 0.00 | JAVA0055 Class should be interface | |
| JAVA0056 | 0.00 | JAVA0056 Unnecessary abstract modifier for interface or annotation | |
| JAVA0057 | 0.00 | JAVA0057 Unnecessary default constructor | |
| JAVA0058 | 0.00 | JAVA0058 Constructor calls super() | |
| JAVA0059 | 0.00 | JAVA0059 Method override only calls super() | |
| JAVA0061 | 0.00 | JAVA0061 Inaccessible member in anonymous class | |
| JAVA0062 | 0.00 | JAVA0062 Public class missing public member or protected constructor | |
| JAVA0063 | 0.00 | JAVA0063 Identifier name should not contain '$' | |
| JAVA0064 | 0.00 | JAVA0064 N variations of identifier name (maximum: M) | |
| JAVA0065 | 0.00 | JAVA0065 Unnecessary final modifier for method in final class | |
| JAVA0066 | 0.00 | JAVA0066 Unnecessary modifier for interface nested type | |
| JAVA0067 | 1.00 | JAVA0067 Array descriptor on identifier name | |
| JAVA0068 | 0.00 | JAVA0068 Modifiers not declared in recommended order | |
| JAVA0071 | 0.00 | JAVA0071 Strings compared with == | |
| JAVA0073 | 0.00 | JAVA0073 Integer division in floating-point context | |
| JAVA0074 | 0.00 | JAVA0074 Use of Object.notify() | |
| JAVA0075 | 0.00 | JAVA0075 Method parameter hides field | |
| JAVA0076 | 0.00 | JAVA0076 Use of magic number | |
| JAVA0077 | 0.00 | JAVA0077 Private field not used in declaring class | |
| JAVA0078 | 0.00 | JAVA0078 Floating point values compared with == | |
| JAVA0079 | 0.00 | JAVA0079 Use of instance to reference static member | |
| JAVA0080 | 0.00 | JAVA0080 Import declaration not used | |
| JAVA0081 | 0.00 | JAVA0081 Boolean literal in comparison | |
| JAVA0082 | 16.00 | JAVA0082 Unnecessary widening cast | |
| JAVA0083 | 1.00 | JAVA0083 Unnecessary instanceof test | |
| JAVA0084 | 0.00 | JAVA0084 Should use compound assignment operator | |
| JAVA0085 | 0.00 | JAVA0085 Use of sun.* class | |
| JAVA0087 | 0.00 | JAVA0087 Use of Thread.sleep() | |
| JAVA0089 | 0.00 | JAVA0089 Use of restricted package | |
| JAVA0092 | 0.00 | JAVA0092 Use of restricted type | |
| JAVA0093 | 0.00 | JAVA0093 Redundant assignment | |
| JAVA0094 | 0.00 | JAVA0094 Field hides a superclass field | |
| JAVA0095 | 0.00 | JAVA0095 Uninitialized private field | |
| JAVA0096 | 0.00 | JAVA0096 Field in nested class hides outer field | |
| JAVA0098 | 0.00 | JAVA0098 Minimize use of implicit field initializers | |
| JAVA0100 | 0.00 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0101 | 0.00 | JAVA0101 Unnecessary modifier for field in interface | |
| JAVA0102 | 0.00 | JAVA0102 Last statement in finalize() not super.finalize() | |
| JAVA0103 | 0.00 | JAVA0103 Explicit call to finalize() | |
| JAVA0104 | 0.00 | JAVA0104 finalize() only calls super.finalize() | |
| JAVA0105 | 0.00 | JAVA0105 Duplicate import declaration | |
| JAVA0106 | 0.00 | JAVA0106 Unnecessary import from current package | |
| JAVA0108 | 0.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 0.00 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0111 | 0.00 | JAVA0111 Incorrect javadoc: @return tag for void method | |
| JAVA0112 | 0.00 | JAVA0112 Incorrect javadoc: no exception 'exception' in throws | |
| JAVA0113 | 1.00 | JAVA0113 Incorrect javadoc: no @author tag | |
| JAVA0114 | 1.00 | JAVA0114 Incorrect javadoc: no @version tag | |
| JAVA0115 | 1.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 0.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 0.00 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0118 | 0.00 | JAVA0118 Missing javadoc: type 'type' | |
| JAVA0119 | 3.00 | JAVA0119 Control variable changed within body of for loop | |
| JAVA0123 | 1.00 | JAVA0123 Use all three components of for loop | |
| JAVA0125 | 4.00 | JAVA0125 Continue statement with label | |
| JAVA0126 | 0.00 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0128 | 0.00 | JAVA0128 Public constructor in non-public class | |
| JAVA0130 | 0.00 | JAVA0130 Non-static method does not use instance fields | |
| JAVA0131 | 0.00 | JAVA0131 Compatible method does not override base | |
| JAVA0132 | 0.00 | JAVA0132 Method overload with compatible signature | |
| JAVA0133 | 0.00 | JAVA0133 Non-synchronized method overrides synchronized method | |
| JAVA0135 | 0.00 | JAVA0135 Only one of Object.equals and Object.hashCode defined: missing 'method' | |
| JAVA0136 | 1.00 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0137 | 0.00 | JAVA0137 Non-abstract class missing constructor | |
| JAVA0138 | 0.00 | JAVA0138 N parameters defined for method (maximum: M) | |
| JAVA0139 | 0.00 | JAVA0139 Definition of main other than public static void main(java.lang.String[]) | |
| JAVA0141 | 0.00 | JAVA0141 Unnecessary modifier for method in interface | |
| JAVA0143 | 0.00 | JAVA0143 Synchronized method | |
| JAVA0144 | 1.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 4.00 | JAVA0145 Tab character used in source file | |
| JAVA0150 | 0.00 | JAVA0150 java.lang.Error (or subclass) thrown | |
| JAVA0153 | 0.00 | JAVA0153 Inefficient conversion of integer to string | |
| JAVA0159 | 0.00 | JAVA0159 Inefficient conversion of string to integer | |
| JAVA0160 | 0.00 | JAVA0160 Method does not throw specified exception | |
| JAVA0161 | 0.00 | JAVA0161 Conditional wait() not in loop | |
| JAVA0163 | 0.00 | JAVA0163 Empty statement | |
| JAVA0165 | 0.00 | JAVA0165 Conflicting return statement in finally block | |
| JAVA0166 | 0.00 | JAVA0166 Generic exception caught | |
| JAVA0167 | 0.00 | JAVA0167 ThreadDeath not rethrown | |
| JAVA0169 | 0.00 | JAVA0169 Unnecessary catch block: exception 'exception' | |
| JAVA0170 | 0.00 | JAVA0170 Caught exception not derived from java.lang.Exception | |
| JAVA0171 | 0.00 | JAVA0171 Unused local variable | |
| JAVA0173 | 0.00 | JAVA0173 Unused method parameter | |
| JAVA0174 | 0.00 | JAVA0174 Assigned local variable never used | |
| JAVA0175 | 0.00 | JAVA0175 Successive assignment to variable | |
| JAVA0176 | 0.00 | JAVA0176 Local variable name does not have required form | |
| JAVA0177 | 0.00 | JAVA0177 Variable declaration missing initializer | |
| JAVA0179 | 0.00 | JAVA0179 Local variable hides visible field | |
| JAVA0233 | 0.00 | JAVA0233 Definition of serialVersionUID other than 'private static final long serialVersionUID' | |
| JAVA0234 | 0.00 | JAVA0234 Class is Serializable but does not define serialVersionUID | |
| JAVA0235 | 0.00 | JAVA0235 Class defines serialVersionUID but does not implement Serializable | |
| JAVA0236 | 0.00 | JAVA0236 Attempt to clone an object which does not implement Cloneable | |
| JAVA0237 | 0.00 | JAVA0237 Class implements Cloneable but does not have public clone method | |
| JAVA0238 | 0.00 | JAVA0238 Clone method does not call super.clone() | |
| JAVA0239 | 0.00 | JAVA0239 Class declares 'readObject' or 'writeObject' but does not implement Serializable | |
| JAVA0240 | 0.00 | JAVA0240 Serializable class which declares readObject or writeObject but not both | |
| JAVA0241 | 0.00 | JAVA0241 'readObject' or 'writeObject' should be declared private in Serializable class | |
| JAVA0242 | 0.00 | JAVA0242 Transient field in non-Serializable class | |
| JAVA0243 | 0.00 | JAVA0243 'readResolve' or 'writeReplace' should be declared private or protected | |
| JAVA0244 | 0.00 | JAVA0244 Field or method name in subclass differs only by case from inherited field or method | |
| JAVA0245 | 0.00 | JAVA0245 JUnit TestCase with non-trivial constructor | |
| JAVA0246 | 0.00 | JAVA0246 JUnit assertXXX statement missing message parameter | |
| JAVA0247 | 0.00 | JAVA0247 JUnit 'setUp()' and 'tearDown()' should call super method | |
| JAVA0248 | 0.00 | JAVA0248 JUnit method 'setUp' or 'tearDown' with incorrect signature | |
| JAVA0249 | 0.00 | JAVA0249 JUnit TestCase 'suite()' should be declared static | |
| JAVA0250 | 0.00 | JAVA0250 JUnit TestCase declares testXXX method with incorrect signature | |
| JAVA0251 | 0.00 | JAVA0251 Use '%n' for line breaks in printf/format for platform independence | |
| JAVA0252 | 0.00 | JAVA0252 'enum' is a Java 1.5 reserved word | |
| JAVA0253 | 0.00 | JAVA0253 Not all enum constants consumed in switch statement | |
| JAVA0254 | 5.00 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0255 | 0.00 | JAVA0255 Result of method invocation not used | |
| JAVA0256 | 0.00 | JAVA0256 Assignment of external collection/array to field | |
| JAVA0257 | 0.00 | JAVA0257 Use of 'Constant Interface' anti-pattern | |
| JAVA0258 | 0.00 | JAVA0258 Implement Iterable for foreach compatibility | |
| JAVA0259 | 0.00 | JAVA0259 Return of collection/array field | |
| JAVA0260 | 0.00 | JAVA0260 Use 'enum' instead of Enumerated Type pattern | |
| JAVA0261 | 0.00 | JAVA0261 Use specialized Enum collection types | |
| JAVA0262 | 0.00 | JAVA0262 Use of char in integer context | |
| JAVA0263 | 0.00 | JAVA0263 Long literal ends with 'l' instead of 'L' | |
| JAVA0264 | 0.00 | JAVA0264 Integer math in long context - check for overflow | |
| JAVA0265 | 0.00 | JAVA0265 Use of Throwable.printStackTrace() | |
| JAVA0266 | 0.00 | JAVA0266 Use of System.out | |
| JAVA0267 | 0.00 | JAVA0267 Use of System.err | |
| JAVA0269 | 0.00 | JAVA0269 Contents of StringBuffer never used | |
| JAVA0270 | 1.00 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| JAVA0271 | 0.00 | JAVA0271 Minimize use of on-demand (.*) static imports | |
| JAVA0272 | 0.00 | JAVA0272 Thread.run() called | |
| JAVA0273 | 0.00 | JAVA0273 Non-final derivative of Thread calls start() in constructor | |
| JAVA0274 | 0.00 | JAVA0274 Serializable class has a synchronized readObject() | |
| JAVA0275 | 0.00 | JAVA0275 Serializable class has a synchronized writeObject() and no other synchronized methods | |
| JAVA0276 | 0.00 | JAVA0276 Unnecessary use of String constructor | |
| JAVA0277 | 0.00 | JAVA0277 Iterator.next() implementation does not throw NoSuchElementException | |
| JAVA0278 | 0.00 | JAVA0278 Unnecessary use of Boolean constructor | |
| JAVA0279 | 0.00 | JAVA0279 Serialization method readObject or readObjectNoData calls an overridable method | |
| JAVA0280 | 0.00 | JAVA0280 IllegalMonitorStateException caught | |
| JAVA0281 | 0.00 | JAVA0281 Iterator.next() not called in loop | |
| JAVA0282 | 0.00 | JAVA0282 Call to Iterator.next() in loop which does not test Iterator.hasNext() | |
| JAVA0283 | 0.00 | JAVA0283 Control variable not updated in loop body | |
| JAVA0284 | 0.00 | JAVA0284 Explicit garbage collection | |
| JAVA0285 | 0.00 | JAVA0285 Dereference of potentially null variable | |
| JAVA0286 | 0.00 | JAVA0286 Dereference of null variable | |
| JAVA0287 | 0.00 | JAVA0287 Unnecessary null check | |
| JAVA0288 | 0.00 | JAVA0288 Inconsistent null check | |
| LINES | 891.00 | Number of lines in the source file | |
| LINE_COMMENT | 107.00 | Number of line comments | |
| LOC | 531.00 | Lines of code | |
| LOGICAL_LINES | 284.00 | Number of statements | |
| LOOPS | 32.00 | Number of loops | |
| NEST_DEPTH | 12.00 | Maximum nesting depth | |
| OPERANDS | 1137.00 | Number of operands | |
| OPERATORS | 2426.00 | Number of operators | |
| PARAMS | 22.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 3563.00 | Halstead program length | |
| PROGRAM_VOCAB | 348.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 93.00 | Number of return points from functions | |
| SIZE | 32720.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 294.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 54.00 | Number of unique operators | |
| WHITESPACE | 123.00 | Number of whitespace lines | |