void run() {
long normal = time( BSON( "x" << 5 ) , BSON( "x" << 5 ) );
long all = time( BSON( "x" << BSON( "$all" << BSON_ARRAY( 5 ) ) ) , BSON( "x" << 5 ) );
cout << "normal: " << normal << " all: " << all << endl;
}
/**
* SERVER-4914 For now the first shard is returned for unsatisfiable queries, as some
* clients of getShardsForQuery() expect at least one shard.
*/
virtual BSONArray expectedShardNames() const {
return BSON_ARRAY( "0" ) /* BSONArray() */;
}
virtual BSONArray extentSizes() const {
return BSON_ARRAY( fitsOne() << fitsOne() );
}
void run() {
insert( BSON( "a" << 0 << "b" << 4 ) );
insert( BSON( "a" << 1 << "b" << 5 ) );
insert( BSON( "a" << 4 << "b" << 3 ) );
insert( BSON( "a" << 5 << "b" << 4 ) );
insert( BSON( "a" << 7 << "b" << 5 ) );
insert( BSON( "a" << 4 << "b" << 4 ) );
insert( BSON( "a" << 9 << "b" << 6 ) );
insert( BSON( "a" << 11 << "b" << 1 ) );
insert( BSON( "a" << 11 << "b" << 4 ) );
check( BSON( "a" << BSON( "$gte" << 1 << "$lte" << 10 ) << "b" << BSON( "$in" << BSON_ARRAY( 4 << 6 ) ) ) );
}
Status AuthzManagerExternalStateMongos::getUserDescription(OperationContext* opCtx,
const UserName& userName,
BSONObj* result) {
if (!shouldUseRolesFromConnection(opCtx, userName)) {
BSONObj usersInfoCmd =
BSON("usersInfo" << BSON_ARRAY(BSON(AuthorizationManager::USER_NAME_FIELD_NAME
<< userName.getUser()
<< AuthorizationManager::USER_DB_FIELD_NAME
<< userName.getDB()))
<< "showPrivileges"
<< true
<< "showCredentials"
<< true);
BSONObjBuilder builder;
const bool ok = Grid::get(opCtx)->catalogClient()->runUserManagementReadCommand(
opCtx, "admin", usersInfoCmd, &builder);
BSONObj cmdResult = builder.obj();
if (!ok) {
return getStatusFromCommandResult(cmdResult);
}
std::vector<BSONElement> foundUsers = cmdResult["users"].Array();
if (foundUsers.size() == 0) {
return Status(ErrorCodes::UserNotFound,
"User \"" + userName.toString() + "\" not found");
}
if (foundUsers.size() > 1) {
return Status(ErrorCodes::UserDataInconsistent,
str::stream() << "Found multiple users on the \"" << userName.getDB()
<< "\" database with name \""
<< userName.getUser()
<< "\"");
}
*result = foundUsers[0].Obj().getOwned();
return Status::OK();
} else {
// Obtain privilege information from the config servers for all roles acquired from the X509
// certificate.
BSONArrayBuilder userRolesBuilder;
auto& sslPeerInfo = SSLPeerInfo::forSession(opCtx->getClient()->session());
for (const RoleName& role : sslPeerInfo.roles) {
userRolesBuilder.append(BSON(AuthorizationManager::ROLE_NAME_FIELD_NAME
<< role.getRole()
<< AuthorizationManager::ROLE_DB_FIELD_NAME
<< role.getDB()));
}
BSONArray providedRoles = userRolesBuilder.arr();
BSONObj rolesInfoCmd = BSON("rolesInfo" << providedRoles << "showPrivileges"
<< "asUserFragment");
BSONObjBuilder cmdResultBuilder;
const bool cmdOk = Grid::get(opCtx)->catalogClient()->runUserManagementReadCommand(
opCtx, "admin", rolesInfoCmd, &cmdResultBuilder);
BSONObj cmdResult = cmdResultBuilder.obj();
if (!cmdOk || !cmdResult["userFragment"].ok()) {
return Status(ErrorCodes::FailedToParse,
"Unable to get resolved X509 roles from config server: " +
getStatusFromCommandResult(cmdResult).toString());
}
cmdResult = cmdResult["userFragment"].Obj().getOwned();
BSONElement userRoles = cmdResult["roles"];
BSONElement userInheritedRoles = cmdResult["inheritedRoles"];
BSONElement userInheritedPrivileges = cmdResult["inheritedPrivileges"];
if (userRoles.eoo() || userInheritedRoles.eoo() || userInheritedPrivileges.eoo() ||
!userRoles.isABSONObj() || !userInheritedRoles.isABSONObj() ||
!userInheritedPrivileges.isABSONObj()) {
return Status(
ErrorCodes::UserDataInconsistent,
"Recieved malformed response to request for X509 roles from config server");
}
*result = BSON("_id" << userName.getUser() << "user" << userName.getUser() << "db"
<< userName.getDB()
<< "credentials"
<< BSON("external" << true)
<< "roles"
<< BSONArray(cmdResult["roles"].Obj())
<< "inheritedRoles"
<< BSONArray(cmdResult["inheritedRoles"].Obj())
<< "inheritedPrivileges"
<< BSONArray(cmdResult["inheritedPrivileges"].Obj()));
return Status::OK();
}
}
virtual BSONArray splitPoints() const {
return BSON_ARRAY( BSON( "a" << "x" ) << BSON( "a" << "y" ) << BSON( "a" << "z" ) );
}
void ModMatchExpression::toBSON(BSONObjBuilder* out) const {
out->append(path(), BSON("$mod" << BSON_ARRAY(_divisor << _remainder)));
}
/* ****************************************************************************
*
* mongoEntityTypes -
*/
HttpStatusCode mongoEntityTypes
(
EntityTypeVectorResponse* responseP,
const std::string& tenant,
const std::vector<std::string>& servicePathV,
std::map<std::string, std::string>& uriParams
)
{
unsigned int offset = atoi(uriParams[URI_PARAM_PAGINATION_OFFSET].c_str());
unsigned int limit = atoi(uriParams[URI_PARAM_PAGINATION_LIMIT].c_str());
std::string detailsString = uriParams[URI_PARAM_PAGINATION_DETAILS];
bool details = (strcasecmp("on", detailsString.c_str()) == 0)? true : false;
bool reqSemTaken = false;
LM_T(LmtMongo, ("Query Entity Types"));
LM_T(LmtPagination, ("Offset: %d, Limit: %d, Details: %s", offset, limit, (details == true)? "true" : "false"));
reqSemTake(__FUNCTION__, "query types request", SemReadOp, &reqSemTaken);
/* Compose query based on this aggregation command:
*
* db.runCommand({aggregate: "entities",
* pipeline: [ {$match: { "_id.servicePath": /.../ } },
* {$project: {_id: 1, "attrNames": 1} },
* {$project: { "attrNames"
* {$cond: [ {$eq: [ "$attrNames", [ ] ] }, [null], "$attrNames"] }
* }
* },
* {$unwind: "$attrNames"},
* {$group: {_id: "$_id.type", attrs: {$addToSet: "$attrNames"}} },
* {$sort: {_id: 1} }
* ]
* })
*
* The $cond part is hard... more information at http://stackoverflow.com/questions/27510143/empty-array-prevents-document-to-appear-in-query
* As a consequence, some "null" values may appear in the resulting attrs vector, which are pruned by the result processing logic.
*
* FIXME P6: in the future, we can interpret the collapse parameter at this layer. If collapse=true so we don't need attributes, the
* following command can be used:
*
* db.runCommand({aggregate: "entities", pipeline: [ {$group: {_id: "$_id.type"} }]})
*
*
*
*/
BSONObj result;
//
// Building the projection part of the query that includes types that have no attributes
// See bug: https://github.com/telefonicaid/fiware-orion/issues/686
//
BSONArrayBuilder emptyArrayBuilder;
BSONArrayBuilder nulledArrayBuilder;
nulledArrayBuilder.appendNull();
// We are using the $cond: [ .. ] and not the $cond: { .. } one, as the former is the only one valid in MongoDB 2.4
BSONObj projection = BSON(
"$project" << BSON(
ENT_ATTRNAMES << BSON(
"$cond" << BSON_ARRAY(
BSON("$eq" << BSON_ARRAY(S_ATTRNAMES << emptyArrayBuilder.arr()) ) <<
nulledArrayBuilder.arr() <<
S_ATTRNAMES
)
)
)
);
BSONObj cmd = BSON("aggregate" << COL_ENTITIES <<
"pipeline" << BSON_ARRAY(
BSON("$match" << BSON(C_ID_SERVICEPATH << fillQueryServicePath(servicePathV))) <<
BSON("$project" << BSON("_id" << 1 << ENT_ATTRNAMES << 1)) <<
projection <<
BSON("$unwind" << S_ATTRNAMES) <<
BSON("$group" << BSON("_id" << CS_ID_ENTITY << "attrs" << BSON("$addToSet" << S_ATTRNAMES))) <<
BSON("$sort" << BSON("_id" << 1))
)
);
std::string err;
if (!runCollectionCommand(composeDatabaseName(tenant), cmd, &result, &err))
{
responseP->statusCode.fill(SccReceiverInternalError, err);
reqSemGive(__FUNCTION__, "query types request", reqSemTaken);
return SccOk;
}
// Processing result to build response
LM_T(LmtMongo, ("aggregation result: %s", result.toString().c_str()));
std::vector<BSONElement> resultsArray = getField(result, "result").Array();
if (resultsArray.size() == 0)
{
responseP->statusCode.fill(SccContextElementNotFound);
reqSemGive(__FUNCTION__, "query types request", reqSemTaken);
return SccOk;
}
/* Another strategy to implement pagination is to use the $skip and $limit operators in the
* aggregation framework. However, doing so, we don't know the total number of results, which can
* be needed in the case of details=on (using that approach, we need to do two queries: one to get
* the count and other to get the actual results with $skip and $limit, in the same "transaction" to
* avoid incoherence between both if some entity type is created or deleted in the process).
*
* However, considering that the number of types will be small compared with the number of entities,
* the current approach seems to be ok
*/
for (unsigned int ix = offset; ix < MIN(resultsArray.size(), offset + limit); ++ix)
{
BSONObj resultItem = resultsArray[ix].embeddedObject();
EntityType* entityType = new EntityType(getStringField(resultItem, "_id"));
std::vector<BSONElement> attrsArray = getField(resultItem, "attrs").Array();
entityType->count = countEntities(tenant, servicePathV, entityType->type);
if (!attrsArray[0].isNull())
{
for (unsigned int jx = 0; jx < attrsArray.size(); ++jx)
{
/* This is where NULL elements in the resulting attrs vector are pruned */
if (attrsArray[jx].isNull())
{
continue;
}
/* Note that we need and extra query() to the database (inside attributeType() function) to get each attribute type.
* This could be unefficient, specially if the number of attributes is large */
std::string attrType = attributeType(tenant, servicePathV, entityType->type , attrsArray[jx].str());
ContextAttribute* ca = new ContextAttribute(attrsArray[jx].str(), attrType, "");
entityType->contextAttributeVector.push_back(ca);
}
}
responseP->entityTypeVector.push_back(entityType);
}
char detailsMsg[256];
if (responseP->entityTypeVector.size() > 0)
{
if (details)
{
snprintf(detailsMsg, sizeof(detailsMsg), "Count: %d", (int) resultsArray.size());
responseP->statusCode.fill(SccOk, detailsMsg);
}
else
{
responseP->statusCode.fill(SccOk);
}
}
else
{
if (details)
{
snprintf(detailsMsg, sizeof(detailsMsg), "Number of types: %d. Offset is %d", (int) resultsArray.size(), offset);
responseP->statusCode.fill(SccContextElementNotFound, detailsMsg);
}
else
{
responseP->statusCode.fill(SccContextElementNotFound);
}
}
reqSemGive(__FUNCTION__, "query types request", reqSemTaken);
return SccOk;
}
TagSet::TagSet() : _tags(BSON_ARRAY(BSONObj())) {}
std::vector< ::stats::Stat>
RetrieveUsers(const std::string& section,
::stats::Timeframe timeframe,
::stats::Direction direction,
boost::optional< ::stats::SortField> sortField = boost::none,
boost::optional<acl::UserID> uid = boost::none)
{
static const char* sortFields[] =
{
"total kbytes",
"total files",
"avg speed"
};
mongo::BSONObjBuilder match;
match.append("direction", util::EnumToString(direction));
match.appendElements(Serialize(timeframe));
if (!section.empty())
match.append("section", section);
else
{
mongo::BSONArrayBuilder sections;
for (const auto& kv : cfg::Get().Sections())
sections.append(kv.first);
match.appendElements(BSON("section" << BSON("$in" << sections.arr())));
}
if (uid) match.append("uid", *uid);
mongo::BSONArrayBuilder ops;
ops.append(BSON("$match" << match.obj()));
ops.append(BSON("$group" << BSON("_id" << "$uid" <<
"total kbytes" << BSON("$sum" << "$kbytes") <<
"total files" << BSON("$sum" << "$files") <<
"total xfertime" << BSON("$sum" << "$xfertime"))));
ops.append(BSON("$project" << BSON("total kbytes" << 1 <<
"total files" << 1 <<
"total xfertime" << 1 <<
"avg speed" << BSON("$divide" <<
BSON_ARRAY("$total kbytes" << "$total xfertime")))));
if (sortField)
{
ops.append(BSON("$sort" << BSON(sortFields[static_cast<unsigned>(*sortField)] << -1)));
}
auto cmd = BSON("aggregate" << "transfers" << "pipeline" << ops.arr());
std::vector< ::stats::Stat> users;
mongo::BSONObj result;
NoErrorConnection conn;
if (conn.RunCommand(cmd, result))
{
for (const auto& elem : result["result"].Array())
{
users.emplace_back(Unserialize(elem.Obj()));
}
}
return users;
}
void interject(CountStage&, int) {
// Should cause index to be converted to multikey
insert(BSON(GENOID << "x" << BSON_ARRAY(1 << 2)));
}
// Test all types
TEST_F(FTDCCompressorTest, Types) {
TestTie c;
auto st = c.addSample(BSON("name"
<< "joe"
<< "key1"
<< 33
<< "key2"
<< 42LL));
ASSERT_HAS_SPACE(st);
const char bytes[] = {0x1, 0x2, 0x3};
BSONObj o = BSON("created" << DATENOW // date_t
<< "null"
<< BSONNULL // { a : null }
<< "undefined"
<< BSONUndefined // { a : undefined }
<< "obj"
<< BSON( // nested object
"a"
<< "abc"
<< "b"
<< 123LL)
<< "foo"
<< BSON_ARRAY("bar"
<< "baz"
<< "qux") // array of strings
<< "foo2"
<< BSON_ARRAY(5 << 6 << 7) // array of ints
<< "bindata"
<< BSONBinData(&bytes[0], 3, bdtCustom) // bindata
<< "oid"
<< OID("010203040506070809101112") // oid
<< "bool"
<< true // bool
<< "regex"
<< BSONRegEx("mongodb") // regex
<< "ref"
<< BSONDBRef("c", OID("010203040506070809101112")) // ref
<< "code"
<< BSONCode("func f() { return 1; }") // code
<< "codewscope"
<< BSONCodeWScope("func f() { return 1; }",
BSON("c" << true)) // codew
<< "minkey"
<< MINKEY // minkey
<< "maxkey"
<< MAXKEY // maxkey
);
st = c.addSample(o);
ASSERT_SCHEMA_CHANGED(st);
st = c.addSample(o);
ASSERT_HAS_SPACE(st);
st = c.addSample(BSON("name"
<< "joe"
<< "key1"
<< 34LL
<< "key2"
<< 45.0f));
ASSERT_SCHEMA_CHANGED(st);
st = c.addSample(BSON("name"
<< "joe"
<< "key1"
<< static_cast<char>(32)
<< "key2"
<< 45.0F));
ASSERT_HAS_SPACE(st);
}
// Test various schema changes
TEST_F(FTDCCompressorTest, TestSchemaChanges) {
TestTie c;
auto st = c.addSample(BSON("name"
<< "joe"
<< "key1"
<< 33
<< "key2"
<< 42));
ASSERT_HAS_SPACE(st);
st = c.addSample(BSON("name"
<< "joe"
<< "key1"
<< 34
<< "key2"
<< 45));
ASSERT_HAS_SPACE(st);
st = c.addSample(BSON("name"
<< "joe"
<< "key1"
<< 34
<< "key2"
<< 45));
ASSERT_HAS_SPACE(st);
// Add Field
st = c.addSample(BSON("name"
<< "joe"
<< "key1"
<< 34
<< "key2"
<< 45
<< "key3"
<< 47));
ASSERT_SCHEMA_CHANGED(st);
st = c.addSample(BSON("name"
<< "joe"
<< "key1"
<< 34
<< "key2"
<< 45
<< "key3"
<< 47));
ASSERT_HAS_SPACE(st);
// Rename field
st = c.addSample(BSON("name"
<< "joe"
<< "key1"
<< 34
<< "key5"
<< 45
<< "key3"
<< 47));
ASSERT_SCHEMA_CHANGED(st);
// Change type
st = c.addSample(BSON("name"
<< "joe"
<< "key1"
<< 34
<< "key5"
<< "45"
<< "key3"
<< 47));
ASSERT_SCHEMA_CHANGED(st);
// Add Field
st = c.addSample(BSON("name"
<< "joe"
<< "key1"
<< 34
<< "key2"
<< 45
<< "key3"
<< 47
<< "key7"
<< 34
<< "key9"
<< 45
<< "key13"
<< 47));
ASSERT_SCHEMA_CHANGED(st);
// Remove Field
st = c.addSample(BSON("name"
<< "joe"
<< "key7"
<< 34
<< "key9"
<< 45
<< "key13"
<< 47));
ASSERT_SCHEMA_CHANGED(st);
st = c.addSample(BSON("name"
<< "joe"
<< "key7"
<< 34
<< "key9"
<< 45
<< "key13"
<< 47));
ASSERT_HAS_SPACE(st);
// Start new batch
st = c.addSample(BSON("name"
<< "joe"
<< "key7"
<< 5));
ASSERT_SCHEMA_CHANGED(st);
// Change field to object
st = c.addSample(BSON("name"
<< "joe"
<< "key7"
<< BSON( // nested object
"a" << 1)));
ASSERT_SCHEMA_CHANGED(st);
// Change field from object to number
st = c.addSample(BSON("name"
<< "joe"
<< "key7"
<< 7));
ASSERT_SCHEMA_CHANGED(st);
// Change field from number to array
st = c.addSample(BSON("name"
<< "joe"
<< "key7"
<< BSON_ARRAY(13 << 17)));
ASSERT_SCHEMA_CHANGED(st);
// Change field from array to number
st = c.addSample(BSON("name"
<< "joe"
<< "key7"
<< 19));
ASSERT_SCHEMA_CHANGED(st);
// New Schema
st = c.addSample(BSON("_id" << 1));
ASSERT_SCHEMA_CHANGED(st);
// Change field to oid
st = c.addSample(BSON(GENOID));
ASSERT_SCHEMA_CHANGED(st);
// Change field from oid to object
st = c.addSample(BSON("_id" << BSON("sub1" << 1)));
ASSERT_SCHEMA_CHANGED(st);
// Change field from object to oid
st = c.addSample(BSON(GENOID));
ASSERT_SCHEMA_CHANGED(st);
}
virtual BSONArray splitPoints() const {
return BSON_ARRAY( BSON( "a" << 5 << "b" << 10 ) << BSON ( "a" << 5 << "b" << 20 ) );
}
BSONObj Coordinates2DGeographic::toBSON() const {
return BSON(kCoordsFieldName << BSON_ARRAY(_longitude << _latitude));
}
virtual BSONObj query() const {
return BSON( "a" << BSON( "$in" << BSON_ARRAY( 0 << 5 << 10 ) ) <<
"b" << BSON( "$in" << BSON_ARRAY( 0 << 5 << 25 ) ) );
}
BSONArray Box::toBSON() const {
return BSON_ARRAY(BSON_ARRAY(_min.x << _min.y) << BSON_ARRAY(_max.x << _max.y));
}
/* ****************************************************************************
*
* mongoAttributesForEntityType -
*/
HttpStatusCode mongoAttributesForEntityType
(
std::string entityType,
EntityTypeResponse* responseP,
const std::string& tenant,
const std::vector<std::string>& servicePathV,
std::map<std::string, std::string>& uriParams
)
{
unsigned int offset = atoi(uriParams[URI_PARAM_PAGINATION_OFFSET].c_str());
unsigned int limit = atoi(uriParams[URI_PARAM_PAGINATION_LIMIT].c_str());
std::string detailsString = uriParams[URI_PARAM_PAGINATION_DETAILS];
bool details = (strcasecmp("on", detailsString.c_str()) == 0)? true : false;
bool reqSemTaken = false;
// Setting the name of the entity type for the response
responseP->entityType.type = entityType;
LM_T(LmtMongo, ("Query Types Attribute for <%s>", entityType.c_str()));
LM_T(LmtPagination, ("Offset: %d, Limit: %d, Details: %s", offset, limit, (details == true)? "true" : "false"));
reqSemTake(__FUNCTION__, "query types attributes request", SemReadOp, &reqSemTaken);
/* Compose query based on this aggregation command:
*
* db.runCommand({aggregate: "entities",
* pipeline: [ {$match: { "_id.type": "TYPE" , "_id.servicePath": /.../ } },
* {$project: {_id: 1, "attrNames": 1} },
* {$unwind: "$attrNames"},
* {$group: {_id: "$_id.type", attrs: {$addToSet: "$attrNames"}} },
* {$unwind: "$attrs"},
* {$group: {_id: "$attrs" }},
* {$sort: {_id: 1}}
* ]
* })
*
*/
BSONObj result;
BSONObj cmd = BSON("aggregate" << COL_ENTITIES <<
"pipeline" << BSON_ARRAY(
BSON("$match" << BSON(C_ID_ENTITY << entityType << C_ID_SERVICEPATH << fillQueryServicePath(servicePathV))) <<
BSON("$project" << BSON("_id" << 1 << ENT_ATTRNAMES << 1)) <<
BSON("$unwind" << S_ATTRNAMES) <<
BSON("$group" << BSON("_id" << CS_ID_ENTITY << "attrs" << BSON("$addToSet" << S_ATTRNAMES))) <<
BSON("$unwind" << "$attrs") <<
BSON("$group" << BSON("_id" << "$attrs")) <<
BSON("$sort" << BSON("_id" << 1))
)
);
std::string err;
if (!runCollectionCommand(composeDatabaseName(tenant), cmd, &result, &err))
{
responseP->statusCode.fill(SccReceiverInternalError, err);
reqSemGive(__FUNCTION__, "query types request", reqSemTaken);
return SccOk;
}
/* Processing result to build response */
LM_T(LmtMongo, ("aggregation result: %s", result.toString().c_str()));
std::vector<BSONElement> resultsArray = getField(result, "result").Array();
responseP->entityType.count = countEntities(tenant, servicePathV, entityType);
if (resultsArray.size() == 0)
{
responseP->statusCode.fill(SccContextElementNotFound);
reqSemGive(__FUNCTION__, "query types request", reqSemTaken);
return SccOk;
}
/* See comment above in the other method regarding this strategy to implement pagination */
for (unsigned int ix = offset; ix < MIN(resultsArray.size(), offset + limit); ++ix)
{
BSONElement idField = resultsArray[ix].embeddedObject().getField("_id");
//
// BSONElement::eoo returns true if 'not found', i.e. the field "_id" doesn't exist in 'sub'
//
// Now, if 'resultsArray[ix].embeddedObject().getField("_id")' is not found, if we continue,
// calling embeddedObject() on it, then we get an exception and the broker crashes.
//
if (idField.eoo() == true)
{
LM_E(("Database Error (error retrieving _id field in doc: %s)", resultsArray[ix].embeddedObject().toString().c_str()));
continue;
}
/* Note that we need and extra query() to the database (inside attributeType() function) to get each attribute type.
* This could be unefficient, specially if the number of attributes is large */
std::string attrType = attributeType(tenant, servicePathV, entityType , idField.str());
ContextAttribute* ca = new ContextAttribute(idField.str(), attrType, "");
responseP->entityType.contextAttributeVector.push_back(ca);
}
char detailsMsg[256];
if (responseP->entityType.contextAttributeVector.size() > 0)
{
if (details)
{
snprintf(detailsMsg, sizeof(detailsMsg), "Count: %d", (int) resultsArray.size());
responseP->statusCode.fill(SccOk, detailsMsg);
}
else
{
responseP->statusCode.fill(SccOk);
}
}
else
{
if (details)
{
snprintf(detailsMsg, sizeof(detailsMsg), "Number of attributes: %d. Offset is %d", (int) resultsArray.size(), offset);
responseP->statusCode.fill(SccContextElementNotFound, detailsMsg);
}
else
{
responseP->statusCode.fill(SccContextElementNotFound);
}
}
reqSemGive(__FUNCTION__, "query types request", reqSemTaken);
return SccOk;
}
// TODO SERVER-25493: Remove $exists clause once MongoDB versions <= 3.2 are no longer supported.
BSONObj ListCollectionsFilter::makeTypeCollectionFilter() {
return BSON("$or" << BSON_ARRAY(BSON("type"
<< "collection")
<< BSON("type" << BSON("$exists" << false))));
}
void run() {
assert( _versionArray("1.2.3") == BSON_ARRAY(1 << 2 << 3 << 0) );
assert( _versionArray("1.2.0") == BSON_ARRAY(1 << 2 << 0 << 0) );
assert( _versionArray("2.0.0") == BSON_ARRAY(2 << 0 << 0 << 0) );
assert( _versionArray("1.2.3-pre-") == BSON_ARRAY(1 << 2 << 3 << -100) );
assert( _versionArray("1.2.0-pre-") == BSON_ARRAY(1 << 2 << 0 << -100) );
assert( _versionArray("2.0.0-pre-") == BSON_ARRAY(2 << 0 << 0 << -100) );
assert( _versionArray("1.2.3-rc0") == BSON_ARRAY(1 << 2 << 3 << -10) );
assert( _versionArray("1.2.0-rc1") == BSON_ARRAY(1 << 2 << 0 << -9) );
assert( _versionArray("2.0.0-rc2") == BSON_ARRAY(2 << 0 << 0 << -8) );
// Note that the pre of an rc is the same as the rc itself
assert( _versionArray("1.2.3-rc3-pre-") == BSON_ARRAY(1 << 2 << 3 << -7) );
assert( _versionArray("1.2.0-rc4-pre-") == BSON_ARRAY(1 << 2 << 0 << -6) );
assert( _versionArray("2.0.0-rc5-pre-") == BSON_ARRAY(2 << 0 << 0 << -5) );
log(1) << "versionArrayTest passed" << endl;
}
BSONObj ListCollectionsFilter::addTypeViewFilter(const BSONObj& filter) {
if (filter.isEmpty())
return makeTypeViewFilter();
return BSON("$and" << BSON_ARRAY(filter << makeTypeViewFilter()));
}
/**
* It isn't actually necessary to return shard 2 because its lowest key is "y", which
* is excluded from the query. SERVER-4791
*/
virtual BSONArray expectedShardNames() const { return BSON_ARRAY( "0" << "1" << "2" ); }
virtual BSONArray extentSizes() const {
return BSON_ARRAY( fitsMany() );
}
