summaryrefslogtreecommitdiff
path: root/jstests/core/fts_querylang.js
blob: de27b65ba5bb7c199df1e1761d45e28721e1e5bc (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
// Test the $text query operator.
// @tags: [requires_non_retryable_writes]
(function() {
    "use strict";

    const coll = db.getCollection("fts_querylang");
    coll.drop();

    assert.commandWorked(coll.insert({_id: 0, unindexedField: 0, a: "textual content"}));
    assert.commandWorked(coll.insert({_id: 1, unindexedField: 1, a: "additional content"}));
    assert.commandWorked(coll.insert({_id: 2, unindexedField: 2, a: "irrelevant content"}));
    assert.commandWorked(coll.createIndex({a: "text"}));

    // Test text query with no results.
    assert.eq(false, coll.find({$text: {$search: "words"}}).hasNext());

    // Test basic text query.
    let results = coll.find({$text: {$search: "textual content -irrelevant"}}).toArray();
    assert.eq(results.length, 2, results);
    assert.neq(results[0]._id, 2, results);
    assert.neq(results[1]._id, 2, results);

    // Test sort with basic text query.
    results = coll.find({$text: {$search: "textual content -irrelevant"}})
                  .sort({unindexedField: 1})
                  .toArray();
    assert.eq(results.length, 2, results);
    assert.eq(results[0]._id, 0, results);
    assert.eq(results[1]._id, 1, results);

    // Test skip with basic text query.
    results = coll.find({$text: {$search: "textual content -irrelevant"}})
                  .sort({unindexedField: 1})
                  .skip(1)
                  .toArray();
    assert.eq(results.length, 1, results);
    assert.eq(results[0]._id, 1, results);

    // Test limit with basic text query.
    results = coll.find({$text: {$search: "textual content -irrelevant"}})
                  .sort({unindexedField: 1})
                  .limit(1)
                  .toArray();
    assert.eq(results.length, 1, results);
    assert.eq(results[0]._id, 0, results);

    // Test $and of basic text query with indexed expression.
    results = coll.find({$text: {$search: "content -irrelevant"}, _id: 1}).toArray();
    assert.eq(results.length, 1, results);
    assert.eq(results[0]._id, 1, results);

    // Test $and of basic text query with indexed expression and bad language.
    assert.commandFailedWithCode(assert.throws(function() {
        coll.find({$text: {$search: "content -irrelevant", $language: "spanglish"}, _id: 1})
            .itcount();
    }),
                                 ErrorCodes.BadValue);

    // Test $and of basic text query with unindexed expression.
    results = coll.find({$text: {$search: "content -irrelevant"}, unindexedField: 1}).toArray();
    assert.eq(results.length, 1, results);
    assert.eq(results[0]._id, 1, results);

    // Test $language.
    let cursor = coll.find({$text: {$search: "contents", $language: "none"}});
    assert.eq(false, cursor.hasNext());

    cursor = coll.find({$text: {$search: "contents", $language: "EN"}});
    assert.eq(true, cursor.hasNext());

    cursor = coll.find({$text: {$search: "contents", $language: "spanglish"}});
    assert.commandFailedWithCode(assert.throws(function() {
        cursor.next();
    }),
                                 ErrorCodes.BadValue);

    // Test update with $text.
    coll.update({$text: {$search: "textual content -irrelevant"}}, {$set: {b: 1}}, {multi: true});
    assert.eq(2, coll.find({b: 1}).itcount(), 'incorrect number of documents updated');

    // $text cannot be contained within a $nor.
    assert.commandFailedWithCode(assert.throws(function() {
        coll.find({$nor: [{$text: {$search: 'a'}}]}).itcount();
    }),
                                 ErrorCodes.BadValue);
}());