Class CompoundIndexPlugin

src/QLContext.actor.cpp:312–450

};

struct CompoundIndexPlugin : IndexPlugin, ReferenceCounted<CompoundIndexPlugin>, FastAllocated<CompoundIndexPlugin> {
	void addref() override { ReferenceCounted<CompoundIndexPlugin>::addref(); }
	void delref() override { ReferenceCounted<CompoundIndexPlugin>::delref(); }

	ACTOR static Future<Void> doIndexUpdateActor(Reference<CompoundIndexPlugin> self,
	                                             Reference<DocTransaction> tr,
	                                             Reference<DocumentDeferred> dd,
	                                             DataKey documentPath) {
		state Reference<QueryContext> doc(new QueryContext(self->next, tr, documentPath));
		state Future<Void> writes_finished = dd->writes_finished.getFuture();

		try {
			dd->snapshotLock.use();

			std::vector<Future<std::vector<DataValue>>> f_old_values;
			for (const auto& expr : self->exprs) {
				f_old_values.push_back(
				    consumeAll(mapAsync(expr.first->evaluate(doc), [](Reference<IReadContext> valcx) {
					    return getMaybeRecursive(valcx, StringRef());
				    })));
			}

			state std::vector<std::vector<DataValue>> old_values = wait(getAll(f_old_values));

			dd->snapshotLock.unuse();

			wait(writes_finished);

			std::vector<Future<std::vector<DataValue>>> f_new_values;
			for (const auto& expr : self->exprs) {
				f_new_values.push_back(
				    consumeAll(mapAsync(expr.first->evaluate(doc), [](Reference<IReadContext> valcx) {
					    return getMaybeRecursive(valcx, StringRef());
				    })));
			}

			state std::vector<std::vector<DataValue>> new_values = wait(getAll(f_new_values));

			int num_new_values = 1;
			for (const auto& v : new_values) {
				num_new_values *= v.size();
			}

			if (num_new_values > DOCLAYER_KNOBS->MULTI_MULTIKEY_INDEX_MAX) {
				throw multikey_index_cartesian_explosion();
			}

			state cartesian_product_iterator<DataValue, std::vector<DataValue>::iterator> nvv(new_values);
			if (self->isUniqueIndex) {
				// for all new entries going to be written, before we clear the potentially existing old index entries,
				// we need to make sure there is no existing unique index for that new value under path
				// dbName+collectionName+"metadata"+"indices"+encodedIndexName+encodedValue

				// When building the unique index, each record out of the table scan needs to wait for the previous
				// one finished duplication detecting and index record writing. And thus the following section
				// before the `lock.release()` call, needs to be protected using a mutex lock.
				ASSERT(self->flowControlLock.present());
				wait(self->flowControlLock.get()->take());