preselectResult = null;

        LuceneIndexWorker index = (LuceneIndexWorker) context.getBroker().getIndexController().getWorkerByIndexId(LuceneIndex.ID);

        // DW: contextSequence can be null

        Item key = getKey(contextSequence, null);

        List<QName> qnames = new ArrayList<>(1);

        qnames.add(contextQName);

        Properties options = parseOptions(contextSequence, null);

        try {

            if (!(input instanceof VirtualNodeSet) && input.isEmpty())

                result = NodeSet.EMPTY_SET;

            else {

                NodeSet inNodes = input.toNodeSet();

                LuceneIndexWorker index = (LuceneIndexWorker)

                        context.getBroker().getIndexController().getWorkerByIndexId(LuceneIndex.ID);

                Item key = getKey(contextSequence, contextItem);

                List<QName> qnames = null;

                if (contextQName != null) {

        long start = System.currentTimeMillis();

        NGramIndexWorker index = (NGramIndexWorker) context.getBroker().getIndexController().getWorkerByIndexId(

            NGramIndex.ID);

        String key = getArgument(1).eval(contextSequence).getStringValue();

        List<QName> qnames = new ArrayList<QName>(1);

        qnames.add(contextQName);

        preselectResult = processMatches(index, docs, qnames, key, useContext ? contextSequence.toNodeSet() : null,

            NodeSet.DESCENDANT);

                result = NodeSet.EMPTY_SET;

            else {

                long start = System.currentTimeMillis();

                NodeSet inNodes = input.toNodeSet();

                NGramIndexWorker index = (NGramIndexWorker) context.getBroker().getIndexController()

                    .getWorkerByIndexId(NGramIndex.ID);

                //Alternate design

                // NGramIndexWorker index =

                // (NGramIndexWorker)context.getBroker().getBrokerPool().getIndexManager().getIndexById(NGramIndex.ID).getWorker();

        preselectResult = null;

        LuceneIndexWorker index = (LuceneIndexWorker)

                context.getBroker().getIndexController().getWorkerByIndexId(LuceneIndex.ID);

        String field = getArgument(0).eval(contextSequence).getStringValue();

        Item query = getKey(contextSequence, null);

        Properties options = parseOptions(contextSequence, null);

        try {

            if (Type.subTypeOf(query.getType(), Type.ELEMENT))

                preselectResult = index.queryField(context, getExpressionId(), docs, useContext ? contextSequence.toNodeSet() : null,

          String field = getArgument(0).eval(contextSequence).getStringValue();

         

          Item query = getKey(contextSequence, null);

         

          if (contextSequence == null)

            docs = context.getStaticallyKnownDocuments();

          else

                docs = contextSequence.getDocumentSet();

                {context.getProfiler().message(this, Profiler.START_SEQUENCES, "CONTEXT ITEM", contextItem.toSequence());}

        }

       

        // get statically known documents from the context

       

//        // document set

//        // TODO: disabled cache for now as it may cause concurrency issues

//        // better use compile-time inspection and maybe a pragma to mark those

//        // sections in the query that can be safely cached

//        if (cachedDocs != null && cachedDocs.equalDocs(ds)) return cached;

       

        // check if the loaded documents should remain locked

        NewArrayNodeSet result = new NewArrayNodeSet(2);

        try {

            // wait for pending updates

            if (!context.inProtectedMode())

          DocumentImpl doc;

              doc = i.next();

                if (context.inProtectedMode() && !context.getProtectedDocs().containsKey(doc.getDocId()))

                    {continue;}

                if(doc.getResourceType() == DocumentImpl.XML_FILE) {  // skip binary resources

                result.add(new NodeProxy(doc));

              }

            }

          cached = result;

          cachedDocs = ds;

        } catch (final LockException e) {

            throw new XPathException(this, "Failed to acquire lock on the context document set");

        } finally {

            // release all locks

            if (!context.inProtectedMode())

        }

        if (context.getProfiler().isEnabled())

            {context.getProfiler().end(this, "", result);}

       

                }

                //TODO: we still need a final decision about this. Also check base-uri.

                //if (result == Sequence.EMPTY_SEQUENCE)

                    //throw new XPathException(this, path + " is not an XML document");

                if (docs != null && DocumentSet.EMPTY_DOCUMENT_SET != docs) {

                    // only cache node sets (which have a non-empty document set)

                    registerUpdateListener();

                }

            } catch (final Exception e) {

    if(idrefval.isEmpty())

            {result = Sequence.EMPTY_SEQUENCE;}

        else {

        String nextId;

            if (getArgumentCount() == 2) {

                // second argument should be a node, whose owner document will be

                // searched for the id

                final Sequence nodes = getArgument(1).eval(contextSequence);

                if (nodes.isEmpty())

      if (args[0].isEmpty())

            {result = Sequence.EMPTY_SEQUENCE;}

      else {

          final NodeSet nodes = args[0].toNodeSet();

         

          if (this.getArgumentCount() == 3){

            final IndexWorker indexWorker = context.getBroker().getIndexController().getWorkerByIndexName(args[2].itemAt(0).getStringValue());

            //Alternate design

            //IndexWorker indexWorker = context.getBroker().getBrokerPool().getIndexManager().getIndexByName(args[2].itemAt(0).getStringValue()).getWorker();