如何使用 Atlas Search 检查空值和非空值

use sample_mflix

1
using MongoDB.Bson;
2
using MongoDB.Bson.Serialization.Attributes;
3
using MongoDB.Bson.Serialization.Conventions;
4
using MongoDB.Driver;
5
using MongoDB.Driver.Search;
6
7
public class IsNullQuery 
8
{
9
    private const string MongoConnectionString = "<connection-string>";
10
    
11
    public static void Main(string[] args) 
12
    {
13
        // allow automapping of the camelCase database fields to our UserDocument
14
        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
15
        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
16
17
        // connect to your Atlas cluster
18
        var mongoClient = new MongoClient(MongoConnectionString);
19
        var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
20
        var usersCollection = mflixDatabase.GetCollection<UserDocument>("users");
21
22
        // define and run pipeline
23
        var results = usersCollection.Aggregate()
24
            .Search(Builders<UserDocument>.Search.Compound()
25
                .Must(Builders<UserDocument>.Search.Exists(user => user.Password))
26
                .MustNot(Builders<UserDocument>.Search.Wildcard(user => user.Password, "*", true)),
27
                indexName: "null-check-tutorial")
28
                .ToList();
29
30
        // print results
31
        foreach (var user in results) 
32
        {
33
            Console.WriteLine(user.ToJson());
34
        }
35
    }
36
}
37
38
[BsonIgnoreExtraElements]
39
public class UserDocument 
40
{
41
    [BsonIgnoreIfDefault]
42
    public ObjectId Id { get; set; }
43
    public string Name { get; set; }
44
    public string Email { get; set; }
45
    public string Password { get; set; }
46
}

1
package main
2
3
import (
4
	"context"
5
	"fmt"
6
7
	"go.mongodb.org/mongo-driver/bson"
8
	"go.mongodb.org/mongo-driver/mongo"
9
	"go.mongodb.org/mongo-driver/mongo/options"
10
)
11
12
func main() {
13
	// connect to your Atlas cluster
14
	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("<connection-string>"))
15
	if err != nil {
16
		panic(err)
17
	}
18
	defer client.Disconnect(context.TODO())
19
	// set namespace
20
	collection := client.Database("sample_mflix").Collection("users")
21
	// define pipeline stages
22
	searchStage := bson.D{{"$search", bson.D{{"index", "null-check-tutorial"}, {"compound", bson.D{{"must", bson.D{{"exists", bson.D{{"path", "password"}}}}}, {"mustNot", bson.D{{"wildcard", bson.D{{"path", "password"}, {"query", "*"}, {"allowAnalyzedField", true}}}}}}}}}}
23
	// run pipeline
24
	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage})
25
	if err != nil {
26
		panic(err)
27
	}
28
	// print results
29
	var results []bson.D
30
	if err = cursor.All(context.TODO(), &results); err != nil {
31
		panic(err)
32
	}
33
	for _, result := range results {
34
		fmt.Println(result)
35
	}
36
}

1
import static com.mongodb.client.model.Aggregates.limit;
2
import static com.mongodb.client.model.Aggregates.project;
3
import static com.mongodb.client.model.Projections.excludeId;
4
import static com.mongodb.client.model.Projections.fields;
5
import static com.mongodb.client.model.Projections.include;
6
import com.mongodb.client.MongoClient;
7
import com.mongodb.client.MongoClients;
8
import com.mongodb.client.MongoCollection;
9
import com.mongodb.client.MongoDatabase;
10
import org.bson.Document;
11
import java.util.Arrays;
12
13
public class IsNullQuery {
14
15
    public static void main(String[] args) {
16
        // connect to your Atlas cluster
17
        String uri = "<connection-string>";
18
        
19
        try (MongoClient mongoClient = MongoClients.create(uri)) {
20
            // set namespace
21
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
22
            MongoCollection<Document> collection = database.getCollection("users");
23
            
24
            // define pipeline
25
            Document agg = new Document("$search",
26
                new Document ("index", "null-check-tutorial")
27
                .append("compound", 
28
                    new Document("must", 
29
                    new Document("exists", 
30
                    new Document("path", "password")))
31
                                .append("mustNot", 
32
                    new Document("wildcard", 
33
                    new Document("path", "password")
34
                                        .append("query", "*")
35
                                        .append("allowAnalyzedField", true)))));
36
            // run pipeline and print results
37
            collection.aggregate(Arrays.asList(agg)).forEach(doc -> System.out.println(doc.toJson()));
38
        }
39
    }
40
}

