Cosmetic cleanup. (#181)

Author: apkar

src/QLPlan.actor.cpp

@@ -335,7 +335,6 @@ ACTOR static Future<Void> toDocInfo(PlanCheckpoint* checkpoint,
 			inputLock->release();
 			Void _ = wait(outputLock->take());
 			lastKey = Key(kv.key, kv.arena());
-			// fprintf(stderr, "lastkey: %s\n", printable(lastKey).c_str());
 			Standalone<StringRef> last(DataKey::decode_item_rev(kv.key, 0), kv.arena());
 			Reference<ScanReturnedContext> output(new ScanReturnedContext(base->getSubContext(last), scanID, lastKey));
 			dis.send(output);
@@ -373,9 +372,6 @@ ACTOR static Future<bool> simpleWouldBeLast(Reference<ScanReturnedContext> doc,
 				break;
 			}
 		}
-		// fprintf(stderr, "SWBL last: %s\n", printable(last).c_str());
-		// fprintf(stderr, "SWBL scankey: %s\n", printable(doc->scanKey()).c_str());
-		// fprintf(stderr, "SWBL upperBound: %s\n", printable(indexUpperBound).c_str());
 		if (doc->scanKey().startsWith(last))
 			return true;
 	}
@@ -416,9 +412,6 @@ ACTOR static Future<bool> compoundWouldBeLast(Reference<ScanReturnedContext> doc
 				break;
 			}
 		}
-		// fprintf(stderr, "CWBL last: %s\n", printable(last).c_str());
-		// fprintf(stderr, "CWBL scankey: %s\n", printable(doc->scanKey()).c_str());
-		// fprintf(stderr, "CWBL upperBound: %s\n", printable(indexUpperBound).c_str());
 		if (doc->scanKey().startsWith(last))
 			return true;
 	}
