// Test queries that set the OplogReplay flag.
// @tags: [requires_replication, requires_capped]

(function() {
"use strict";

load("jstests/libs/analyze_plan.js");

function test(t) {
    t.drop();
    assert.commandWorked(t.getDB().createCollection(t.getName(), {capped: true, size: 16 * 1024}));

    const isOplog = t.getName().startsWith("oplog.");

    /**
     * Helper function for making timestamps with the property that if i < j, then makeTS(i) <
     * makeTS(j).
     */
    function makeTS(i) {
        return Timestamp(1000, i);
    }

    for (let i = 1; i <= 100; i++) {
        assert.writeOK(t.insert({_id: i, ts: makeTS(i)}));
    }

    // Missing 'ts' field.
    assert.throws(function() {
        t.find().addOption(DBQuery.Option.oplogReplay).next();
    });
    assert.throws(function() {
        t.find({_id: 3}).addOption(DBQuery.Option.oplogReplay).next();
    });

    // 'ts' field is not top-level.
    assert.throws(function() {
        t.find({$or: [{ts: {$gt: makeTS(3)}}, {foo: 3}]})
            .addOption(DBQuery.Option.oplogReplay)
            .next();
    });
    assert.throws(function() {
        t.find({$nor: [{ts: {$gt: makeTS(4)}}, {foo: 4}]})
            .addOption(DBQuery.Option.oplogReplay)
            .next();
    });

    // There is no $eq, $gt or $gte predicate on 'ts'.
    assert.throws(function() {
        t.find({ts: {$lt: makeTS(4)}}).addOption(DBQuery.Option.oplogReplay).next();
    });
    assert.throws(function() {
        t.find({ts: {$lt: makeTS(4)}, _id: 3}).addOption(DBQuery.Option.oplogReplay).next();
    });

    // A $gt query on just the 'ts' field should return the next document after the timestamp.
    var cursor = t.find({ts: {$gt: makeTS(20)}}).addOption(DBQuery.Option.oplogReplay);
    assert.eq(21, cursor.next()["_id"]);
    assert.eq(22, cursor.next()["_id"]);

    // A $gte query on the 'ts' field should include the timestamp.
    cursor = t.find({ts: {$gte: makeTS(20)}}).addOption(DBQuery.Option.oplogReplay);
    assert.eq(20, cursor.next()["_id"]);
    assert.eq(21, cursor.next()["_id"]);

    // An $eq query on the 'ts' field should return the single record with the timestamp.
    cursor = t.find({ts: {$eq: makeTS(20)}}).addOption(DBQuery.Option.oplogReplay);
    assert.eq(20, cursor.next()["_id"]);
    assert(!cursor.hasNext());

    // An AND with both a $gt and $lt query on the 'ts' field will correctly return results in
    // the proper bounds.
    cursor = t.find({
                  $and: [{ts: {$lt: makeTS(5)}}, {ts: {$gt: makeTS(1)}}]
              }).addOption(DBQuery.Option.oplogReplay);
    assert.eq(2, cursor.next()["_id"]);
    assert.eq(3, cursor.next()["_id"]);
    assert.eq(4, cursor.next()["_id"]);
    assert(!cursor.hasNext());

    // An AND with multiple predicates on the 'ts' field correctly returns results on the
    // tightest range.
    cursor = t.find({
                  $and: [
                      {ts: {$gte: makeTS(2)}},
                      {ts: {$gt: makeTS(3)}},
                      {ts: {$lte: makeTS(7)}},
                      {ts: {$lt: makeTS(7)}}
                  ]
              }).addOption(DBQuery.Option.oplogReplay);
    assert.eq(4, cursor.next()["_id"]);
    assert.eq(5, cursor.next()["_id"]);
    assert.eq(6, cursor.next()["_id"]);
    assert(!cursor.hasNext());

    // An AND with an $eq predicate in conjunction with other bounds correctly returns one
    // result.
    cursor = t.find({
                  $and: [
                      {ts: {$gte: makeTS(1)}},
                      {ts: {$gt: makeTS(2)}},
                      {ts: {$eq: makeTS(5)}},
                      {ts: {$lte: makeTS(8)}},
                      {ts: {$lt: makeTS(8)}}
                  ]
              }).addOption(DBQuery.Option.oplogReplay);
    assert.eq(5, cursor.next()["_id"]);
    assert(!cursor.hasNext());

    // An $eq query stops scanning after passing the max timestamp.
    let res = t.find({ts: {$eq: makeTS(10)}})
                  .addOption(DBQuery.Option.oplogReplay)
                  .explain("executionStats");
    assert.commandWorked(res);
    // If this is the oplog, we expect to be able to seek directly to the entry with a 'ts' of
    // 10. Otherwise, we have to scan from the beginning of the oplog.
    let expectedDocsExamined = isOplog ? 2 : 11;
    assert.lte(res.executionStats.totalDocsExamined, expectedDocsExamined, tojson(res));
    let collScanStage = getPlanStage(res.executionStats.executionStages, "COLLSCAN");
    assert.neq(null, collScanStage, "no collection scan found in explain output: " + tojson(res));
    assert.eq(makeTS(10), collScanStage.maxTs, tojson(res));

    // An AND with an $lt predicate stops scanning after passing the max timestamp.
    res = t.find({$and: [{ts: {$gte: makeTS(1)}}, {ts: {$lt: makeTS(10)}}]})
              .addOption(DBQuery.Option.oplogReplay)
              .explain("executionStats");
    assert.commandWorked(res);
    assert.lte(res.executionStats.totalDocsExamined, 11, tojson(res));
    collScanStage = getPlanStage(res.executionStats.executionStages, "COLLSCAN");
    assert.neq(null, collScanStage, "no collection scan found in explain output: " + tojson(res));
    assert.eq(makeTS(10), collScanStage.maxTs, tojson(res));

    // An AND with an $lte predicate stops scanning after passing the max timestamp.
    res = t.find({$and: [{ts: {$gte: makeTS(1)}}, {ts: {$lte: makeTS(10)}}]})
              .addOption(DBQuery.Option.oplogReplay)
              .explain("executionStats");
    assert.commandWorked(res);
    assert.lte(res.executionStats.totalDocsExamined, 12, tojson(res));
    collScanStage = getPlanStage(res.executionStats.executionStages, "COLLSCAN");
    assert.neq(null, collScanStage, "no collection scan found in explain output: " + tojson(res));
    assert.eq(makeTS(10), collScanStage.maxTs, tojson(res));

    // The max timestamp is respected even when the min timestamp is smaller than the lowest
    // timestamp in the collection.
    res = t.find({$and: [{ts: {$gte: makeTS(0)}}, {ts: {$lte: makeTS(10)}}]})
              .addOption(DBQuery.Option.oplogReplay)
              .explain("executionStats");
    assert.commandWorked(res);
    assert.lte(res.executionStats.totalDocsExamined, 12, tojson(res));
    collScanStage = getPlanStage(res.executionStats.executionStages, "COLLSCAN");
    assert.neq(null, collScanStage, "no collection scan found in explain output: " + tojson(res));
    assert.eq(makeTS(10), collScanStage.maxTs, tojson(res));

    // An AND with redundant $eq/$lt/$lte predicates stops scanning after passing the max
    // timestamp.
    res = t.find({
               $and: [
                   {ts: {$gte: makeTS(0)}},
                   {ts: {$lte: makeTS(10)}},
                   {ts: {$eq: makeTS(5)}},
                   {ts: {$lt: makeTS(20)}}
               ]
           })
              .addOption(DBQuery.Option.oplogReplay)
              .explain("executionStats");
    assert.commandWorked(res);
    // If this is the oplog, we expect to be able to seek directly to the entry with a 'ts' of
    // 5. Otherwise, we have to scan from the beginning of the oplog.
    expectedDocsExamined = isOplog ? 2 : 11;
    assert.lte(res.executionStats.totalDocsExamined, expectedDocsExamined, tojson(res));
    collScanStage = getPlanStage(res.executionStats.executionStages, "COLLSCAN");
    assert.neq(null, collScanStage, "no collection scan found in explain output: " + tojson(res));
    assert.eq(makeTS(5), collScanStage.maxTs, tojson(res));

    // An $eq query for a non-existent timestamp scans a single oplog document.
    res = t.find({ts: {$eq: makeTS(200)}})
              .addOption(DBQuery.Option.oplogReplay)
              .explain("executionStats");
    assert.commandWorked(res);
    // If this is the oplog, we expect to be able to seek directly to the end of the oplog.
    // Otherwise, we have to scan the entire oplog before determining that 'ts' 100 does not
    // exist.
    expectedDocsExamined = isOplog ? 1 : 100;
    assert.lte(res.executionStats.totalDocsExamined, expectedDocsExamined, tojson(res));
    collScanStage = getPlanStage(res.executionStats.executionStages, "COLLSCAN");
    assert.neq(null, collScanStage, "no collection scan found in explain output: " + tojson(res));
    assert.eq(makeTS(200), collScanStage.maxTs, tojson(res));

    // When the filter matches the last document within the timestamp range, the collection scan
    // examines at most one more document.
    res = t.find({$and: [{ts: {$gte: makeTS(4)}}, {ts: {$lte: makeTS(8)}}, {_id: 8}]})
              .addOption(DBQuery.Option.oplogReplay)
              .explain("executionStats");
    assert.commandWorked(res);
    // If this is the oplog, we expect to be able to seek directly to the start of the 'ts'
    // range. Otherwise, we have to scan the capped collection from the beginning.
    expectedDocsExamined = isOplog ? 6 : 9;
    assert.lte(res.executionStats.totalDocsExamined, expectedDocsExamined, tojson(res));
    collScanStage = getPlanStage(res.executionStats.executionStages, "COLLSCAN");
    assert.neq(null, collScanStage, "no collection scan found in explain output: " + tojson(res));
    assert.eq(makeTS(8), collScanStage.maxTs, tojson(res));

    // A query over both 'ts' and '_id' should only pay attention to the 'ts' field for finding
    // the oplog start (SERVER-13566).
    cursor = t.find({ts: {$gte: makeTS(20)}, _id: 25}).addOption(DBQuery.Option.oplogReplay);
    assert.eq(25, cursor.next()["_id"]);
    assert(!cursor.hasNext());
}

jsTestLog("Non-oplog.");
// Test that oplog replay on a non-oplog collection succeeds.
test(db.jstests_query_oplogreplay);

jsTestLog("Oplog.");
// Test that oplog replay on the actual oplog succeeds.
test(db.getSiblingDB("local").oplog.jstests_query_oplogreplay);

// Test that oplog replay on a non-capped collection fails.
const coll = db.jstests_query_oplogreplay;
coll.drop();
assert.commandWorked(coll.getDB().createCollection(coll.getName()));
assert.throws(function() {
    coll.find({ts: {$gt: "abcd"}}).addOption(DBQuery.Option.oplogReplay).next();
});
}());