244 lines
7.2 KiB
JavaScript
244 lines
7.2 KiB
JavaScript
(function() {
|
|
|
|
var s = new ShardingTest({name: "features1", shards: 2, mongos: 1});
|
|
|
|
s.adminCommand({enablesharding: "test"});
|
|
s.ensurePrimaryShard('test', 'shard0001');
|
|
|
|
// ---- can't shard system namespaces ----
|
|
|
|
assert(!s.admin.runCommand({shardcollection: "test.system.blah", key: {num: 1}}).ok,
|
|
"shard system namespace");
|
|
|
|
// ---- setup test.foo -----
|
|
|
|
s.adminCommand({shardcollection: "test.foo", key: {num: 1}});
|
|
|
|
db = s.getDB("test");
|
|
|
|
a = s._connections[0].getDB("test");
|
|
b = s._connections[1].getDB("test");
|
|
|
|
db.foo.ensureIndex({y: 1});
|
|
|
|
s.adminCommand({split: "test.foo", middle: {num: 10}});
|
|
s.adminCommand(
|
|
{movechunk: "test.foo", find: {num: 20}, to: s.getOther(s.getPrimaryShard("test")).name});
|
|
|
|
db.foo.save({num: 5});
|
|
db.foo.save({num: 15});
|
|
|
|
s.sync();
|
|
|
|
// ---- make sure shard key index is everywhere ----
|
|
|
|
assert.eq(3, a.foo.getIndexKeys().length, "a index 1");
|
|
assert.eq(3, b.foo.getIndexKeys().length, "b index 1");
|
|
|
|
// ---- make sure if you add an index it goes everywhere ------
|
|
|
|
db.foo.ensureIndex({x: 1});
|
|
|
|
s.sync();
|
|
|
|
assert.eq(4, a.foo.getIndexKeys().length, "a index 2");
|
|
assert.eq(4, b.foo.getIndexKeys().length, "b index 2");
|
|
|
|
// ---- no unique indexes ------
|
|
|
|
db.foo.ensureIndex({z: 1}, true);
|
|
|
|
s.sync();
|
|
|
|
assert.eq(4, a.foo.getIndexKeys().length, "a index 3");
|
|
assert.eq(4, b.foo.getIndexKeys().length, "b index 3");
|
|
|
|
db.foo.ensureIndex({num: 1, bar: 1}, true);
|
|
s.sync();
|
|
assert.eq(5, b.foo.getIndexKeys().length, "c index 3");
|
|
|
|
// ---- can't shard thing with unique indexes
|
|
|
|
db.foo2.ensureIndex({a: 1});
|
|
s.sync();
|
|
printjson(db.foo2.getIndexes());
|
|
assert(s.admin.runCommand({shardcollection: "test.foo2", key: {num: 1}}).ok,
|
|
"shard with index");
|
|
|
|
db.foo3.ensureIndex({a: 1}, true);
|
|
s.sync();
|
|
printjson(db.foo3.getIndexes());
|
|
assert(!s.admin.runCommand({shardcollection: "test.foo3", key: {num: 1}}).ok,
|
|
"shard with unique index");
|
|
|
|
db.foo7.ensureIndex({num: 1, a: 1}, true);
|
|
s.sync();
|
|
printjson(db.foo7.getIndexes());
|
|
assert(s.admin.runCommand({shardcollection: "test.foo7", key: {num: 1}}).ok,
|
|
"shard with ok unique index");
|
|
|
|
// ----- eval -----
|
|
|
|
db.foo2.save({num: 5, a: 7});
|
|
db.foo3.save({num: 5, a: 8});
|
|
|
|
assert.eq(1, db.foo3.count(), "eval pre1");
|
|
assert.eq(1, db.foo2.count(), "eval pre2");
|
|
|
|
assert.eq(8,
|
|
db.eval(function() {
|
|
return db.foo3.findOne().a;
|
|
}),
|
|
"eval 1 ");
|
|
assert.throws(function() {
|
|
db.eval(function() {
|
|
return db.foo2.findOne().a;
|
|
});
|
|
}, [], "eval 2");
|
|
|
|
assert.eq(1,
|
|
db.eval(function() {
|
|
return db.foo3.count();
|
|
}),
|
|
"eval 3 ");
|
|
assert.throws(function() {
|
|
db.eval(function() {
|
|
return db.foo2.count();
|
|
});
|
|
}, [], "eval 4");
|
|
|
|
// ----- "eval" new command name SERVER-5588 -----
|
|
var result;
|
|
result = db.runCommand({
|
|
eval: function() {
|
|
return db.foo3.count();
|
|
}
|
|
}); // non-sharded collection
|
|
assert.eq(1, result.ok, "eval should work for non-sharded collection in cluster");
|
|
|
|
result = db.runCommand({
|
|
eval: function() {
|
|
return db.foo2.count();
|
|
}
|
|
}); // sharded collection
|
|
assert.eq(0, result.ok, "eval should not work for sharded collection in cluster");
|
|
|
|
// ---- unique shard key ----
|
|
|
|
assert(s.admin.runCommand({shardcollection: "test.foo4", key: {num: 1}, unique: true}).ok,
|
|
"shard with index and unique");
|
|
s.adminCommand({split: "test.foo4", middle: {num: 10}});
|
|
|
|
s.admin.runCommand(
|
|
{movechunk: "test.foo4", find: {num: 20}, to: s.getOther(s.getPrimaryShard("test")).name});
|
|
|
|
assert.writeOK(db.foo4.save({num: 5}));
|
|
assert.writeOK(db.foo4.save({num: 15}));
|
|
s.sync();
|
|
assert.eq(1, a.foo4.count(), "ua1");
|
|
assert.eq(1, b.foo4.count(), "ub1");
|
|
|
|
assert.eq(2, a.foo4.getIndexes().length, "ua2");
|
|
assert.eq(2, b.foo4.getIndexes().length, "ub2");
|
|
|
|
assert(a.foo4.getIndexes()[1].unique, "ua3");
|
|
assert(b.foo4.getIndexes()[1].unique, "ub3");
|
|
|
|
assert.eq(2, db.foo4.count(), "uc1");
|
|
db.foo4.save({num: 7});
|
|
assert.eq(3, db.foo4.count(), "uc2");
|
|
assert.writeError(db.foo4.save({num: 7}));
|
|
assert.eq(3, db.foo4.count(), "uc4");
|
|
|
|
// --- don't let you convertToCapped ----
|
|
assert(!db.foo4.isCapped(), "ca1");
|
|
assert(!a.foo4.isCapped(), "ca2");
|
|
assert(!b.foo4.isCapped(), "ca3");
|
|
assert(!db.foo4.convertToCapped(30000).ok, "ca30");
|
|
assert(!db.foo4.isCapped(), "ca4");
|
|
assert(!a.foo4.isCapped(), "ca5");
|
|
assert(!b.foo4.isCapped(), "ca6");
|
|
|
|
// make sure i didn't break anything
|
|
db.foo4a.save({a: 1});
|
|
assert(!db.foo4a.isCapped(), "ca7");
|
|
db.foo4a.convertToCapped(30000);
|
|
assert(db.foo4a.isCapped(), "ca8");
|
|
|
|
// --- don't let you shard a capped collection
|
|
|
|
db.createCollection("foo5", {capped: true, size: 30000});
|
|
assert(db.foo5.isCapped(), "cb1");
|
|
var res = s.admin.runCommand({shardcollection: "test.foo5", key: {num: 1}});
|
|
assert(!res.ok, "shard capped: " + tojson(res));
|
|
|
|
// ----- group ----
|
|
|
|
db.foo6.save({a: 1});
|
|
db.foo6.save({a: 3});
|
|
db.foo6.save({a: 3});
|
|
db.foo6.ensureIndex({a: 1});
|
|
s.sync();
|
|
printjson(db.foo6.getIndexes());
|
|
|
|
assert.eq(2,
|
|
db.foo6
|
|
.group({
|
|
key: {a: 1},
|
|
initial: {count: 0},
|
|
reduce: function(z, prev) {
|
|
prev.count++;
|
|
}
|
|
})
|
|
.length);
|
|
|
|
assert.eq(3, db.foo6.find().count());
|
|
assert(s.admin.runCommand({shardcollection: "test.foo6", key: {a: 1}}).ok);
|
|
assert.eq(3, db.foo6.find().count());
|
|
|
|
s.adminCommand({split: "test.foo6", middle: {a: 2}});
|
|
|
|
// movechunk commands are wrapped in assert.soon
|
|
// Sometimes the TO-side shard isn't immediately ready, this
|
|
// causes problems on slow hosts.
|
|
// Remove when SERVER-10232 is fixed
|
|
|
|
assert.soon(function() {
|
|
var cmdRes = s.admin.runCommand(
|
|
{movechunk: "test.foo6", find: {a: 3}, to: s.getOther(s.getPrimaryShard("test")).name});
|
|
return cmdRes.ok;
|
|
}, 'move chunk test.foo6', 60000, 1000);
|
|
|
|
assert.throws(function() {
|
|
db.foo6.group({
|
|
key: {a: 1},
|
|
initial: {count: 0},
|
|
reduce: function(z, prev) {
|
|
prev.count++;
|
|
}
|
|
});
|
|
});
|
|
|
|
// ---- can't shard non-empty collection without index -----
|
|
|
|
assert.writeOK(db.foo8.save({a: 1}));
|
|
assert(!s.admin.runCommand({shardcollection: "test.foo8", key: {a: 1}}).ok,
|
|
"non-empty collection");
|
|
|
|
// ---- can't shard non-empty collection with null values in shard key ----
|
|
|
|
assert.writeOK(db.foo9.save({b: 1}));
|
|
db.foo9.ensureIndex({a: 1});
|
|
assert(!s.admin.runCommand({shardcollection: "test.foo9", key: {a: 1}}).ok,
|
|
"entry with null value");
|
|
|
|
// --- listDatabases ---
|
|
|
|
r = db.getMongo().getDBs();
|
|
assert.eq(3, r.databases.length, tojson(r));
|
|
assert.eq("number", typeof(r.totalSize), "listDatabases 3 : " + tojson(r));
|
|
|
|
s.stop();
|
|
|
|
})();
|