C++ WriteErrorDetail::setIndex方法代码示例

void BatchSafeWriter::safeWriteBatch( DBClientBase* conn,
                                      const BatchedCommandRequest& request,
                                      BatchedCommandResponse* response ) {

    // N starts at zero, and we add to it for each item
    response->setN( 0 );

    for ( size_t i = 0; i < request.sizeWriteOps(); ++i ) {

        BatchItemRef itemRef( &request, static_cast<int>( i ) );
        LastError lastError;

        _safeWriter->safeWrite( conn, itemRef, &lastError );

        // Register the error if we need to
        WriteErrorDetail* batchError = lastErrorToBatchError( lastError );
        if ( batchError ) {
            batchError->setIndex( i );
            response->addToErrDetails( batchError );
        }

        response->setN( response->getN() + lastError.nObjects );

        if ( !lastError.upsertedId.isEmpty() ) {
            BatchedUpsertDetail* upsertedId = new BatchedUpsertDetail;
            upsertedId->setIndex( i );
            upsertedId->setUpsertedID( lastError.upsertedId );
            response->addToUpsertDetails( upsertedId );
        }

        // Break on first error if we're ordered
        if ( request.getOrdered() && BatchSafeWriter::isFailedOp( lastError ) ) break;
    }

    if ( request.sizeWriteOps() == 1 && response->isErrDetailsSet()
            && !response->isErrCodeSet() ) {

        // Promote single error to batch error
        const WriteErrorDetail* error = response->getErrDetailsAt( 0 );
        response->setErrCode( error->getErrCode() );
        if ( error->isErrInfoSet() ) response->setErrInfo( error->getErrInfo() );
        response->setErrMessage( error->getErrMessage() );

        response->unsetErrDetails();
    }

    if ( request.sizeWriteOps() == 1 && response->isUpsertDetailsSet() ) {

        // Promote single upsert to batch upsert
        const BatchedUpsertDetail* upsertedId = response->getUpsertDetailsAt( 0 );
        response->setSingleUpserted( upsertedId->getUpsertedID() );

        response->unsetUpsertDetails();
    }

    response->setOk( !response->isErrCodeSet() );
    dassert( response->isValid( NULL ) );
}

    void WriteBatchExecutor::execInserts( const BatchedCommandRequest& request,
                                          std::vector<WriteErrorDetail*>* errors ) {

        // Theory of operation:
        //
        // Instantiates an ExecInsertsState, which represents all of the state involved in the batch
        // insert execution algorithm.  Most importantly, encapsulates the lock state.
        //
        // Every iteration of the loop in execInserts() processes one document insertion, by calling
        // insertOne() exactly once for a given value of state.currIndex.
        //
        // If the ExecInsertsState indicates that the requisite write locks are not held, insertOne
        // acquires them and performs lock-acquisition-time checks.  However, on non-error
        // execution, it does not release the locks.  Therefore, the yielding logic in the while
        // loop in execInserts() is solely responsible for lock release in the non-error case.
        //
        // Internally, insertOne loops performing the single insert until it completes without a
        // PageFaultException, or until it fails with some kind of error.  Errors are mostly
        // propagated via the request->error field, but DBExceptions or std::exceptions may escape,
        // particularly on operation interruption.  These kinds of errors necessarily prevent
        // further insertOne calls, and stop the batch.  As a result, the only expected source of
        // such exceptions are interruptions.
        ExecInsertsState state(&request);
        normalizeInserts(request, &state.normalizedInserts, &state.pregeneratedKeys);

        ElapsedTracker elapsedTracker(128, 10); // 128 hits or 10 ms, matching RunnerYieldPolicy's

        for (state.currIndex = 0;
             state.currIndex < state.request->sizeWriteOps();
             ++state.currIndex) {

            if (elapsedTracker.intervalHasElapsed()) {
                // Consider yielding between inserts.

                if (state.hasLock()) {
                    int micros = ClientCursor::suggestYieldMicros();
                    if (micros > 0) {
                        state.unlock();
                        killCurrentOp.checkForInterrupt();
                        sleepmicros(micros);
                    }
                }
                killCurrentOp.checkForInterrupt();
                elapsedTracker.resetLastTime();
            }

            WriteErrorDetail* error = NULL;
            execOneInsert(&state, &error);
            if (error) {
                errors->push_back(error);
                error->setIndex(state.currIndex);
                if (request.getOrdered())
                    return;
            }
        }
    }