267 lines
12 KiB
JavaScript
267 lines
12 KiB
JavaScript
// Tests for $elemMatch projections and $ positional operator projection.
|
|
t = db.SERVER828Test;
|
|
t.drop();
|
|
|
|
date1 = new Date();
|
|
|
|
// Insert various styles of arrays
|
|
for ( i = 0; i < 100; i++ ) {
|
|
t.insert({ group: 1, x: [ 1, 2, 3, 4, 5 ] });
|
|
t.insert({ group: 2, x: [ { a: 1, b: 2 }, { a: 2, c: 3 }, { a:1, d:5 } ] });
|
|
t.insert({ group: 3, x: [ { a: 1, b: 2 }, { a: 2, c: 3 }, { a:1, d:5 } ],
|
|
y: [ { aa: 1, bb: 2 }, { aa: 2, cc: 3 }, { aa:1, dd:5 } ] });
|
|
t.insert({ group: 3, x: [ { a: 1, b: 3 }, { a: -6, c: 3 } ] });
|
|
t.insert({ group: 4, x: [ { a: 1, b: 4 }, { a: -6, c: 3 } ] });
|
|
t.insert({ group: 5, x: [ new Date(), 5, 10, 'string', new ObjectId(), 123.456 ] });
|
|
t.insert({ group: 6, x: [ { a: 'string', b: date1 },
|
|
{ a: new ObjectId(), b: 1.2345 },
|
|
{ a: 'string2', b: date1 } ] });
|
|
t.insert({ group: 7, x: [ { y: [ 1, 2, 3, 4 ] } ] });
|
|
t.insert({ group: 8, x: [ { y: [ { a: 1, b: 2 }, {a: 3, b: 4} ] } ] });
|
|
t.insert({ group: 9, x: [ { y: [ { a: 1, b: 2 }, {a: 3, b: 4} ] },
|
|
{ z: [ { a: 1, b: 2 }, {a: 3, b: 4} ] } ] });
|
|
t.insert({ group: 10, x: [ { a: 1, b: 2 }, {a: 3, b: 4} ],
|
|
y: [ { c: 1, d: 2 }, {c: 3, d: 4} ] });
|
|
t.insert({ group: 10, x: [ { a: 1, b: 2 }, {a: 3, b: 4} ],
|
|
y: [ { c: 1, d: 2 }, {c: 3, d: 4} ] });
|
|
t.insert({ group: 11, x: [ { a: 1, b: 2 }, { a: 2, c: 3 }, { a:1, d:5 } ],
|
|
covered: [ { aa: 1, bb: 2 }, { aa: 2, cc: 3 }, { aa:1, dd:5 } ] });
|
|
t.insert({ group: 12, x: { y : [ { a: 1, b: 1 }, { a: 1, b: 2} ] } } );
|
|
t.insert({ group: 13, x: [ { a: 1, b: 1 }, {a: 1, b: 2 } ] } );
|
|
t.insert({ group: 13, x: [ { a: 1, b: 2 }, {a: 1, b: 1 } ] } );
|
|
}
|
|
t.ensureIndex({group:1, 'y.d':1}); // for regular index test (not sure if this is really adding anything useful)
|
|
t.ensureIndex({group:1, covered:1}); // for covered index test
|
|
|
|
//
|
|
// SERVER-828: Positional operator ($) projection tests
|
|
//
|
|
assert.eq( 1,
|
|
t.find( { group:3, 'x.a':2 }, { 'x.$':1 } ).toArray()[0].x.length,
|
|
"single object match (array length match)" );
|
|
|
|
assert.eq( 2,
|
|
t.find( { group:3, 'x.a':1 }, { 'x.$':1 } ).toArray()[0].x[0].b,
|
|
"single object match first" );
|
|
|
|
assert.eq( undefined,
|
|
t.find( { group:3, 'x.a':2 }, { _id:0, 'x.$':1 } ).toArray()[0]._id,
|
|
"single object match with filtered _id" );
|
|
|
|
assert.eq( 1,
|
|
t.find( { group:3, 'x.a':2 }, { 'x.$':1 } ).sort( { _id:1 } ).toArray()[0].x.length,
|
|
"sorted single object match with filtered _id (array length match)" );
|
|
|
|
assert.eq( 1,
|
|
t.find( { 'group':2, 'x': { '$elemMatch' : { 'a':1, 'b':2 } } }, { 'x.$':1 } ).toArray()[0].x.length,
|
|
"single object match with elemMatch" );
|
|
|
|
assert.eq( 1,
|
|
t.find( { 'group':2, 'x': { '$elemMatch' : { 'a':1, 'b':2 } } }, { 'x.$':{'$slice':1} } ).toArray()[0].x.length,
|
|
"single object match with elemMatch and positive slice" );
|
|
|
|
assert.eq( 1,
|
|
t.find( { 'group':2, 'x': { '$elemMatch' : { 'a':1, 'b':2 } } }, { 'x.$':{'$slice':-1} } ).toArray()[0].x.length,
|
|
"single object match with elemMatch and negative slice" );
|
|
|
|
assert.eq( 1,
|
|
t.find( { 'group':12, 'x.y.a':1 }, { 'x.y.$': 1 } ).toArray()[0].x.y.length,
|
|
"single object match with two level dot notation" );
|
|
|
|
assert.eq( 1,
|
|
t.find( { group:3, 'x.a':2 }, { 'x.$':1 } ).sort( { x:1 } ).toArray()[0].x.length,
|
|
"sorted object match (array length match)" );
|
|
|
|
assert.eq( { aa:1, dd:5 },
|
|
t.find( { group:3, 'y.dd':5 }, { 'y.$':1 } ).toArray()[0].y[0],
|
|
"single object match (value match)" );
|
|
|
|
assert.throws( function() {
|
|
t.find( { group:3, 'x.a':2 }, { 'y.$':1 } ).toArray();
|
|
}, [], "throw on invalid projection (field mismatch)" );
|
|
|
|
assert.throws( function() {
|
|
t.find( { group:3, 'x.a':2 }, { 'y.$':1 } ).sort( { x:1 } ).toArray()
|
|
}, [], "throw on invalid sorted projection (field mismatch)" );
|
|
|
|
assert.throws( function() {x
|
|
t.find( { group:3, 'x.a':2 }, { 'x.$':1, group:0 } ).sort( { x:1 } ).toArray();
|
|
}, [], "throw on invalid projection combination (include and exclude)" );
|
|
|
|
assert.throws( function() {
|
|
t.find( { group:3, 'x.a':1, 'y.aa':1 }, { 'x.$':1, 'y.$':1 } ).toArray();
|
|
}, [], "throw on multiple projections" );
|
|
|
|
assert.throws( function() {
|
|
t.find( { group:3}, { 'g.$':1 } ).toArray()
|
|
}, [], "throw on invalid projection (non-array field)" );
|
|
|
|
assert.eq( { aa:1, dd:5 },
|
|
t.find( { group:11, 'covered.dd':5 }, { 'covered.$':1 } ).toArray()[0].covered[0],
|
|
"single object match (covered index)" );
|
|
|
|
assert.eq( { aa:1, dd:5 },
|
|
t.find( { group:11, 'covered.dd':5 }, { 'covered.$':1 } ).sort( { covered:1 } ).toArray()[0].covered[0],
|
|
"single object match (sorted covered index)" );
|
|
|
|
assert.eq( 1,
|
|
t.find( { group:10, 'y.d': 4 }, { 'y.$':1 } ).toArray()[0].y.length,
|
|
"single object match (regular index" );
|
|
|
|
if (false) {
|
|
|
|
assert.eq( 2, // SERVER-1013: allow multiple positional operators
|
|
t.find( { group:3, 'y.bb':2, 'x.d':5 }, { 'y.$':1, 'x.$':1 } ).toArray()[0].y[0].bb,
|
|
"multi match, multi proj 1" );
|
|
|
|
assert.eq( 5, // SSERVER-1013: allow multiple positional operators
|
|
t.find( { group:3, 'y.bb':2, 'x.d':5 }, { 'y.$':1, 'x.$':1 } ).toArray()[0].x[0].d,
|
|
"multi match, multi proj 2" );
|
|
|
|
assert.eq( 2, // SERVER-1243: allow multiple results from same matcher
|
|
t.find( { group:2, x: { $elemMatchAll: { a:1 } } }, { 'x.$':1 } ).toArray()[0].x.length,
|
|
"multi element match, single proj" );
|
|
|
|
assert.eq( 2, // SERVER-1013: multiple array matches with one prositional operator
|
|
t.find( { group:3, 'y.bb':2, 'x.d':5 }, { 'y.$':1 } ).toArray()[0].y[0].bb,
|
|
"multi match, single proj 1" );
|
|
|
|
assert.eq( 2, // SERVER-1013: multiple array matches with one positional operator
|
|
t.find( { group:3, 'y.cc':3, 'x.b':2 }, { 'x.$':1 } ).toArray()[0].x[0].b,
|
|
"multi match, single proj 2" );
|
|
|
|
}
|
|
|
|
//
|
|
// SERVER-2238: $elemMatch projections
|
|
//
|
|
assert.eq( -6,
|
|
t.find( { group:4 }, { x: { $elemMatch: { a:-6 } } } ).toArray()[0].x[0].a,
|
|
"single object match" );
|
|
|
|
assert.eq( 1,
|
|
t.find( { group:4 }, { x: { $elemMatch: { a:-6 } } } ).toArray()[0].x.length,
|
|
"filters non-matching array elements" );
|
|
|
|
assert.eq( 1,
|
|
t.find( { group:4 }, { x: { $elemMatch: { a:-6, c:3 } } } ).toArray()[0].x.length,
|
|
"filters non-matching array elements with multiple elemMatch criteria" );
|
|
|
|
assert.eq( 1,
|
|
t.find( { group: 13 }, { 'x' : {'$elemMatch' : { a: {$gt: 0, $lt: 2} } } } ).toArray()[0].x.length,
|
|
"filters non-matching array elements with multiple criteria for a single element in the array" );
|
|
|
|
assert.eq( 3,
|
|
t.find( { group:4 }, { x: { $elemMatch: { a:{ $lt:1 } } } } ).toArray()[0].x[0].c,
|
|
"object operator match" );
|
|
|
|
assert.eq( [ 4 ],
|
|
t.find( { group:1 }, { x: { $elemMatch: { $in:[100, 4, -123] } } } ).toArray()[0].x,
|
|
"$in number match" );
|
|
|
|
assert.eq( [ {a : 1, b : 2} ],
|
|
t.find( { group:2 }, { x: { $elemMatch: { a: { $in:[1] } } } } ).toArray()[0].x,
|
|
"$in number match" );
|
|
|
|
assert.eq( [1],
|
|
t.find( { group:1 }, { x: { $elemMatch: { $nin:[4, 5, 6] } } } ).toArray()[0].x,
|
|
"$nin number match" );
|
|
|
|
// but this may become a user assertion, since a single element of an array can't match more than one value
|
|
assert.eq( [ 1],
|
|
t.find( { group:1 }, { x: { $elemMatch: { $all:[1] } } } ).toArray()[0].x,
|
|
"$in number match" );
|
|
|
|
assert.eq( [ { a: 'string', b: date1 } ],
|
|
t.find( { group:6 }, { x: { $elemMatch: { a:'string' } } } ).toArray()[0].x,
|
|
"mixed object match on string eq" );
|
|
|
|
assert.eq( [ { a: 'string2', b: date1 } ],
|
|
t.find( { group:6 }, { x: { $elemMatch: { a:/ring2/ } } } ).toArray()[0].x,
|
|
"mixed object match on regexp" );
|
|
|
|
assert.eq( [ { a: 'string', b: date1 } ],
|
|
t.find( { group:6 }, { x: { $elemMatch: { a: { $type: 2 } } } } ).toArray()[0].x,
|
|
"mixed object match on type" );
|
|
|
|
assert.eq( [ { a : 2, c : 3} ],
|
|
t.find( { group:2 }, { x: { $elemMatch: { a: { $ne: 1 } } } } ).toArray()[0].x,
|
|
"mixed object match on ne" );
|
|
|
|
assert.eq( [ {a : 1, d : 5} ],
|
|
t.find( { group:3 }, { x: { $elemMatch: { d: { $exists: true } } } } ).toArray()[0].x,
|
|
"mixed object match on exists" );
|
|
|
|
assert.eq( [ {a : 2, c : 3} ],
|
|
t.find( { group:3 }, { x: { $elemMatch: { a: { $mod : [2, 0 ] } } } } ).toArray()[0].x,
|
|
"mixed object match on mod" );
|
|
|
|
assert.eq( {"x" : [ { "a" : 1, "b" : 2 } ], "y" : [ { "c" : 3, "d" : 4 } ] },
|
|
t.find( { group:10 }, { _id : 0,
|
|
x: { $elemMatch: { a: 1 } },
|
|
y: { $elemMatch: { c: 3 } } } ).toArray()[0],
|
|
"multiple $elemMatch on unique fields 1" );
|
|
|
|
if (false) {
|
|
|
|
assert.eq( 2 , // SERVER-1243: handle multiple $elemMatch results
|
|
t.find( { group:4 }, { x: { $elemMatchAll: { a:{ $lte:2 } } } } ).toArray()[0].x.length,
|
|
"multi object match" );
|
|
|
|
assert.eq( 3 , // SERVER-1243: handle multiple $elemMatch results
|
|
t.find( { group:1 }, { x: { $elemMatchAll: { $in:[1, 2, 3] } } } ).toArray()[0].x.length,
|
|
"$in number match" );
|
|
|
|
assert.eq( 1 , // SERVER-1243: handle multiple $elemMatch results
|
|
t.find( { group:5 }, { x: { $elemMatchAll: { $ne: 5 } } } ).toArray()[0].x.length,
|
|
"single mixed type match 1" );
|
|
|
|
assert.eq( 1 , // SERVER-831: handle nested arrays
|
|
t.find( { group:9 }, { 'x.y': { $elemMatch: { a: 1 } } } ).toArray()[0].x.length,
|
|
"single dotted match" );
|
|
|
|
}
|
|
|
|
//
|
|
// Batch/getMore tests
|
|
//
|
|
// test positional operator across multiple batches
|
|
a = t.find( { group:3, 'x.b':2 }, { 'x.$':1 } ).batchSize(1)
|
|
while ( a.hasNext() ) {
|
|
assert.eq( 2, a.next().x[0].b, "positional getMore test");
|
|
}
|
|
|
|
// test $elemMatch operator across multiple batches
|
|
a = t.find( { group:3 }, { x:{$elemMatch:{a:1}} } ).batchSize(1)
|
|
while ( a.hasNext() ) {
|
|
assert.eq( 1, a.next().x[0].a, "positional getMore test");
|
|
}
|
|
|
|
// verify the positional update operator matches the same element as the the positional find. this
|
|
// is to ensure consistent behavior with updates until SERVER-1013 is resolved, at which point the
|
|
// following tests should be updated.
|
|
|
|
t.update({ group: 10, 'x.a': 3, 'y.c':1 }, { $set:{'x.$':100} }, false, true );
|
|
// updated the wrong element, so the following assertions should be true
|
|
assert.eq( 100,
|
|
t.find( { group:10, 'y.c':1 , x:100 }, { 'x.$':1 } ).toArray()[0].x[0],
|
|
"wrong single element match after update" );
|
|
|
|
assert.eq( 100,
|
|
t.find( { group:10 , x:100 , 'y.c':1 }, { 'x.$':1 } ).toArray()[0].x[0],
|
|
"wrong single element match after update" );
|
|
|
|
t.remove({ group: 10 });
|
|
t.insert({ group: 10, x: [ { a: 1, b: 2 }, {a: 3, b: 4} ],
|
|
y: [ { c: 1, d: 2 }, {c: 3, d: 4} ] });
|
|
|
|
t.update({ group: 10, 'y.c':1, 'x.a': 3 }, { $set:{'x.$':100} }, false, true );
|
|
// updated the correct element
|
|
assert.eq( 100,
|
|
t.find( { group:10, 'y.c':1 , x:100 }, { 'x.$':1 } ).toArray()[0].x[0],
|
|
"right single element match after update" );
|
|
|
|
// the following test asserts that the array element match behavior is consistently wrong
|
|
assert.eq( { a: 1, b: 2 },
|
|
t.find( { group:10 , x:100 , 'y.c':1 }, { 'x.$':1 } ).toArray()[0].x[0],
|
|
"right single element match after update" );
|