1
import com.mongodb.kotlin.client.coroutine.MongoClient
2
import kotlinx.coroutines.runBlocking
3
import org.bson.Document
4
5
fun main() {
6
    // connect to your Atlas cluster
7
    val uri = "<connection-string>"
8
    val mongoClient = MongoClient.create(uri)
9
10
    // set namespace
11
    val database = mongoClient.getDatabase("sample_mflix")
12
    val collection = database.getCollection<Document>("users")
13
14
    runBlocking {
15
        // define pipeline
16
        val agg = Document(
17
            "\$search",
18
            Document("index", "null-check-tutorial")
19
                .append(
20
                    "compound",
21
                    Document(
22
                        "must",
23
                        Document(
24
                            "exists",
25
                            Document("path", "password")
26
                        )
27
                    )
28
                        .append(
29
                            "mustNot",
30
                            Document(
31
                                "wildcard",
32
                                Document("path", "password")
33
                                    .append("query", "*")
34
                                    .append("allowAnalyzedField", true)
35
                            )
36
                        )
37
                )
38
        )
39
40
        // run pipeline and print results
41
        val resultsFlow = collection.aggregate<Document>(
42
            listOf(agg)
43
        )
44
        resultsFlow.collect { println(it) }
45
    }
46
47
    mongoClient.close()
48
}

1
const { MongoClient } = require("mongodb");
2
3
// connect to your Atlas cluster
4
const uri =
5
    "<connection-string>";
6
7
const client = new MongoClient(uri);
8
9
async function run() {
10
    try {
11
        await client.connect();
12
13
        // set namespace
14
        const database = client.db("sample_mflix");
15
        const coll = database.collection("users");
16
17
        // define pipeline
18
        const agg = [{
19
            '$search': {
20
              'index': 'null-check-tutorial',
21
              'compound': {
22
                'must': {
23
                  'exists': {
24
                    'path': 'password'
25
                  }
26
                },
27
                'mustNot': {
28
                  'wildcard': {
29
                    'path': 'password', 
30
                    'query': '*', 
31
                    'allowAnalyzedField': true
32
                  }
33
                }
34
              }
35
            }
36
        }];
37
        // run pipeline
38
        const result = await coll.aggregate(agg);
39
40
        // print results
41
        await result.forEach((doc) => console.log(doc));
42
    } finally {
43
        await client.close();
44
    }
45
}
46
run().catch(console.dir);

1
import pymongo
2
3
# connect to your Atlas cluster
4
client = pymongo.MongoClient('<connection-string>')
5
6
# define pipeline
7
pipeline = [{
8
    '$search': {
9
        'index': 'null-check-tutorial',
10
        'compound': {
11
            'must': {
12
                'exists': {
13
                    'path': 'password'
14
                }
15
            },
16
            'mustNot': {
17
                'wildcard': {
18
                    'path': 'password', 
19
                    'query': '*', 
20
                    'allowAnalyzedField': True
21
                }
22
            }
23
        }
24
    }
25
}]
26
# run pipeline
27
result = client["sample_mflix"]["users"].aggregate(pipeline)
28
29
# print results
30
for i in result:
31
    print(i)

use sample_mflix

1
using MongoDB.Bson;
2
using MongoDB.Bson.Serialization.Attributes;
3
using MongoDB.Bson.Serialization.Conventions;
4
using MongoDB.Driver;
5
using MongoDB.Driver.Search;
6
7
public class NotNullQuery 
8
{
9
    private const string MongoConnectionString = "<connection-string>";
10
    
11
    public static void Main(string[] args) 
12
    {
13
        // allow automapping of the camelCase database fields to our UserDocument
14
        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
15
        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
16
17
        // connect to your Atlas cluster
18
        var mongoClient = new MongoClient(MongoConnectionString);
19
        var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
20
        var usersCollection = mflixDatabase.GetCollection<UserDocument>("users");
21
22
        // define a builder for the search score
23
        var scoreBuilder = new SearchScoreDefinitionBuilder<UserDocument>();
24
25
        // define and run pipeline
26
        var results = usersCollection.Aggregate()
27
            .Search(Builders<UserDocument>.Search.Compound()
28
                .Should(Builders<UserDocument>.Search.Wildcard(user => user.Password, "*", true))
29
                .Should(Builders<UserDocument>.Search.Compound(scoreBuilder.Constant(2))
30
                .MustNot(Builders<UserDocument>.Search.Exists(user => user.Password))),
31
                indexName: "null-check-tutorial")
32
                .Limit(5)
33
                .Project<UserDocument>(Builders<UserDocument>.Projection
34
                    .Include(user => user.Name)
35
                    .Include(user => user.Password)
36
                    .MetaSearchScore(user => user.Score)
37
                    .Exclude(user => user.Id))
38
                .ToList();
39
40
        // print results
41
        foreach (var user in results) 
42
        {
43
            Console.WriteLine(user.ToJson());
44
        }
45
    }
46
}
47
48
[BsonIgnoreExtraElements]
49
public class UserDocument 
50
{
51
    [BsonIgnoreIfDefault]
52
    public string Id { get; set; }
53
    public string Name { get; set; }
54
    [BsonIgnoreIfDefault]
55
    public string Password { get; set; }
56
    public double Score { get; set; }
57
}

