mirror of
https://github.com/mongodb/mongo.git
synced 2024-11-28 16:24:56 +01:00
227 lines
8.2 KiB
JavaScript
227 lines
8.2 KiB
JavaScript
// shard2.js
|
|
|
|
/**
|
|
* test basic sharding
|
|
*/
|
|
|
|
placeCheck = function( num ){
|
|
print("shard2 step: " + num );
|
|
}
|
|
|
|
printAll = function(){
|
|
print( "****************" );
|
|
db.foo.find().forEach( printjsononeline )
|
|
print( "++++++++++++++++++" );
|
|
primary.foo.find().forEach( printjsononeline )
|
|
print( "++++++++++++++++++" );
|
|
secondary.foo.find().forEach( printjsononeline )
|
|
print( "---------------------" );
|
|
}
|
|
|
|
s = new ShardingTest( "shard2" , 2 , 2 );
|
|
|
|
// We're doing a lot of checks here that can get screwed up by the balancer, now that
|
|
// it moves small #s of chunks too
|
|
s.stopBalancer()
|
|
|
|
db = s.getDB( "test" );
|
|
|
|
s.adminCommand( { enablesharding : "test" } );
|
|
s.adminCommand( { shardcollection : "test.foo" , key : { num : 1 } } );
|
|
assert.eq( 1 , s.config.chunks.count() , "sanity check 1" );
|
|
|
|
s.adminCommand( { split : "test.foo" , middle : { num : 0 } } );
|
|
assert.eq( 2 , s.config.chunks.count() , "should be 2 shards" );
|
|
chunks = s.config.chunks.find().toArray();
|
|
assert.eq( chunks[0].shard , chunks[1].shard , "server should be the same after a split" );
|
|
|
|
|
|
db.foo.save( { num : 1 , name : "eliot" } );
|
|
db.foo.save( { num : 2 , name : "sara" } );
|
|
db.foo.save( { num : -1 , name : "joe" } );
|
|
|
|
assert.eq( 3 , s.getServer( "test" ).getDB( "test" ).foo.find().length() , "not right directly to db A" );
|
|
assert.eq( 3 , db.foo.find().length() , "not right on shard" );
|
|
|
|
primary = s.getServer( "test" ).getDB( "test" );
|
|
secondary = s.getOther( primary ).getDB( "test" );
|
|
|
|
assert.eq( 3 , primary.foo.find().length() , "primary wrong B" );
|
|
assert.eq( 0 , secondary.foo.find().length() , "secondary wrong C" );
|
|
assert.eq( 3 , db.foo.find().sort( { num : 1 } ).length() );
|
|
|
|
placeCheck( 2 );
|
|
|
|
// NOTE: at this point we have 2 shard on 1 server
|
|
|
|
// test move shard
|
|
assert.throws( function(){ s.adminCommand( { movechunk : "test.foo" , find : { num : 1 } , to : primary.getMongo().name, _waitForDelete : true } ); } );
|
|
assert.throws( function(){ s.adminCommand( { movechunk : "test.foo" , find : { num : 1 } , to : "adasd", _waitForDelete : true } ) } );
|
|
|
|
s.adminCommand( { movechunk : "test.foo" , find : { num : 1 } , to : secondary.getMongo().name, _waitForDelete : true } );
|
|
assert.eq( 2 , secondary.foo.find().length() , "secondary should have 2 after move shard" );
|
|
assert.eq( 1 , primary.foo.find().length() , "primary should only have 1 after move shard" );
|
|
|
|
assert.eq( 2 , s.config.chunks.count() , "still should have 2 shards after move not:" + s.getChunksString() );
|
|
chunks = s.config.chunks.find().toArray();
|
|
assert.neq( chunks[0].shard , chunks[1].shard , "servers should NOT be the same after the move" );
|
|
|
|
placeCheck( 3 );
|
|
|
|
// test inserts go to right server/shard
|
|
|
|
assert.writeOK(db.foo.save( { num : 3 , name : "bob" } ));
|
|
assert.eq( 1 , primary.foo.find().length() , "after move insert go wrong place?" );
|
|
assert.eq( 3 , secondary.foo.find().length() , "after move insert go wrong place?" );
|
|
|
|
assert.writeOK(db.foo.save( { num : -2 , name : "funny man" } ));
|
|
assert.eq( 2 , primary.foo.find().length() , "after move insert go wrong place?" );
|
|
assert.eq( 3 , secondary.foo.find().length() , "after move insert go wrong place?" );
|
|
|
|
|
|
assert.writeOK(db.foo.save( { num : 0 , name : "funny guy" } ));
|
|
assert.eq( 2 , primary.foo.find().length() , "boundary A" );
|
|
assert.eq( 4 , secondary.foo.find().length() , "boundary B" );
|
|
|
|
placeCheck( 4 );
|
|
|
|
// findOne
|
|
assert.eq( "eliot" , db.foo.findOne( { num : 1 } ).name );
|
|
assert.eq( "funny man" , db.foo.findOne( { num : -2 } ).name );
|
|
|
|
// getAll
|
|
function sumQuery( c ){
|
|
var sum = 0;
|
|
c.toArray().forEach(
|
|
function(z){
|
|
sum += z.num;
|
|
}
|
|
);
|
|
return sum;
|
|
}
|
|
assert.eq( 6 , db.foo.find().length() , "sharded query 1" );
|
|
assert.eq( 3 , sumQuery( db.foo.find() ) , "sharded query 2" );
|
|
|
|
placeCheck( 5 );
|
|
|
|
// sort by num
|
|
|
|
assert.eq( 3 , sumQuery( db.foo.find().sort( { num : 1 } ) ) , "sharding query w/sort 1" );
|
|
assert.eq( 3 , sumQuery( db.foo.find().sort( { num : -1 } ) ) , "sharding query w/sort 2" );
|
|
|
|
assert.eq( "funny man" , db.foo.find().sort( { num : 1 } )[0].name , "sharding query w/sort 3 order wrong" );
|
|
assert.eq( -2 , db.foo.find().sort( { num : 1 } )[0].num , "sharding query w/sort 4 order wrong" );
|
|
|
|
assert.eq( "bob" , db.foo.find().sort( { num : -1 } )[0].name , "sharding query w/sort 5 order wrong" );
|
|
assert.eq( 3 , db.foo.find().sort( { num : -1 } )[0].num , "sharding query w/sort 6 order wrong" );
|
|
|
|
placeCheck( 6 );
|
|
// sory by name
|
|
|
|
function getNames( c ){
|
|
return c.toArray().map( function(z){ return z.name; } );
|
|
}
|
|
correct = getNames( db.foo.find() ).sort();
|
|
assert.eq( correct , getNames( db.foo.find().sort( { name : 1 } ) ) );
|
|
correct = correct.reverse();
|
|
assert.eq( correct , getNames( db.foo.find().sort( { name : -1 } ) ) );
|
|
|
|
assert.eq( 3 , sumQuery( db.foo.find().sort( { name : 1 } ) ) , "sharding query w/non-shard sort 1" );
|
|
assert.eq( 3 , sumQuery( db.foo.find().sort( { name : -1 } ) ) , "sharding query w/non-shard sort 2" );
|
|
|
|
|
|
// sort by num multiple shards per server
|
|
s.adminCommand( { split : "test.foo" , middle : { num : 2 } } );
|
|
assert.eq( "funny man" , db.foo.find().sort( { num : 1 } )[0].name , "sharding query w/sort and another split 1 order wrong" );
|
|
assert.eq( "bob" , db.foo.find().sort( { num : -1 } )[0].name , "sharding query w/sort and another split 2 order wrong" );
|
|
assert.eq( "funny man" , db.foo.find( { num : { $lt : 100 } } ).sort( { num : 1 } ).arrayAccess(0).name , "sharding query w/sort and another split 3 order wrong" );
|
|
|
|
placeCheck( 7 );
|
|
|
|
db.foo.find().sort( { _id : 1 } ).forEach( function(z){ print( z._id ); } )
|
|
|
|
zzz = db.foo.find().explain("executionStats").executionStats;
|
|
assert.eq( 0 , zzz.totalKeysExamined , "EX1a" )
|
|
assert.eq( 6 , zzz.nReturned , "EX1b" )
|
|
assert.eq( 6 , zzz.totalDocsExamined , "EX1c" )
|
|
|
|
zzz = db.foo.find().hint( { _id : 1 } ).sort( { _id : 1 } )
|
|
.explain("executionStats").executionStats;
|
|
assert.eq( 6 , zzz.totalKeysExamined , "EX2a" )
|
|
assert.eq( 6 , zzz.nReturned , "EX2b" )
|
|
assert.eq( 6 , zzz.totalDocsExamined , "EX2c" )
|
|
|
|
// getMore
|
|
assert.eq( 4 , db.foo.find().limit(-4).toArray().length , "getMore 1" );
|
|
function countCursor( c ){
|
|
var num = 0;
|
|
while ( c.hasNext() ){
|
|
c.next();
|
|
num++;
|
|
}
|
|
return num;
|
|
}
|
|
assert.eq( 6 , countCursor( db.foo.find()._exec() ) , "getMore 2" );
|
|
assert.eq( 6 , countCursor( db.foo.find().batchSize(1)._exec() ) , "getMore 3" );
|
|
|
|
// find by non-shard-key
|
|
db.foo.find().forEach(
|
|
function(z){
|
|
var y = db.foo.findOne( { _id : z._id } );
|
|
assert( y , "_id check 1 : " + tojson( z ) );
|
|
assert.eq( z.num , y.num , "_id check 2 : " + tojson( z ) );
|
|
}
|
|
);
|
|
|
|
// update
|
|
person = db.foo.findOne( { num : 3 } );
|
|
assert.eq( "bob" , person.name , "update setup 1" );
|
|
person.name = "bob is gone";
|
|
db.foo.update( { num : 3 } , person );
|
|
person = db.foo.findOne( { num : 3 } );
|
|
assert.eq( "bob is gone" , person.name , "update test B" );
|
|
|
|
// remove
|
|
assert( db.foo.findOne( { num : 3 } ) != null , "remove test A" );
|
|
db.foo.remove( { num : 3 } );
|
|
assert.isnull( db.foo.findOne( { num : 3 } ) , "remove test B" );
|
|
|
|
db.foo.save( { num : 3 , name : "eliot2" } );
|
|
person = db.foo.findOne( { num : 3 } );
|
|
assert( person , "remove test C" );
|
|
assert.eq( person.name , "eliot2" );
|
|
|
|
db.foo.remove( { _id : person._id } );
|
|
assert.isnull( db.foo.findOne( { num : 3 } ) , "remove test E" );
|
|
|
|
placeCheck( 8 );
|
|
|
|
// more update stuff
|
|
|
|
printAll();
|
|
total = db.foo.find().count();
|
|
var res = assert.writeOK(db.foo.update( {}, { $inc: { x: 1 } }, false, true ));
|
|
printAll();
|
|
assert.eq( total , res.nModified, res.toString() );
|
|
|
|
|
|
res = db.foo.update( { num : -1 } , { $inc : { x : 1 } } , false , true );
|
|
assert.eq( 1, res.nModified, res.toString() );
|
|
|
|
// ---- move all to the secondary
|
|
|
|
assert.eq( 2 , s.onNumShards( "foo" ) , "on 2 shards" );
|
|
|
|
secondary.foo.insert( { num : -3 } );
|
|
|
|
s.adminCommand( { movechunk : "test.foo" , find : { num : -2 } , to : secondary.getMongo().name, _waitForDelete : true } );
|
|
assert.eq( 1 , s.onNumShards( "foo" ) , "on 1 shards" );
|
|
|
|
s.adminCommand( { movechunk : "test.foo" , find : { num : -2 } , to : primary.getMongo().name, _waitForDelete : true } );
|
|
assert.eq( 2 , s.onNumShards( "foo" ) , "on 2 shards again" );
|
|
assert.eq( 3 , s.config.chunks.count() , "only 3 chunks" );
|
|
|
|
print( "YO : " + tojson( db.runCommand( "serverStatus" ) ) );
|
|
|
|
s.stop();
|