@@ -558,7 +551,6 @@ ACTOR static Future<Void> doPKScan(PlanCheckpoint* checkpoint,
 			lastKey = Key(kv.key, kv.arena());
 		}
 	} catch (Error& e) {
-		// fprintf(stderr, "doPKScan: %s %d\n", e.what(), checkpoint->splitBoundWanted());
 		if (e.code() == error_code_actor_cancelled) {
 			if (checkpoint->splitBoundWanted()) {
 				DataKey splitKey = DataKey::decode_bytes(lastKey);
@@ -577,8 +569,8 @@ FutureStream<Reference<ScanReturnedContext>> PrimaryKeyLookupPlan::execute(PlanC
 	Reference<CollectionContext> bcx = cx->bindCollectionContext(tr);
 	if (begin.present() && end.present() && begin.get() == end.get()) {
 		PromiseStream<Reference<ScanReturnedContext>> p;
-		checkpoint->addOperation(doSinglePKLookup(checkpoint, p, bcx, begin.get(), scanID),
-		                         p); // ??? Can we skip this overhead?
+		// ??? Can we skip this overhead?
+		checkpoint->addOperation(doSinglePKLookup(checkpoint, p, bcx, begin.get(), scanID), p);
 		return p.getFuture();
 	} else {
 		PromiseStream<Reference<ScanReturnedContext>> p;
@@ -590,7 +582,6 @@ FutureStream<Reference<ScanReturnedContext>> PrimaryKeyLookupPlan::execute(PlanC
 		Standalone<StringRef> endKey = std::max<Standalone<StringRef>>(
 		    beginKey, std::min(end.present() ? strinc(end.get().encode_key_part()) : LiteralStringRef("\xff"),
 		                       checkpoint->getBounds(scanID).end));
-		// fprintf(stderr, "PK scan executing from %s to %s\n", printable(beginKey).c_str(), printable(endKey).c_str());
 
 		GenFutureStream<KeyValue> kvs = bcx->cx->getDescendants(beginKey, endKey, descendantFlowControlLock);
 		checkpoint->addOperation(doPKScan(checkpoint, bcx, scanID, kvs, p, descendantFlowControlLock),
@@ -704,17 +695,14 @@ ACTOR static Future<Void> doNonIsolatedRO(PlanCheckpoint* outerCheckpoint,
 	try {
 		state uint64_t metadataVersion = wait(cx->bindCollectionContext(dtr)->getMetadataVersion());
 		loop {
-			// printf("Trying nonIsolatedRO with %d outputs and checkpoint '%s'-'%s'\n", nResults,
-			// printable(innerCheckpoint->getBounds(0).begin).c_str(),
-			// printable(innerCheckpoint->getBounds(0).end).c_str());
 			state FutureStream<Reference<ScanReturnedContext>> docs = subPlan->execute(innerCheckpoint.getPtr(), dtr);
 			state FlowLock* innerLock = innerCheckpoint->getDocumentFinishedLock();
 			state bool first = true;
 			state Future<Void> timeout = delay(3.0);
 
 			loop choose {
-				when(state Reference<ScanReturnedContext> doc =
-				         waitNext(docs)) { // throws end_of_stream when totally finished
+				when(state Reference<ScanReturnedContext> doc = waitNext(docs)) {
+					// throws end_of_stream when totally finished
 					Void _ = wait(outerLock->take());
 					innerLock->release();
 					output.send(doc);
@@ -723,7 +711,6 @@ ACTOR static Future<Void> doNonIsolatedRO(PlanCheckpoint* outerCheckpoint,
 						timeout = delay(DOCLAYER_KNOBS->NONISOLATED_INTERNAL_TIMEOUT);
 						first = false;
 					}
-					// if (oCount == 3) timeout = delay(0);
 				}
 				when(Void _ = wait(timeout)) { break; }
 			}
@@ -785,9 +772,10 @@ ACTOR static Future<Void> doNonIsolatedRW(PlanCheckpoint* outerCheckpoint,
 					loop {
 						if (bufferedDocs.size() + committingDocs.size() >=
 						    DOCLAYER_KNOBS->NONISOLATED_RW_INTERNAL_BUFFER_MAX)
-							timeout = delay(0); // We do this instead of breaking so that when stopAndCheckpoint() gets
-							                    // called below, the actor for the plan immediately inside us is never
-							                    // on the call stack, so gets its actor_cancelled delivered immediately.
+							// We do this instead of breaking so that when stopAndCheckpoint() gets
+							// called below, the actor for the plan immediately inside us is never
+							// on the call stack, so gets its actor_cancelled delivered immediately.
+							timeout = delay(0);
 						choose {
 							when(state Reference<ScanReturnedContext> doc =
 							         waitNext(docs)) { // throws end_of_stream when totally finished
@@ -1045,10 +1033,10 @@ ACTOR static Future<Void> doFlushChanges(PlanCheckpoint* checkpoint,
 			try {
 				choose {
 					when(Reference<ScanReturnedContext> nextInput = waitNext(input)) {
+						// FIXME: this will be unsafe with unique indexes. Something has to happen here that doesn't
+						// kill performance.
 						futures.push_back(std::pair<Reference<ScanReturnedContext>, Future<Void>>(
-						    nextInput,
-						    nextInput->commitChanges())); // FIXME: this will be unsafe with unique indexes. Something
-						                                  // has to happen here that doesn't kill performance.
+						    nextInput, nextInput->commitChanges()));
 					}
 					when(Void _ = wait(futures.empty() ? Never() : futures.front().second)) {
 						output.send(futures.front().first);
@@ -1127,7 +1115,6 @@ ACTOR static Future<Void> doUpdate(PlanCheckpoint* checkpoint,
 
 		throw end_of_stream();
 	} catch (Error& e) {
-		// printf("doUpdate: %s\n", e.what());
 		if (e.code() == error_code_actor_cancelled) {
 			if (checkpoint->splitBoundWanted()) {
 				for (int i = futures.size() - 1; i >= 0; i--)
@@ -1172,18 +1159,15 @@ ACTOR static Future<Void> findAndModify(PlanCheckpoint* outerCheckpoint,
 	try {
 		state uint64_t metadataVersion = wait(cx->bindCollectionContext(dtr)->getMetadataVersion());
 		loop {
-			// printf("Trying nonIsolatedRO with %d outputs and checkpoint '%s'-'%s'\n", nResults,
-			// printable(innerCheckpoint->getBounds(0).begin).c_str(),
-			// printable(innerCheckpoint->getBounds(0).end).c_str());
 			state FutureStream<Reference<ScanReturnedContext>> docs = subPlan->execute(innerCheckpoint.getPtr(), dtr);
 			state FlowLock* innerLock = innerCheckpoint->getDocumentFinishedLock();
 			state Future<Void> timeout = delay(1.0);
 			state bool done = false;
 
 			try {
 				loop choose {
-					when(state Reference<ScanReturnedContext> doc =
-					         waitNext(docs)) { // throws end_of_stream when totally finished
+					when(state Reference<ScanReturnedContext> doc = waitNext(docs)) {
+						// throws end_of_stream when totally finished
 						firstDoc = doc;
 						innerLock->release();
 						done = true;
@@ -1441,10 +1425,9 @@ ACTOR static Future<Void> doInsert(PlanCheckpoint* checkpoint,
                                    Reference<MetadataManager> mm,
                                    Namespace ns,
                                    PromiseStream<Reference<ScanReturnedContext>> output) {
-	// state int64_t& inserted = checkpoint->getIntState(0); <- This is broken for now.
 	state Deque<Future<Reference<IReadWriteContext>>> f;
 	state FlowLock* flowControlLock = checkpoint->getDocumentFinishedLock();
-	state int i = 0; // = inserted;
+	state int i = 0;
 
 	try {
 		state Reference<UnboundCollectionContext> ucx = wait(mm->getUnboundCollectionContext(tr, ns));
@@ -1459,15 +1442,13 @@ ACTOR static Future<Void> doInsert(PlanCheckpoint* checkpoint,
 				when(Reference<IReadWriteContext> doc = wait(f.empty() ? Never() : f.front())) {
 					output.send(ref(new ScanReturnedContext(doc, -1, Key()))); // Are these the right scanId etc?
 					f.pop_front();
-					// inserted++;
 				}
 			}
 		}
 		state int j = 0;
 		for (; j < f.size(); j++) {
 			Reference<IReadWriteContext> doc = wait(f[j]);
 			output.send(ref(new ScanReturnedContext(doc, -1, Key()))); // Are these the right scanId etc?
-			// inserted++;
 		}
 		throw end_of_stream();
 	} catch (Error& e) {
@@ -1503,11 +1484,9 @@ ACTOR static Future<Void> doSort(PlanCheckpoint* outerCheckpoint,
 	loop {
 		try {
 			Reference<ScanReturnedContext> doc = waitNext(docs);
-			returnProjections.push_back(
-			    doc->toDataValue().get().getPackedObject().getOwned()); // Note that this call to get() is safe here but
-			                                                            // not in general, because we know that
-			                                                            // doc is wrapping a BsonContext, which means
-			                                                            // toDataValue() is synchronous.
+			// Note that this call to get() is safe here but not in general, because we know that doc is wrapping a
+			// BsonContext, which means toDataValue() is synchronous.
+			returnProjections.push_back(doc->toDataValue().get().getPackedObject().getOwned());
 			innerLock->release();
 		} catch (Error& e) {
 			if (e.code() == error_code_end_of_stream) {