BSONObj TransactionRouter::Participant::attachTxnFieldsIfNeeded(
BSONObj cmd, bool isFirstStatementInThisParticipant) const {
bool hasStartTxn = false;
bool hasAutoCommit = false;
bool hasTxnNum = false;
BSONObjIterator iter(cmd);
while (iter.more()) {
auto elem = iter.next();
if (OperationSessionInfoFromClient::kStartTransactionFieldName ==
elem.fieldNameStringData()) {
hasStartTxn = true;
} else if (OperationSessionInfoFromClient::kAutocommitFieldName ==
elem.fieldNameStringData()) {
hasAutoCommit = true;
} else if (OperationSessionInfo::kTxnNumberFieldName == elem.fieldNameStringData()) {
hasTxnNum = true;
}
}
// TODO: SERVER-37045 assert when attaching startTransaction to killCursors command.
// The first command sent to a participant must start a transaction, unless it is a transaction
// command, which don't support the options that start transactions, i.e. startTransaction and
// readConcern. Otherwise the command must not have a read concern.
bool mustStartTransaction = isFirstStatementInThisParticipant && !isTransactionCommand(cmd);
if (!mustStartTransaction) {
dassert(!cmd.hasField(repl::ReadConcernArgs::kReadConcernFieldName));
}
BSONObjBuilder newCmd = mustStartTransaction
? appendFieldsForStartTransaction(std::move(cmd),
sharedOptions.readConcernArgs,
sharedOptions.atClusterTime,
!hasStartTxn)
: BSONObjBuilder(std::move(cmd));
if (isCoordinator) {
newCmd.append(kCoordinatorField, true);
}
if (!hasAutoCommit) {
newCmd.append(OperationSessionInfoFromClient::kAutocommitFieldName, false);
}
if (!hasTxnNum) {
newCmd.append(OperationSessionInfo::kTxnNumberFieldName, sharedOptions.txnNumber);
} else {
auto osi =
OperationSessionInfoFromClient::parse("OperationSessionInfo"_sd, newCmd.asTempObj());
invariant(sharedOptions.txnNumber == *osi.getTxnNumber());
}
return newCmd.obj();
}
Status AddToSetNode::init(BSONElement modExpr, const CollatorInterface* collator) {
invariant(modExpr.ok());
bool isEach = false;
// If the value of 'modExpr' is an object whose first field is '$each', treat it as an $each.
if (modExpr.type() == BSONType::Object) {
auto firstElement = modExpr.Obj().firstElement();
if (firstElement && firstElement.fieldNameStringData() == "$each") {
isEach = true;
if (firstElement.type() != BSONType::Array) {
return Status(
ErrorCodes::TypeMismatch,
str::stream()
<< "The argument to $each in $addToSet must be an array but it was of type "
<< typeName(firstElement.type()));
}
if (modExpr.Obj().nFields() > 1) {
return Status(ErrorCodes::BadValue,
str::stream() << "Found unexpected fields after $each in $addToSet: "
<< modExpr.Obj());
}
_elements = firstElement.Array();
}
}
// If the value of 'modExpr' was not an $each, we append the entire element.
if (!isEach) {
_elements.push_back(modExpr);
}
setCollator(collator);
return Status::OK();
}
NamespaceString AggregationRequest::parseNs(const std::string& dbname, const BSONObj& cmdObj) {
auto firstElement = cmdObj.firstElement();
if (firstElement.isNumber()) {
uassert(ErrorCodes::FailedToParse,
str::stream() << "Invalid command format: the '"
<< firstElement.fieldNameStringData()
<< "' field must specify a collection name or 1",
firstElement.number() == 1);
return NamespaceString::makeCollectionlessAggregateNSS(dbname);
} else {
uassert(ErrorCodes::TypeMismatch,
str::stream() << "collection name has invalid type: "
<< typeName(firstElement.type()),
firstElement.type() == BSONType::String);
const NamespaceString nss(dbname, firstElement.valueStringData());
uassert(ErrorCodes::InvalidNamespace,
str::stream() << "Invalid namespace specified '" << nss.ns() << "'",
nss.isValid() && !nss.isCollectionlessAggregateNS());
return nss;
}
}
OpMsgRequest upconvertRequest(StringData db, BSONObj cmdObj, int queryFlags) {
cmdObj = cmdObj.getOwned(); // Usually this is a no-op since it is already owned.
auto readPrefContainer = BSONObj();
const StringData firstFieldName = cmdObj.firstElementFieldName();
if (firstFieldName == "$query" || firstFieldName == "query") {
// Commands sent over OP_QUERY specify read preference by putting it at the top level and
// putting the command in a nested field called either query or $query.
// Check if legacyCommand has an invalid $maxTimeMS option.
uassert(ErrorCodes::InvalidOptions,
"cannot use $maxTimeMS query option with commands; use maxTimeMS command option "
"instead",
!cmdObj.hasField("$maxTimeMS"));
if (auto readPref = cmdObj["$readPreference"])
readPrefContainer = readPref.wrap();
cmdObj = cmdObj.firstElement().Obj().shareOwnershipWith(cmdObj);
} else if (auto queryOptions = cmdObj["$queryOptions"]) {
// Mongos rewrites commands with $readPreference to put it in a field nested inside of
// $queryOptions. Its command implementations often forward commands in that format to
// shards. This function is responsible for rewriting it to a format that the shards
// understand.
readPrefContainer = queryOptions.Obj().shareOwnershipWith(cmdObj);
cmdObj = cmdObj.removeField("$queryOptions");
}
if (!readPrefContainer.isEmpty()) {
cmdObj = BSONObjBuilder(std::move(cmdObj)).appendElements(readPrefContainer).obj();
} else if (!cmdObj.hasField("$readPreference") && (queryFlags & QueryOption_SlaveOk)) {
BSONObjBuilder bodyBuilder(std::move(cmdObj));
ReadPreferenceSetting(ReadPreference::SecondaryPreferred).toContainingBSON(&bodyBuilder);
cmdObj = bodyBuilder.obj();
}
// Try to move supported array fields into document sequences.
auto docSequenceIt = docSequenceFieldsForCommands.find(cmdObj.firstElementFieldName());
auto docSequenceElem = docSequenceIt == docSequenceFieldsForCommands.end()
? BSONElement()
: cmdObj[docSequenceIt->second];
if (!isArrayOfObjects(docSequenceElem))
return OpMsgRequest::fromDBAndBody(db, std::move(cmdObj));
auto docSequenceName = docSequenceElem.fieldNameStringData();
// Note: removing field before adding "$db" to avoid the need to copy the potentially large
// array.
auto out = OpMsgRequest::fromDBAndBody(db, cmdObj.removeField(docSequenceName));
out.sequences.push_back({docSequenceName.toString()});
for (auto elem : docSequenceElem.Obj()) {
out.sequences[0].objs.push_back(elem.Obj().shareOwnershipWith(cmdObj));
}
return out;
}
int BSONElement::woCompare(const BSONElement& elem,
ComparisonRulesSet rules,
const StringData::ComparatorInterface* comparator) const {
if (type() != elem.type()) {
int lt = (int)canonicalType();
int rt = (int)elem.canonicalType();
if (int diff = lt - rt)
return diff;
}
if (rules & ComparisonRules::kConsiderFieldName) {
if (int diff = fieldNameStringData().compare(elem.fieldNameStringData()))
return diff;
}
return compareElements(*this, elem, rules, comparator);
}
void updateSessionEntry(OperationContext* opCtx, const UpdateRequest& updateRequest) {
// Current code only supports replacement update.
dassert(UpdateDriver::isDocReplacement(updateRequest.getUpdates()));
AutoGetCollection autoColl(opCtx, NamespaceString::kSessionTransactionsTableNamespace, MODE_IX);
uassert(40527,
str::stream() << "Unable to persist transaction state because the session transaction "
"collection is missing. This indicates that the "
<< NamespaceString::kSessionTransactionsTableNamespace.ns()
<< " collection has been manually deleted.",
autoColl.getCollection());
WriteUnitOfWork wuow(opCtx);
auto collection = autoColl.getCollection();
auto idIndex = collection->getIndexCatalog()->findIdIndex(opCtx);
uassert(40672,
str::stream() << "Failed to fetch _id index for "
<< NamespaceString::kSessionTransactionsTableNamespace.ns(),
idIndex);
auto indexAccess = collection->getIndexCatalog()->getIndex(idIndex);
// Since we are looking up a key inside the _id index, create a key object consisting of only
// the _id field.
auto idToFetch = updateRequest.getQuery().firstElement();
auto toUpdateIdDoc = idToFetch.wrap();
dassert(idToFetch.fieldNameStringData() == "_id"_sd);
auto recordId = indexAccess->findSingle(opCtx, toUpdateIdDoc);
auto startingSnapshotId = opCtx->recoveryUnit()->getSnapshotId();
if (recordId.isNull()) {
// Upsert case.
auto status = collection->insertDocument(
opCtx, InsertStatement(updateRequest.getUpdates()), nullptr, true, false);
if (status == ErrorCodes::DuplicateKey) {
throw WriteConflictException();
}
uassertStatusOK(status);
wuow.commit();
return;
}
auto originalRecordData = collection->getRecordStore()->dataFor(opCtx, recordId);
auto originalDoc = originalRecordData.toBson();
invariant(collection->getDefaultCollator() == nullptr);
boost::intrusive_ptr<ExpressionContext> expCtx(new ExpressionContext(opCtx, nullptr));
auto matcher = fassertStatusOK(
40673, MatchExpressionParser::parse(updateRequest.getQuery(), std::move(expCtx)));
if (!matcher->matchesBSON(originalDoc)) {
// Document no longer match what we expect so throw WCE to make the caller re-examine.
throw WriteConflictException();
}
OplogUpdateEntryArgs args;
args.nss = NamespaceString::kSessionTransactionsTableNamespace;
args.uuid = collection->uuid();
args.update = updateRequest.getUpdates();
args.criteria = toUpdateIdDoc;
args.fromMigrate = false;
collection->updateDocument(opCtx,
recordId,
Snapshotted<BSONObj>(startingSnapshotId, originalDoc),
updateRequest.getUpdates(),
true, // enforceQuota
false, // indexesAffected = false because _id is the only index
nullptr,
&args);
wuow.commit();
}