1
package main
2
3
import (
4
	"context"
5
	"fmt"
6
7
	"go.mongodb.org/mongo-driver/bson"
8
	"go.mongodb.org/mongo-driver/mongo"
9
	"go.mongodb.org/mongo-driver/mongo/options"
10
)
11
12
func main() {
13
	// connect to your Atlas cluster
14
	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("<connection-string>"))
15
	if err != nil {
16
		panic(err)
17
	}
18
	defer client.Disconnect(context.TODO())
19
	// set namespace
20
	collection := client.Database("sample_mflix").Collection("users")
21
	// define pipeline stages
22
	searchStage := bson.D{{"$search", bson.D{
23
		{"index", "null-check-tutorial"},
24
		{"compound", bson.D{{
25
			"should", bson.A{bson.D{{
26
				"wildcard", bson.D{
27
					{"path", "password"},
28
					{"query", "*"},
29
					{"allowAnalyzedField", true}}}}, bson.D{{
30
				"compound", bson.D{{
31
					"mustNot", bson.D{{
32
						"exists", bson.D{
33
							{"path", "password"}}}}},
34
					{"score", bson.D{{"constant", bson.D{{"value", 2}}}}},
35
				}}}}}}}}}}
36
	projectStage := bson.D{{"$project", bson.D{{"name", 1}, {"password", 1}, {"_id", 0}, {"score", bson.D{{"$meta", "searchScore"}}}}}}
37
	limitStage := bson.D{{"$limit", 5}}
38
	// run pipeline
39
	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, projectStage, limitStage})
40
	if err != nil {
41
		panic(err)
42
	}
43
	// print results
44
	var results []bson.D
45
	if err = cursor.All(context.TODO(), &results); err != nil {
46
		panic(err)
47
	}
48
	for _, result := range results {
49
		fmt.Println(result)
50
	}
51
}

1
import static com.mongodb.client.model.Aggregates.limit;
2
import static com.mongodb.client.model.Aggregates.project;
3
import static com.mongodb.client.model.Projections.*;
4
import com.mongodb.client.MongoClient;
5
import com.mongodb.client.MongoClients;
6
import com.mongodb.client.MongoCollection;
7
import com.mongodb.client.MongoDatabase;
8
import org.bson.Document;
9
import java.util.Arrays;
10
11
public class NotNullQuery {
12
13
    public static void main(String[] args) {
14
        // connect to your Atlas cluster
15
        String uri = "<connection-string>";
16
17
        try (MongoClient mongoClient = MongoClients.create(uri)) {
18
            // set namespace
19
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
20
            MongoCollection<Document> collection = database.getCollection("users");
21
22
            // define pipeline
23
            Document agg = new Document("$search",
24
                new Document ("index", "null-check-tutorial")
25
                .append("compound",
26
                    new Document("should", Arrays.asList(
27
                        new Document("wildcard",
28
                                new Document("path", "password")
29
                                .append("query", "*")
30
                                .append("allowAnalyzedField", true)),
31
                                    new Document("compound",
32
                                            new Document("mustNot",
33
                                                    new Document("exists",
34
                                                            new Document("path", "password")))
35
                                                    .append("score",
36
                                                            new Document("constant",
37
                                                                    new Document("value", 2L))))))));
38
39
            // run pipeline and print results
40
            collection.aggregate(Arrays.asList(agg,
41
                            limit(5),
42
                            project(fields(
43
                                    excludeId(),
44
                                    include("name", "password"),
45
                                    computed("score", new Document("$meta", "searchScore"))))))
46
                    .forEach(doc -> System.out.println(doc.toJson()));
47
        }
48
    }
49
}

