throws Exception
{
SearchScope scope = searchContext.getScope();
Dn baseDn = searchContext.getDn();
AliasDerefMode aliasDerefMode = searchContext.getAliasDerefMode();
ExprNode filter = searchContext.getFilter();
// Compute the UUID of the baseDN entry
String baseId = db.getEntryId( baseDn );
// Prepare the instance containing the search result
PartitionSearchResult searchResult = new PartitionSearchResult( schemaManager );
Set<IndexEntry<String, String>> resultSet = new HashSet<IndexEntry<String, String>>();
// Check that we have an entry, otherwise we can immediately get out
if ( baseId == null )
{
if ( ( ( Partition ) db ).getSuffixDn().equals( baseDn ) )
{
// The context entry is not created yet, return an empty result
searchResult.setResultSet( resultSet );
return searchResult;
}
else
{
// The search base doesn't exist
throw new LdapNoSuchObjectException( I18n.err( I18n.ERR_648, baseDn ) );
}
}
// --------------------------------------------------------------------
// Determine the effective base with aliases
// --------------------------------------------------------------------
String aliasedBase = db.getAliasIndex().reverseLookup( baseId );
Dn effectiveBase = baseDn;
String effectiveBaseId = baseId;
if ( ( aliasedBase != null ) && aliasDerefMode.isDerefFindingBase() )
{
/*
* If the base is an alias and alias dereferencing does occur on
* finding the base, or always then we set the effective base to the alias target
* got from the alias index.
*/
effectiveBase = new Dn( schemaManager, aliasedBase );
effectiveBaseId = db.getEntryId( effectiveBase );
}
// --------------------------------------------------------------------
// Specifically Handle Object Level Scope
// --------------------------------------------------------------------
if ( scope == SearchScope.OBJECT )
{
IndexEntry<String, String> indexEntry = new IndexEntry<String, String>();
indexEntry.setId( effectiveBaseId );
// Fetch the entry, as we have only one
Entry entry = db.fetch( indexEntry.getId(), effectiveBase );
Evaluator<? extends ExprNode> evaluator = null;
if ( filter instanceof ObjectClassNode )
{
ScopeNode node = new ScopeNode( aliasDerefMode, effectiveBase, effectiveBaseId, scope );
evaluator = new BaseLevelScopeEvaluator<Entry>( db, node );
}
else
{
optimizer.annotate( filter );
evaluator = evaluatorBuilder.build( filter );
// Special case if the filter selects no candidate
if ( evaluator == null )
{
ScopeNode node = new ScopeNode( aliasDerefMode, effectiveBase, effectiveBaseId, scope );
evaluator = new BaseLevelScopeEvaluator<Entry>( db, node );
}
}
indexEntry.setEntry( entry );
resultSet.add( indexEntry );
searchResult.setEvaluator( evaluator );
searchResult.setResultSet( resultSet );
return searchResult;
}
// This is not a BaseObject scope search.
// Add the scope node using the effective base to the filter
ExprNode root = null;
if ( filter instanceof ObjectClassNode )
{
root = new ScopeNode( aliasDerefMode, effectiveBase, effectiveBaseId, scope );
}
else
{
root = new AndNode();
( ( AndNode ) root ).getChildren().add( filter );
ExprNode node = new ScopeNode( aliasDerefMode, effectiveBase, effectiveBaseId, scope );
( ( AndNode ) root ).getChildren().add( node );
}
// Annotate the node with the optimizer and return search enumeration.
optimizer.annotate( root );