void Translator::insert(int idx, const TranslatorMessage &msg)
{
addIndex(idx, msg);
m_messages.insert(idx, msg);
}
void run() {
Client::WriteContext ctx(ns());
for (int i = 0; i < 50; ++i) {
insert(BSON("foo" << i << "bar" << i));
}
addIndex(BSON("foo" << 1));
addIndex(BSON("bar" << 1));
WorkingSet ws;
scoped_ptr<AndHashStage> ah(new AndHashStage(&ws, NULL));
// Foo <= 20
IndexScanParams params;
params.descriptor = getIndex(BSON("foo" << 1));
params.bounds.isSimpleRange = true;
params.bounds.startKey = BSON("" << 20);
params.bounds.endKey = BSONObj();
params.bounds.endKeyInclusive = true;
params.direction = -1;
ah->addChild(new IndexScan(params, &ws, NULL));
// Bar >= 10
params.descriptor = getIndex(BSON("bar" << 1));
params.bounds.startKey = BSON("" << 10);
params.bounds.endKey = BSONObj();
params.bounds.endKeyInclusive = true;
params.direction = 1;
ah->addChild(new IndexScan(params, &ws, NULL));
// ah reads the first child into its hash table.
// ah should read foo=20, foo=19, ..., foo=0 in that order.
// Read half of them...
for (int i = 0; i < 10; ++i) {
WorkingSetID out;
PlanStage::StageState status = ah->work(&out);
ASSERT_EQUALS(PlanStage::NEED_TIME, status);
}
// ...yield
ah->prepareToYield();
// ...invalidate one of the read objects
set<DiskLoc> data;
getLocs(&data);
for (set<DiskLoc>::const_iterator it = data.begin(); it != data.end(); ++it) {
if (it->obj()["foo"].numberInt() == 15) {
ah->invalidate(*it);
remove(it->obj());
break;
}
}
ah->recoverFromYield();
// And expect to find foo==15 it flagged for review.
const vector<WorkingSetID>& flagged = ws.getFlagged();
ASSERT_EQUALS(size_t(1), flagged.size());
// Expect to find the right value of foo in the flagged item.
WorkingSetMember* member = ws.get(flagged[0]);
ASSERT_TRUE(NULL != member);
ASSERT_EQUALS(WorkingSetMember::OWNED_OBJ, member->state);
BSONElement elt;
ASSERT_TRUE(member->getFieldDotted("foo", &elt));
ASSERT_EQUALS(15, elt.numberInt());
// Now, finish up the AND. Since foo == bar, we would have 11 results, but we subtract
// one because of a mid-plan invalidation, so 10.
int count = 0;
while (!ah->isEOF()) {
WorkingSetID id;
PlanStage::StageState status = ah->work(&id);
if (PlanStage::ADVANCED != status) { continue; }
++count;
member = ws.get(id);
ASSERT_TRUE(member->getFieldDotted("foo", &elt));
ASSERT_LESS_THAN_OR_EQUALS(elt.numberInt(), 20);
ASSERT_NOT_EQUALS(15, elt.numberInt());
ASSERT_TRUE(member->getFieldDotted("bar", &elt));
ASSERT_GREATER_THAN_OR_EQUALS(elt.numberInt(), 10);
}
ASSERT_EQUALS(10, count);
}
//--------------------------------------------------------------
void ofMesh::addTriangle(ofIndexType index1, ofIndexType index2, ofIndexType index3) {
addIndex(index1);
addIndex(index2);
addIndex(index3);
}
//--------------------------------------------------------------
void ofMesh::addIndices(const ofIndexType* inds, int amt){
for (int i = 0; i < amt;i++){
addIndex(inds[i]);
}
bIndicesChanged = true;
}
void run() {
Client::WriteContext ctx(ns());
// Insert a bunch of data
for (int i = 0; i < 50; ++i) {
insert(BSON("foo" << 1 << "bar" << 1));
}
addIndex(BSON("foo" << 1));
addIndex(BSON("bar" << 1));
WorkingSet ws;
scoped_ptr<AndSortedStage> ah(new AndSortedStage(&ws, NULL));
// Scan over foo == 1
IndexScanParams params;
params.descriptor = getIndex(BSON("foo" << 1));
params.bounds.isSimpleRange = true;
params.bounds.startKey = BSON("" << 1);
params.bounds.endKey = BSON("" << 1);
params.bounds.endKeyInclusive = true;
params.direction = 1;
ah->addChild(new IndexScan(params, &ws, NULL));
// Scan over bar == 1
params.descriptor = getIndex(BSON("bar" << 1));
ah->addChild(new IndexScan(params, &ws, NULL));
// Get the set of disklocs in our collection to use later.
set<DiskLoc> data;
getLocs(&data);
// We're making an assumption here that happens to be true because we clear out the
// collection before running this: increasing inserts have increasing DiskLocs.
// This isn't true in general if the collection is not dropped beforehand.
WorkingSetID id;
// Sorted AND looks at the first child, which is an index scan over foo==1.
ah->work(&id);
// The first thing that the index scan returns (due to increasing DiskLoc trick) is the
// very first insert, which should be the very first thing in data. Let's invalidate it
// and make sure it shows up in the flagged results.
ah->prepareToYield();
ah->invalidate(*data.begin());
remove(data.begin()->obj());
ah->recoverFromYield();
// Make sure the nuked obj is actually in the flagged data.
ASSERT_EQUALS(ws.getFlagged().size(), size_t(1));
WorkingSetMember* member = ws.get(ws.getFlagged()[0]);
ASSERT_EQUALS(WorkingSetMember::OWNED_OBJ, member->state);
BSONElement elt;
ASSERT_TRUE(member->getFieldDotted("foo", &elt));
ASSERT_EQUALS(1, elt.numberInt());
ASSERT_TRUE(member->getFieldDotted("bar", &elt));
ASSERT_EQUALS(1, elt.numberInt());
set<DiskLoc>::iterator it = data.begin();
// Proceed along, AND-ing results.
int count = 0;
while (!ah->isEOF() && count < 10) {
WorkingSetID id;
PlanStage::StageState status = ah->work(&id);
if (PlanStage::ADVANCED != status) { continue; }
++count;
++it;
member = ws.get(id);
ASSERT_TRUE(member->getFieldDotted("foo", &elt));
ASSERT_EQUALS(1, elt.numberInt());
ASSERT_TRUE(member->getFieldDotted("bar", &elt));
ASSERT_EQUALS(1, elt.numberInt());
ASSERT_EQUALS(member->loc, *it);
}
// Move 'it' to a result that's yet to show up.
for (int i = 0; i < count + 10; ++i) { ++it; }
// Remove a result that's coming up. It's not the 'target' result of the AND so it's
// not flagged.
ah->prepareToYield();
ah->invalidate(*it);
remove(it->obj());
ah->recoverFromYield();
// Get all results aside from the two we killed.
while (!ah->isEOF()) {
WorkingSetID id;
PlanStage::StageState status = ah->work(&id);
if (PlanStage::ADVANCED != status) { continue; }
++count;
member = ws.get(id);
ASSERT_TRUE(member->getFieldDotted("foo", &elt));
ASSERT_EQUALS(1, elt.numberInt());
ASSERT_TRUE(member->getFieldDotted("bar", &elt));
ASSERT_EQUALS(1, elt.numberInt());
}
ASSERT_EQUALS(count, 48);
ASSERT_EQUALS(size_t(1), ws.getFlagged().size());
}
Base() : lk(ns()), _context( ns() ) {
addIndex( fromjson( "{\"a\":1}" ) );
}
void MainWindow::showContextMenu( const QPoint & )
{
QModelIndexList selectedRows = mUI.mTreeView->selectedRows();
printf( "%i rows selected\n", selectedRows.size() );
if( selectedRows.size() > 1 ) return;
QModelIndex idx;
if( selectedRows.size() == 1 ) idx = selectedRows[0];
QMenu * m = new QMenu( this );
QAction * newTable = 0, * newTableInherit = 0, * newField = 0, * newIndex = 0, * modifyTable = 0, * removeTable = 0, * createVerifyTable = 0;
QAction * modifyField = 0, * removeField = 0, * modifyIndex = 0, * removeIndex = 0;
TableSchema * table = 0;
if( !idx.isValid() || TableTranslator::isType(idx) ) {
newTable = m->addAction( "Create Table" );
if( TableTranslator::isType(idx) ) {
newTableInherit = m->addAction( "Create Inherited Table" );
table = TableTranslator::data(idx).mTable;
}
}
if( StandardTranslator::isType(idx) ) {
QString name = idx.data(Qt::DisplayRole).toString();
table = TableTranslator::data(idx.parent()).mTable;
if( name == "Fields" )
newField = m->addAction( "Create Field/Variable" );
if( name == "Indexes" )
newIndex = m->addAction( "Create Index" );
}
if( TableTranslator::isType(idx) ) {
m->addSeparator();
modifyTable = m->addAction( "Modify Table" );
removeTable = m->addAction( "Remove Table" );
m->addSeparator();
createVerifyTable = m->addAction( "Create or Verify Table in Database..." );
}
if( FieldTranslator::isType(idx) ) {
modifyField = m->addAction( "Modify Field" );
removeField = m->addAction( "Remove Field" );
} else if ( IndexTranslator::isType(idx) ) {
modifyIndex = m->addAction( "Modify Index" );
removeIndex = m->addAction( "Remove Index" );
}
QAction * res = m->exec( QCursor::pos() );
if( !res ) {
delete m;
return;
}
if( res == newTable ) {
addTable( TableDialog::createTable( this, mSchema, 0 ) );
} else if( res == newTableInherit ) {
addTable( TableDialog::createTable( this, mSchema, table ) );
} else if( res == modifyTable ) {
if( TableDialog::modifyTable( this, table ) ) {
mModel->dataChange(idx);
mChanges = true;
}
} else if( res == removeTable ) {
mModel->remove(idx);
delete table;
mChanges = true;
} else if( res == createVerifyTable ) {
slotCreateDatabase( table );
} else if( res == newField ) {
addField( FieldDialog::createField( this, table ) );
} else if( res == modifyField ) {
if( FieldDialog::modifyField( this, FieldTranslator::data(idx).mField ) ) {
mModel->dataChange(idx);
mChanges = true;
}
} else if( res == removeField ) {
Field * f = FieldTranslator::data(idx).mField;
mModel->remove(idx);
delete f;
mChanges = true;
} else if( res == newIndex ) {
addIndex( IndexDialog::createIndex( this, table ) );
} else if( res == modifyIndex ) {
if( IndexDialog::modifyIndex( this, IndexTranslator::data(idx).mIndex ) ) {
mModel->dataChange(idx);
mChanges = true;
}
} else if( res == removeIndex ) {
IndexSchema * i = IndexTranslator::data(idx).mIndex;
mModel->remove(idx);
delete i;
mChanges = true;
}
delete m;
}
void Model::addTriangle(uint16_t a, uint16_t b, uint16_t c) {
addIndex(a);
addIndex(b);
addIndex(c);
}
void BoundingBox::createGeometry()
{
// create the vertices
float halfx = _dimensions.x()/2;
float halfy = _dimensions.y()/2;
float halfz = _dimensions.z()/2;
//unsigned int col = 0x55555555; // pure white and opaque
/* the cube:
v5-----------v6
/ | / |
/ | / |
v2----------v1 |
| | | |
| | | |
| v4--------|--v7
| / | /
|/ | /
v3-----------v0
*/
// front vertices:
addVertex(Vertex( halfx, -halfy, -halfz, 1.0f, 1.0f, 1.0f));
addVertex(Vertex( halfx, halfy, -halfz, 1.0f, 1.0f, 1.0f));
addVertex(Vertex(-halfx, halfy, -halfz, 1.0f, 1.0f, 1.0f));
addVertex(Vertex(-halfx, -halfy, -halfz, 1.0f, 1.0f, 1.0f));
// back vertices:
addVertex(Vertex(-halfx, -halfy, halfz, 1.0f, 1.0f, 1.0f));
addVertex(Vertex(-halfx, halfy, halfz, 1.0f, 1.0f, 1.0f));
addVertex(Vertex( halfx, halfy, halfz, 1.0f, 1.0f, 1.0f));
addVertex(Vertex( halfx, -halfy, halfz, 1.0f, 1.0f, 1.0f));
// create the indices for the lines
// front
addIndex(0); addIndex(1);
addIndex(1); addIndex(2);
addIndex(2); addIndex(3);
addIndex(3); addIndex(0);
// left
addIndex(3); addIndex(2);
addIndex(2); addIndex(5);
addIndex(5); addIndex(4);
addIndex(4); addIndex(3);
// right
addIndex(7); addIndex(6);
addIndex(6); addIndex(1);
addIndex(1); addIndex(0);
addIndex(0); addIndex(7);
// back
addIndex(4); addIndex(5);
addIndex(5); addIndex(6);
addIndex(6); addIndex(7);
addIndex(7); addIndex(4);
}
void run() {
Client::WriteContext ctx(ns());
const int N = 5000;
for (int i = 0; i < N; ++i) {
insert(BSON("foo" << (i % 10)));
}
addIndex(BSON("foo" << 1));
// Plan 0: IXScan over foo == 7
// Every call to work() returns something so this should clearly win (by current scoring
// at least).
IndexScanParams ixparams;
ixparams.descriptor = getIndex(BSON("foo" << 1));
ixparams.bounds.isSimpleRange = true;
ixparams.bounds.startKey = BSON("" << 7);
ixparams.bounds.endKey = BSON("" << 7);
ixparams.bounds.endKeyInclusive = true;
ixparams.direction = 1;
auto_ptr<WorkingSet> firstWs(new WorkingSet());
IndexScan* ix = new IndexScan(ixparams, firstWs.get(), NULL);
auto_ptr<PlanStage> firstRoot(new FetchStage(firstWs.get(), ix, NULL));
// Plan 1: CollScan with matcher.
CollectionScanParams csparams;
csparams.ns = ns();
csparams.direction = CollectionScanParams::FORWARD;
auto_ptr<WorkingSet> secondWs(new WorkingSet());
// Make the filter.
BSONObj filterObj = BSON("foo" << 7);
StatusWithMatchExpression swme = MatchExpressionParser::parse(filterObj);
verify(swme.isOK());
auto_ptr<MatchExpression> filter(swme.getValue());
// Make the stage.
auto_ptr<PlanStage> secondRoot(new CollectionScan(csparams, secondWs.get(),
filter.get()));
// Hand the plans off to the runner.
CanonicalQuery* cq = NULL;
verify(CanonicalQuery::canonicalize(ns(), BSON("foo" << 7), &cq).isOK());
verify(NULL != cq);
MultiPlanRunner mpr(ctx.ctx().db()->getCollection(ns()),cq);
mpr.addPlan(createQuerySolution(), firstRoot.release(), firstWs.release());
mpr.addPlan(createQuerySolution(), secondRoot.release(), secondWs.release());
// Plan 0 aka the first plan aka the index scan should be the best.
size_t best;
ASSERT(mpr.pickBestPlan(&best));
ASSERT_EQUALS(size_t(0), best);
// Get all our results out.
int results = 0;
BSONObj obj;
while (Runner::RUNNER_ADVANCED == mpr.getNext(&obj, NULL)) {
ASSERT_EQUALS(obj["foo"].numberInt(), 7);
++results;
}
ASSERT_EQUALS(results, N / 10);
}
void run() {
// insert documents with a: 1 and b: 1
for (size_t i = 0; i < 1000; ++i) {
insert(BSON("a" << 1 << "b" << 1));
}
// insert documents with a: 1 and b: 2
for (size_t i = 0; i < 1000; ++i) {
insert(BSON("a" << 1 << "b" << 2));
}
// insert documents with a: 2 and b: 1
for (size_t i = 0; i < 1000; ++i) {
insert(BSON("a" << 2 << "b" << 1));
}
// insert documents with a: 2 and b: 3
for (size_t i = 0; i < 1000; ++i) {
insert(BSON("a" << 2 << "b" << 3));
}
addIndex(BSON("a" << 1 << "b" << 1));
AutoGetCollectionForReadCommand ctx(&_opCtx, nss);
Collection* coll = ctx.getCollection();
std::vector<const IndexDescriptor*> indices;
coll->getIndexCatalog()->findIndexesByKeyPattern(
&_opCtx, BSON("a" << 1 << "b" << 1), false, &indices);
ASSERT_EQ(1U, indices.size());
DistinctParams params{&_opCtx, indices[0]};
params.scanDirection = 1;
params.fieldNo = 1;
params.bounds.isSimpleRange = false;
OrderedIntervalList aOil{"a"};
aOil.intervals.push_back(IndexBoundsBuilder::allValues());
params.bounds.fields.push_back(aOil);
OrderedIntervalList bOil{"b"};
bOil.intervals.push_back(IndexBoundsBuilder::allValues());
params.bounds.fields.push_back(bOil);
WorkingSet ws;
DistinctScan distinct(&_opCtx, std::move(params), &ws);
WorkingSetID wsid;
PlanStage::StageState state;
std::vector<int> seen;
while (PlanStage::IS_EOF != (state = distinct.work(&wsid))) {
ASSERT_NE(PlanStage::FAILURE, state);
if (PlanStage::ADVANCED == state) {
seen.push_back(getIntFieldDotted(ws, wsid, "b"));
}
}
ASSERT_EQUALS(4U, seen.size());
ASSERT_EQUALS(1, seen[0]);
ASSERT_EQUALS(2, seen[1]);
ASSERT_EQUALS(1, seen[2]);
ASSERT_EQUALS(3, seen[3]);
}
int loadElf(int cpuf, int fd, unsigned int *entry_p, unsigned int *stack_p, int verbose)
{
unsigned char buf[BUF_SIZE];
int ReadBytes = 0, err = 0;
//EntryPoint
err = lseek(fd, 0x18, SEEK_SET);
if(err < 0)
{
printf("error lseek(0x18) loadElf\n");
return 1;
}
err = read(fd, &buf, 4);
if(err != 4)
{
printf("error read(4) loadElf\n");
return 1;
}
*entry_p = buf[0]|buf[1]<<8|buf[2]<<16|buf[3]<<24;
//printf("EntryPoint is 0x%08X\n", *entry_p);
//seek to the table address field
err = lseek(fd, 0x20, SEEK_SET);
if(err < 0)
{
printf("error lseek(0x18) loadElf\n");
return 1;
}
err = read(fd, &buf, 4);
if(err != 4)
{
printf("error read(4) loadElf\n");
return 1;
}
unsigned int TableAddress = buf[0]|buf[1]<<8|buf[2]<<16|buf[3]<<24;
//printf("TableAddress is 0x%08X\n", TableAddress);
err = lseek(fd, TableAddress, SEEK_SET);
if(err < 0)
{
printf("error lseek(TableAdress) loadElf\n");
return 1;
}
while( (ReadBytes = read(fd, &buf, 10 * sizeof(int))) == (10 * sizeof(int)) ) {
unsigned int IncreasingNumber = buf[0] | buf[1]<<8 | buf[2]<<16 | buf[3]<<24;
unsigned int Flags = buf[4] | buf[5]<<8 | buf[6]<<16 | buf[7]<<24;
unsigned int DontKnow2 = buf[8] | buf[9]<<8 | buf[10]<<16 | buf[11]<<24;
unsigned int DestinationAddress = buf[12] | buf[13]<<8 | buf[14]<<16 | buf[15]<<24;
unsigned int SourceAddress = buf[16] | buf[17]<<8 | buf[18]<<16 | buf[19]<<24;
unsigned int Size = buf[20] | buf[21]<<8 | buf[22]<<16 | buf[23]<<24;
unsigned int DontKnow3 = buf[24] | buf[25]<<8 | buf[26]<<16 | buf[27]<<24;
unsigned int DontKnow4 = buf[28] | buf[29]<<8 | buf[30]<<16 | buf[31]<<24;
unsigned int Alignment = buf[32] | buf[33]<<8 | buf[34]<<16 | buf[35]<<24;
unsigned int DontKnow5 = buf[36] | buf[37]<<8 | buf[38]<<16 | buf[39]<<24;
if(DestinationAddress == 0x00 && SourceAddress != 0x00) {
//Source Address is address of description
err = readDescription(fd, SourceAddress, Size);
if(err != 0) return 1;
break; //Exit While
} else {
//Add Index to Table
addIndex(DestinationAddress, SourceAddress, Size, Alignment,
Flags, DontKnow2);
}
}
if(ReadBytes != 10 * sizeof(int))
{
printf("error ReadBytes\n");
return 1;
}
//printTable();
err = sectionToSlave(cpuf, fd, entry_p);
if(err != 0) return 1;
//printf("start address = 0x%08X\n", *entry_p);
return 0;
}
void run() {
Client::WriteContext ctx(ns());
OperationContextImpl txn;
Database* db = ctx.ctx().db();
Collection* coll = db->getCollection(ns());
if (!coll) {
coll = db->createCollection(&txn, ns());
}
WorkingSet ws;
// Sort by foo:1
MergeSortStageParams msparams;
msparams.pattern = BSON("foo" << 1);
auto_ptr<MergeSortStage> ms(new MergeSortStage(msparams, &ws, coll));
IndexScanParams params;
params.bounds.isSimpleRange = true;
params.bounds.startKey = objWithMinKey(1);
params.bounds.endKey = objWithMaxKey(1);
params.bounds.endKeyInclusive = true;
params.direction = 1;
// Index 'a'+i has foo equal to 'i'.
int numIndices = 20;
for (int i = 0; i < numIndices; ++i) {
// 'a', 'b', ...
string index(1, 'a' + i);
insert(BSON(index << 1 << "foo" << i));
BSONObj indexSpec = BSON(index << 1 << "foo" << 1);
addIndex(indexSpec);
params.descriptor = getIndex(indexSpec, coll);
ms->addChild(new IndexScan(params, &ws, NULL));
}
set<DiskLoc> locs;
getLocs(&locs, coll);
set<DiskLoc>::iterator it = locs.begin();
// Get 10 results. Should be getting results in order of 'locs'.
int count = 0;
while (!ms->isEOF() && count < 10) {
WorkingSetID id = WorkingSet::INVALID_ID;
PlanStage::StageState status = ms->work(&id);
if (PlanStage::ADVANCED != status) { continue; }
WorkingSetMember* member = ws.get(id);
ASSERT_EQUALS(member->loc, *it);
BSONElement elt;
string index(1, 'a' + count);
ASSERT(member->getFieldDotted(index, &elt));
ASSERT_EQUALS(1, elt.numberInt());
ASSERT(member->getFieldDotted("foo", &elt));
ASSERT_EQUALS(count, elt.numberInt());
++count;
++it;
}
// Invalidate locs[11]. Should force a fetch. We don't get it back.
ms->prepareToYield();
ms->invalidate(*it, INVALIDATION_DELETION);
ms->recoverFromYield();
// Make sure locs[11] was fetched for us.
{
// TODO: If we have "return upon invalidation" ever triggerable, do the following test.
/*
WorkingSetID id = WorkingSet::INVALID_ID;
PlanStage::StageState status;
do {
status = ms->work(&id);
} while (PlanStage::ADVANCED != status);
WorkingSetMember* member = ws.get(id);
ASSERT(!member->hasLoc());
ASSERT(member->hasObj());
string index(1, 'a' + count);
BSONElement elt;
ASSERT_TRUE(member->getFieldDotted(index, &elt));
ASSERT_EQUALS(1, elt.numberInt());
ASSERT(member->getFieldDotted("foo", &elt));
ASSERT_EQUALS(count, elt.numberInt());
*/
++it;
++count;
}
// And get the rest.
while (!ms->isEOF()) {
WorkingSetID id = WorkingSet::INVALID_ID;
PlanStage::StageState status = ms->work(&id);
if (PlanStage::ADVANCED != status) { continue; }
WorkingSetMember* member = ws.get(id);
ASSERT_EQUALS(member->loc, *it);
BSONElement elt;
string index(1, 'a' + count);
ASSERT_TRUE(member->getFieldDotted(index, &elt));
ASSERT_EQUALS(1, elt.numberInt());
ASSERT(member->getFieldDotted("foo", &elt));
ASSERT_EQUALS(count, elt.numberInt());
++count;
++it;
}
}
void run() {
Client::WriteContext ctx(ns());
Database* db = ctx.ctx().db();
Collection* coll = db->getCollection(ns());
if (!coll) {
coll = db->createCollection(ns());
}
for (int i = 0; i < 50; ++i) {
insert(BSON("_id" << i << "foo" << i << "bar" << i << "baz" << i));
}
addIndex(BSON("foo" << 1));
addIndex(BSON("bar" << 1));
addIndex(BSON("baz" << 1));
WorkingSet ws;
scoped_ptr<AndHashStage> ah(new AndHashStage(&ws, NULL));
// Foo <= 20 (descending)
IndexScanParams params;
params.descriptor = getIndex(BSON("foo" << 1), coll);
params.bounds.isSimpleRange = true;
params.bounds.startKey = BSON("" << 20);
params.bounds.endKey = BSONObj();
params.bounds.endKeyInclusive = true;
params.direction = -1;
ah->addChild(new IndexScan(params, &ws, NULL));
// Bar <= 19 (descending)
params.descriptor = getIndex(BSON("bar" << 1), coll);
params.bounds.startKey = BSON("" << 19);
ah->addChild(new IndexScan(params, &ws, NULL));
// First call to work reads the first result from the children.
// The first result is for the first scan over foo is {foo: 20, bar: 20, baz: 20}.
// The first result is for the second scan over bar is {foo: 19, bar: 19, baz: 19}.
WorkingSetID id;
PlanStage::StageState status = ah->work(&id);
ASSERT_EQUALS(PlanStage::NEED_TIME, status);
const unordered_set<WorkingSetID>& flagged = ws.getFlagged();
ASSERT_EQUALS(size_t(0), flagged.size());
// "delete" deletedObj (by invalidating the DiskLoc of the obj that matches it).
BSONObj deletedObj = BSON("_id" << 20 << "foo" << 20 << "bar" << 20 << "baz" << 20);
ah->prepareToYield();
set<DiskLoc> data;
getLocs(&data, coll);
for (set<DiskLoc>::const_iterator it = data.begin(); it != data.end(); ++it) {
if (0 == deletedObj.woCompare(it->obj())) {
ah->invalidate(*it, INVALIDATION_DELETION);
break;
}
}
ah->recoverFromYield();
// The deleted obj should show up in flagged.
ASSERT_EQUALS(size_t(1), flagged.size());
// And not in our results.
int count = 0;
while (!ah->isEOF()) {
WorkingSetID id;
PlanStage::StageState status = ah->work(&id);
if (PlanStage::ADVANCED != status) { continue; }
WorkingSetMember* wsm = ws.get(id);
ASSERT_NOT_EQUALS(0, deletedObj.woCompare(wsm->loc.obj()));
++count;
}
ASSERT_EQUALS(count, 20);
}
void GeometryBuffer::addIndex(uint16 index)
{
return addIndex((uint8*) &index, sizeof(uint16));
}
void GeometryBuffer::setIndex(uint8* buf, uint32 size)
{
indexData.clear();
addIndex(buf, size);
forceRebuild();
}
