← Back to branch summary

~ubuntu-branches/ubuntu/trusty/mongodb/trusty-proposed

« back to all changes in this revision

Viewing changes to jstests/cursor6.js

  • Committer: Bazaar Package Importer
  • Author(s): Antonin Kral
  • Date: 2010-01-29 19:48:45 UTC
  • Revision ID: james.westby@ubuntu.com-20100129194845-8wbmkf626fwcavc9
Tags: upstream-1.3.1
Import upstream version 1.3.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
jstests/cursor6.js
 
1
// Test different directions for compound indexes
 
2
 
 
3
function eq( one, two ) {
 
4
    assert.eq( one.a, two.a );
 
5
    assert.eq( one.b, two.b );
 
6
}
 
7
 
 
8
function checkExplain( e, idx, reverse, nScanned ) {
 
9
    if ( !reverse ) {
 
10
        if ( idx ) {
 
11
            assert.eq( "BtreeCursor a_1_b_-1", e.cursor );
 
12
        } else {
 
13
            assert.eq( "BasicCursor", e.cursor );
 
14
        }
 
15
    } else {
 
16
        if ( idx ) {
 
17
            assert.eq( "BtreeCursor a_1_b_-1 reverse", e.cursor );
 
18
        } else {
 
19
            assert( false );
 
20
        }
 
21
    }
 
22
    assert.eq( nScanned, e.nscanned );
 
23
}
 
24
 
 
25
function check( indexed ) {
 
26
    var hint;
 
27
    if ( indexed ) {
 
28
        hint = { a: 1, b: -1 };
 
29
    } else {
 
30
        hint = { $natural: 1 };
 
31
    }
 
32
    
 
33
    e = r.find().sort( { a: 1, b: 1 } ).hint( hint ).explain();
 
34
    checkExplain( e, indexed, false, 4 );
 
35
    f = r.find().sort( { a: 1, b: 1 } ).hint( hint );
 
36
    eq( z[ 0 ], f[ 0 ] );
 
37
    eq( z[ 1 ], f[ 1 ] );
 
38
    eq( z[ 2 ], f[ 2 ] );
 
39
    eq( z[ 3 ], f[ 3 ] );
 
40
 
 
41
    e = r.find().sort( { a: 1, b: -1 } ).hint( hint ).explain();
 
42
    checkExplain( e, indexed, false, 4 );
 
43
    f = r.find().sort( { a: 1, b: -1 } ).hint( hint );
 
44
    eq( z[ 1 ], f[ 0 ] );
 
45
    eq( z[ 0 ], f[ 1 ] );
 
46
    eq( z[ 3 ], f[ 2 ] );
 
47
    eq( z[ 2 ], f[ 3 ] );
 
48
 
 
49
    e = r.find().sort( { a: -1, b: 1 } ).hint( hint ).explain();
 
50
    checkExplain( e, indexed, true && indexed, 4 );
 
51
    f = r.find().sort( { a: -1, b: 1 } ).hint( hint );
 
52
    eq( z[ 2 ], f[ 0 ] );
 
53
    eq( z[ 3 ], f[ 1 ] );
 
54
    eq( z[ 0 ], f[ 2 ] );
 
55
    eq( z[ 1 ], f[ 3 ] );
 
56
 
 
57
    e = r.find( { a: { $gte: 2 } } ).sort( { a: 1, b: -1 } ).hint( hint ).explain();
 
58
    checkExplain( e, indexed, false, indexed ? 2 : 4 );
 
59
    f = r.find( { a: { $gte: 2 } } ).sort( { a: 1, b: -1 } ).hint( hint );
 
60
    eq( z[ 3 ], f[ 0 ] );
 
61
    eq( z[ 2 ], f[ 1 ] );
 
62
 
 
63
    e = r.find( { a : { $gte: 2 } } ).sort( { a: -1, b: 1 } ).hint( hint ).explain();
 
64
    checkExplain( e, indexed, true && indexed, indexed ? 2 : 4 );
 
65
    f = r.find( { a: { $gte: 2 } } ).sort( { a: -1, b: 1 } ).hint( hint );
 
66
    eq( z[ 2 ], f[ 0 ] );
 
67
    eq( z[ 3 ], f[ 1 ] );
 
68
 
 
69
    e = r.find( { a : { $gte: 2 } } ).sort( { a: 1, b: 1 } ).hint( hint ).explain();
 
70
    checkExplain( e, indexed, false, indexed ? 2 : 4 );
 
71
    f = r.find( { a: { $gte: 2 } } ).sort( { a: 1, b: 1 } ).hint( hint );
 
72
    eq( z[ 2 ], f[ 0 ] );
 
73
    eq( z[ 3 ], f[ 1 ] );
 
74
 
 
75
    e = r.find().sort( { a: -1, b: -1 } ).hint( hint ).explain();
 
76
    checkExplain( e, indexed, false, 4 );
 
77
    f = r.find().sort( { a: -1, b: -1 } ).hint( hint );
 
78
    eq( z[ 3 ], f[ 0 ] );
 
79
    eq( z[ 2 ], f[ 1 ] );
 
80
    eq( z[ 1 ], f[ 2 ] );
 
81
    eq( z[ 0 ], f[ 3 ] );
 
82
}
 
83
 
 
84
db.setProfilingLevel( 1 );
 
85
r = db.ed_db_cursor6;
 
86
r.drop();
 
87
 
 
88
z = [ { a: 1, b: 1 },
 
89
      { a: 1, b: 2 },
 
90
      { a: 2, b: 1 },
 
91
      { a: 2, b: 2 } ];
 
92
for( i = 0; i < z.length; ++i )
 
93
    r.save( z[ i ] );
 
94
 
 
95
r.ensureIndex( { a: 1, b: -1 } );
 
96
 
 
97
check( false );
 
98
check( true );
 
99
 
 
100
assert.eq( "BasicCursor", r.find().sort( { a: 1, b: -1, z: 1 } ).hint( { $natural: -1 } ).explain().cursor );