1
import com.mongodb.client.model.Aggregates.limit
2
import com.mongodb.client.model.Aggregates.project
3
import com.mongodb.client.model.Projections.*
4
import com.mongodb.kotlin.client.coroutine.MongoClient
5
import kotlinx.coroutines.runBlocking
6
import org.bson.Document
7
8
fun main() {
9
    // connect to your Atlas cluster
10
    val uri = "<connection-string>"
11
    val mongoClient = MongoClient.create(uri)
12
13
    // set namespace
14
    val database = mongoClient.getDatabase("sample_mflix")
15
    val collection = database.getCollection<Document>("users")
16
17
    runBlocking {
18
        // define pipeline
19
        val agg = Document(
20
            "\$search",
21
            Document("index", "null-check-tutorial")
22
                .append(
23
                    "compound",
24
                    Document(
25
                        "should", listOf(
26
                            Document(
27
                                "wildcard",
28
                                Document("path", "password")
29
                                    .append("query", "*")
30
                                    .append("allowAnalyzedField", true)
31
                            ),
32
                            Document(
33
                                "compound",
34
                                Document(
35
                                    "mustNot",
36
                                    Document(
37
                                        "exists",
38
                                        Document("path", "password")
39
                                    )
40
                                )
41
                                    .append(
42
                                        "score",
43
                                        Document(
44
                                            "constant",
45
                                            Document("value", 2L)
46
                                        )
47
                                    )
48
                            )
49
                        )
50
                    )
51
                )
52
        )
53
54
        // run pipeline and print results
55
        val resultsFlow = collection.aggregate<Document>(
56
            listOf(
57
                agg,
58
                limit(5),
59
                project(fields(
60
                    excludeId(),
61
                    include("name", "password"),
62
                    computed("score", Document("\$meta", "searchScore"))))
63
            )
64
        )
65
        resultsFlow.collect { println(it) }
66
    }
67
68
    mongoClient.close()
69
}

1
const { MongoClient } = require("mongodb");
2
3
// connect to your Atlas cluster
4
const uri =
5
    "<connection-string>";
6
7
const client = new MongoClient(uri);
8
9
async function run() {
10
    try {
11
        await client.connect();
12
13
        // set namespace
14
        const database = client.db("sample_mflix");
15
        const coll = database.collection("users");
16
17
        // define pipeline
18
        const agg = [
19
            {
20
                '$search': {
21
                    'index': 'null-check-tutorial',
22
                    'compound': {
23
                        'should': [{
24
                            'wildcard': {
25
                                'path': 'password', 
26
                                'query': '*', 
27
                                'allowAnalyzedField': true
28
                            }
29
                        }, 
30
                        {
31
                            'compound': {
32
                                'mustNot': {
33
                                    'exists': {
34
                                        'path': 'password'
35
                                    }
36
                                },
37
                                'score': { 'constant': { 'value': 2 } }
38
                            }
39
                        }]
40
                    }
41
                }
42
            },
43
            {    
44
                '$limit': 5   
45
            },
46
            {
47
                '$project': {'_id': 0, 'name': 1, 'password': 1, 'score': { '$meta': 'searchScore' }}
48
            }
49
        ];
50
        // run pipeline
51
        const result = await coll.aggregate(agg);
52
53
        // print results
54
        await result.forEach((doc) => console.log(doc));
55
    } finally {
56
        await client.close();
57
    }
58
}
59
run().catch(console.dir);

1
import pymongo
2
3
# connect to your Atlas cluster
4
client = pymongo.MongoClient('<connection-string>')
5
6
# define pipeline
7
pipeline = [{
8
        '$search': {
9
            'index': 'null-check-tutorial',
10
            'compound': {
11
                'should': [
12
                    {
13
                        'wildcard': {
14
                            'path': 'password', 
15
                            'query': '*', 
16
                            'allowAnalyzedField': True
17
                        }
18
                    }, {
19
                        'compound': {
20
                            'mustNot': {
21
                                'exists': {
22
                                    'path': 'password'
23
                                }
24
                            }, 
25
                            'score': {
26
                                'constant': {
27
                                    'value': 2
28
                                }
29
                            }
30
                        }
31
                    }
32
                ]
33
            }
34
        }
35
    }, {
36
        '$project': {
37
            '_id': 0, 
38
            'name': 1, 
39
            'password': 1, 
40
            'score': {
41
                '$meta': 'searchScore'
42
            }
43
        }
44
    }, {
45
        '$limit': 5
46
    }
47
]
48
# run pipeline
49
result = client["sample_mflix"]["users"].aggregate(pipeline)
50
51
# print results
52
for i in result:
53
    print(i)