void ResultCollectorImpl::collect(const QueryResult& queryResults)
{
    if (queryResults.hasError())
    {
        m_result.setError(m_result.getErrorMsg() + queryResults.getErrorMsg());
    }
    else
    {
        m_result.setTotalHits(m_result.getTotalHits() + queryResults.getTotalHits());
        if (queryResults.getTimeCost() > m_result.getTimeCost())
        {
            m_result.setTimeCost(queryResults.getTimeCost());
        }

        shardid_t shardId = -1;
        QueryResult::Iterator it = queryResults.iterator();
        while (it.hasNext())
        {
            const ResultDocPtr& pDoc = it.next();
            m_pResultQueue->insert(pDoc);
            shardId = pDoc->getShardId();
        }
        
        const QueryTracerPtr& pTracer = queryResults.getTracer();
        if (pTracer.isNotNull())
        {
            if (m_result.getTracer().isNull())
            {
                m_result.setTracer(new QueryTracer("proxy", pTracer->getLevel()));
            }
            QueryTracerPtr& pResTracer = m_result.getTracer();
            string str;
            NumberFormatter::append(str, shardId);
            pResTracer->addChildTracer(pTracer)->prependPath(str);
        }
    }
}
void SearchShardsBase::collectPhaseTwoResult()
{
    FX_DEBUG("Collect phase two result");

    SEARCH_LATENCY_BEGIN();

    QueryResult phaseTwoResult;
    const QueryResult& qResult = m_pResultCollector->getResult();
    phaseTwoResult.setTracer(qResult.getTracer());

    int64_t nMaxTimeCost = 0;
    m_shardResults.clear();
    for (size_t i = 0; i < m_requestedShards.size(); ++i)
    {
        SearchShardBase* pShard = m_requestedShards[i];
        const string& sResult = pShard->getResponse();
        if (pShard->getStatus() != SearchReplicaBase::EC_OK)
        {
            stringstream ss;
            ss << "Has error on shard: [" << pShard->getName() 
               << "]: " << parseError(sResult);

            FX_LOG(ERROR, ss.str().c_str());
            setError(ss.str());
            SEARCH_LATENCY_END(m_nPhaseTwoCollectLatency);
            return;
        }

        FX_TRACE("Phase2 result: [%s]", sResult.c_str());

        XMLResultParser parser;
        QueryResultPtr& pTmpQRes = m_shardResults[pShard->getShardId()].second;
        parser.parse(sResult, *(pTmpQRes));
        if (pTmpQRes->getTimeCost() > nMaxTimeCost)
        {
            nMaxTimeCost = pTmpQRes->getTimeCost();
        }

        // merge trace information
        QueryTracerPtr& pTracer = pTmpQRes->getTracer();
        if (pTracer.isNotNull())
        {
            if (phaseTwoResult.getTracer().isNull())
            {
                phaseTwoResult.setTracer(new QueryTracer("proxy", pTracer->getLevel()));
            }
            string str;
            NumberFormatter::append(str, pShard->getShardId());
            phaseTwoResult.getTracer()->addChildTracer(pTracer)->prependPath(str);
        }
    }

    // Merge hit docs
    phaseTwoResult.setTotalHits(qResult.getTotalHits());
    phaseTwoResult.setTimeCost(nMaxTimeCost + qResult.getTimeCost());
    QueryResult::Iterator it = qResult.iterator();
    while (it.hasNext())
    {
        const ResultDocPtr& pDoc = it.next();
        shardid_t shardId = pDoc->getShardId();
        FIRTEX_ASSERT2((size_t)shardId <= m_shards.size());
        
        ResultPair& resPair = m_shardResults[shardId];
        QueryResultPtr& pQResult2 = resPair.second;
        if (pQResult2->hasError())
        {
            FX_LOG(ERROR, "Has error on shard: [%d], msg: [%s]",
                   pQResult2->getErrorMsg().c_str());
            phaseTwoResult.setError(pQResult2->getErrorMsg());
            break;
        }
        ResultDocPtr& pDoc2 = (*pQResult2)[resPair.first++];
        pDoc2->setScore(pDoc->getScore());
        phaseTwoResult.addDoc(pDoc2);
    }

    SEARCH_LATENCY_END(m_nPhaseTwoCollectLatency);

    // Add query trace information
    QueryTracerPtr& pResTracer = phaseTwoResult.getTracer();
    if (pResTracer.isNotNull())
    {
        FX_QUERY_TRACE(DEBUG, pResTracer, "Phase one search latency: [%d] ms",
                       m_nPhaseOneLatency);
        FX_QUERY_TRACE(DEBUG, pResTracer, "Phase one collection latency: [%d] ms",
                       m_nPhaseOneCollectLatency);
        FX_QUERY_TRACE(DEBUG, pResTracer, "Phase two search latency: [%d] ms",
                       m_nPhaseTwoLatency);
        FX_QUERY_TRACE(DEBUG, pResTracer, "Phase two collection latency: [%d] ms",
                       m_nPhaseTwoCollectLatency);
    }

    FX_DEBUG("Begin format result");
    stringstream ss;
    XMLResultFormatter formatter;
    formatter.format(phaseTwoResult, ss);
    m_sResult = ss.str();
    FX_DEBUG("End format result");
}
void SearchShardsBase::doPhaseTwoSearch()
{
    SEARCH_LATENCY_BEGIN();
    
    const QueryResult& qResult = m_pResultCollector->getResult();
    if (qResult.hasError())
    {
        FX_LOG(WARN, qResult.getErrorMsg().c_str());
        setError(qResult.getErrorMsg());
        SEARCH_LATENCY_END(m_nPhaseTwoLatency);
        return;
    }

    m_stat.setParameter(ParameterClause::PHASE_PREFIX, 
                        IndexSearcher::PHASE_RETRIEVE_DOC_STR);
    size_t i;
    for (i = 0; i < m_reqests.size(); ++i)
    {
        m_reqests[i]->str("");
    }

    FX_DEBUG("Collected doc count: [%d]", (int32_t)qResult.size());
    QueryResult::Iterator it = qResult.iterator();
    while (it.hasNext())
    {
        const ResultDocPtr& pDoc = it.next();
        
        shardid_t shardId = pDoc->getShardId();
        FIRTEX_ASSERT2((size_t)shardId <= m_reqests.size());

        if (m_reqests[shardId]->str().empty())
        {
            m_stat.toString(*(m_reqests[shardId]));
            *(m_reqests[shardId]) << DocSelectClause::PREFIX 
                                  << Statement::CLAUSE_EQUAL_SYMBOL;
        }

        FX_TRACE("doc: [%d], shardId: [%d]", pDoc->getDocId(), shardId);
        (*m_reqests[shardId]) << pDoc->getDocId() << ",";
    }

    m_requestedShards.clear();
    for (i = 0; i < m_reqests.size(); ++i)
    {
        if (!m_reqests[i]->str().empty())
        {
            m_requestedShards.push_back(m_shards[i]);
        }
    }

    m_currentPhase = TWO_PHASE_TWO;
    for (i = 0; i < m_requestedShards.size(); ++i)
    {
        SearchShardBase* pShard = m_requestedShards[i];
        FX_DEBUG("Search shard: [%s], query: [%s]",
                 pShard->getName().c_str(),
                 m_reqests[pShard->getShardId()]->str().c_str());

        pShard->asyncSearch(m_reqests[pShard->getShardId()]->str());
    }

    m_deliver.waitFinish();

    SEARCH_LATENCY_END(m_nPhaseTwoLatency);

    collectResult();
}
Beispiel #4
0
void XMLResultFormatter::format(const QueryResult& result,
                                std::stringstream& ss)
{
    m_xmlDoc.clear();

    m_xmlDoc.addDeclarationNode(result.getEncoding());
    XMLNodeWrapperPtr pRootNode = m_xmlDoc.appendNode(
            XMLDocumentWrapper::NODE_ELEMENT, "result");
    if (result.hasError())
    {
        formatError(pRootNode, result.getErrorMsg());
    }
    else 
    {
        XMLNodeWrapperPtr resultNode = pRootNode->appendNode(
                XMLDocumentWrapper::NODE_ELEMENT, "hits");
    
        string str;
        NumberFormatter::append(str, (int32_t)result.size());
        resultNode->appendAttribute("number_hits", str);

        str.clear();
        NumberFormatter::append(str, result.getTotalHits());
        resultNode->appendAttribute("total_hits", str);

        str.clear();
        NumberFormatter::append(str, result.getTimeCost());
        resultNode->appendAttribute("cost", str);

        QueryResult::Iterator it = result.iterator();
        while (it.hasNext())
        {
            XMLNodeWrapperPtr pHitNode = resultNode->appendNode(
                    XMLDocumentWrapper::NODE_ELEMENT, "hit");

            const ResultDocPtr& pResDoc = it.next();

            if (result.hasShardId())
            {
                str.clear();
                NumberFormatter::append(str, pResDoc->getShardId());
                pHitNode->appendNode(XMLDocumentWrapper::NODE_ELEMENT,
                        "shardid", str);
            }

            if (result.hasDocId())
            {
                str.clear();
                NumberFormatter::append(str, pResDoc->getDocId());
                pHitNode->appendNode(XMLDocumentWrapper::NODE_ELEMENT,
                        "docid", str);
            }

            if (result.hasScore())
            {
                str.clear();
                NumberFormatter::append(str, pResDoc->getScore(), 2);
                pHitNode->appendNode(XMLDocumentWrapper::NODE_ELEMENT,
                        "score", str);
            }

            if (result.hasFields())
            {
                XMLNodeWrapperPtr pFieldsNode = pHitNode->appendNode(
                        XMLDocumentWrapper::NODE_ELEMENT, "fields");

                ResultDoc::Iterator fieldIt = pResDoc->iterator();
                while (fieldIt.hasNext())
                {
                    const ResultDoc::Field& field = fieldIt.next();

                    XMLNodeWrapperPtr pCDataNode = pFieldsNode->appendNode(
                            XMLDocumentWrapper::NODE_ELEMENT, field.first);
                    pCDataNode->appendNode(XMLDocumentWrapper::NODE_CDATA,
                            "", field.second);
                }
            }
        } // end while 

        const QueryTracerPtr& pTracer = result.getTracer();
        if (pTracer)
        {
            formatTracer(pRootNode, pTracer);
        }
    }
    m_xmlDoc.print(ss);
}