Atlas Search 快速入门

1
using MongoDB.Bson;
2
using MongoDB.Driver;
3
4
// connect to your Atlas deployment
5
var uri = "<connection-string>";
6
7
var client = new MongoClient(uri);
8
9
var db = client.GetDatabase("sample_mflix");
10
var collection = db.GetCollection<BsonDocument>("movies");
11
12
// define your Atlas Search index
13
var index =  new CreateSearchIndexModel(
14
  "default", new BsonDocument
15
  {
16
    { "mappings", new BsonDocument
17
      {
18
        { "dynamic", true }
19
      }
20
    }
21
  });
22
23
var result = collection.SearchIndexes.CreateOne(index);
24
Console.WriteLine(result);

1
package main
2
3
import (
4
 "context"
5
 "log"
6
7
 "go.mongodb.org/mongo-driver/v2/bson"
8
 "go.mongodb.org/mongo-driver/v2/mongo"
9
 "go.mongodb.org/mongo-driver/v2/mongo/options"
10
)
11
12
func main() {
13
 ctx := context.Background()
14
15
 // Replace the placeholder with your Atlas connection string
16
 const uri = "<connection-string>"
17
18
 // Connect to your Atlas cluster
19
 clientOptions := options.Client().ApplyURI(uri)
20
 client, err := mongo.Connect(clientOptions)
21
 if err != nil {
22
  log.Fatalf("failed to connect to the server: %v", err)
23
 }
24
 defer func() { _ = client.Disconnect(ctx) }()
25
26
 // Set the namespace
27
 coll := client.Database("sample_mflix").Collection("movies")
28
29
 // Define a simple Atlas Search index
30
 indexName := "default"
31
32
 // Create the default definition for search index
33
 definition := bson.D{{"mappings", bson.D{{"dynamic", true}}}}
34
 indexModel := mongo.SearchIndexModel{
35
  Definition: definition,
36
  Options: options.SearchIndexes().SetName(indexName),
37
 }
38
39
 // Create the index
40
 searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, indexModel)
41
 if err != nil {
42
  log.Fatalf("failed to create the search index: %v", err)
43
 }
44
 log.Println("New search index named " + searchIndexName + " is building.")
45
}

1
import com.mongodb.client.MongoClient;
2
import com.mongodb.client.MongoClients;
3
import com.mongodb.client.MongoCollection;
4
import com.mongodb.client.MongoDatabase;
5
import org.bson.Document;
6
7
public class CreateIndex {
8
    public static void main(String[] args) {
9
        // connect to your Atlas cluster
10
        String uri = "<connection-string>";
11
12
        try (MongoClient mongoClient = MongoClients.create(uri)) {
13
            // set namespace
14
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
15
            MongoCollection<Document> collection = database.getCollection("movies");
16
17
            Document index = new Document("mappings",
18
                    new Document("dynamic", true));
19
            collection.createSearchIndex(index);
20
        }
21
    }
22
}

1
import com.mongodb.MongoException
2
import com.mongodb.client.model.SearchIndexModel
3
import com.mongodb.client.model.SearchIndexType
4
import com.mongodb.kotlin.client.coroutine.MongoClient
5
import kotlinx.coroutines.runBlocking
6
import org.bson.Document
7
8
fun main() {
9
    // Replace the placeholder with your MongoDB deployment's connection string
10
    val uri = "<connection-string>"
11
    val mongoClient = MongoClient.create(uri)
12
    val database = mongoClient.getDatabase("sample_mflix")
13
    val collection = database.getCollection<Document>("movies")
14
    val searchIdx = Document(
15
        "mappings",
16
        Document("dynamic", true)
17
    )
18
    runBlocking {
19
        try {
20
            val result = collection.createSearchIndex("default", searchIdx)
21
            println("Index created: $result")
22
        } catch (e: MongoException) {
23
            println("Failed to create search index: ${e.message}")
24
        } finally {
25
            mongoClient.close()
26
        }
27
    }
28
}

1
const { MongoClient } = require("mongodb");
2
3
// connect to your Atlas deployment
4
const uri =  
5
  "<connection-string>";
6
7
const client = new MongoClient(uri);
8
9
async function run() {
10
  try {
11
12
    // set namespace
13
    const database = client.db("sample_mflix");
14
    const collection = database.collection("movies");
15
    
16
    // define your Atlas Search index
17
    const index = {
18
        name: "default",
19
        definition: {
20
            /* search index definition fields */
21
            "mappings": {
22
                "dynamic": true
23
            }
24
        }
25
    }
26
27
    // run the helper method
28
    const result = await collection.createSearchIndex(index);
29
    console.log(result);
30
  } finally {
31
    await client.close();
32
  }
33
}
34
35
run().catch(console.dir);

1
from pymongo import MongoClient
2
from pymongo.operations import SearchIndexModel
3
4
# connect to your Atlas deployment
5
uri = "<connection-string>"
6
client = MongoClient(uri)
7
8
# set namespace
9
database = client["sample_mflix"]
10
collection = database["movies"]
11
12
# define your Atlas Search index
13
search_index_model = SearchIndexModel(
14
    definition={
15
        "mappings": {
16
            "dynamic": True
17
        },
18
    },
19
    name="default",
20
)
21
22
# create the index
23
result = collection.create_search_index(model=search_index_model)
24
print(result)

1
use mongodb::bson::{doc, Document};
2
use mongodb::{Client, Collection, SearchIndexModel, SearchIndexType};
3
4
#[tokio::main]
5
async fn main() -> mongodb::error::Result<()> {
6
    // Connects to your Atlas deployment
7
    let uri = 
8
        "<connection-string>";
9
10
    let client = Client::with_uri_str(uri).await?;
11
12
    // Sets the namespace
13
    let collection: Collection<Document> = client
14
        .database("sample_mflix")
15
        .collection("movies");
16
17
    // Defines your Atlas Search index
18
    let index = doc! {
19
        "mappings": doc! {
20
            "dynamic": true
21
        }
22
    };  
23
24
    let idx_model = SearchIndexModel::builder()
25
        .definition(index)
26
        .name("search_idx".to_string())
27
        .index_type(SearchIndexType::Search)
28
        .build();
29
30
    // Runs the helper method
31
    let result = collection.create_search_index(idx_model).await?;
32
    println!("{}", result);
33
34
    Ok(())
35
}

1
using MongoDB.Bson;
2
using MongoDB.Driver;
3
4
// connect to your Atlas deployment
5
var uri = "<connection-string>";
6
7
var client = new MongoClient(uri);
8
9
var db = client.GetDatabase("sample_mflix");
10
var collection = db.GetCollection<BsonDocument>("movies");
11
12
// define your Atlas Search index
13
var index =  new CreateSearchIndexModel(
14
  "default", new BsonDocument
15
  {
16
    { "mappings", new BsonDocument
17
      {
18
        { "dynamic", true }
19
      }
20
    }
21
  });
22
23
var result = collection.SearchIndexes.CreateOne(index);
24
Console.WriteLine(result);

1
package main
2
3
import (
4
 "context"
5
 "log"
6
7
 "go.mongodb.org/mongo-driver/v2/bson"
8
 "go.mongodb.org/mongo-driver/v2/mongo"
9
 "go.mongodb.org/mongo-driver/v2/mongo/options"
10
)
11
12
func main() {
13
 ctx := context.Background()
14
15
 // Replace the placeholder with your Atlas connection string
16
 const uri = "<connection-string>"
17
18
 // Connect to your Atlas cluster
19
 clientOptions := options.Client().ApplyURI(uri)
20
 client, err := mongo.Connect(clientOptions)
21
 if err != nil {
22
  log.Fatalf("failed to connect to the server: %v", err)
23
 }
24
 defer func() { _ = client.Disconnect(ctx) }()
25
26
 // Set the namespace
27
 coll := client.Database("sample_mflix").Collection("movies")
28
29
 // Define a simple Atlas Search index
30
 indexName := "default"
31
32
 // Create the default definition for search index
33
 definition := bson.D{{"mappings", bson.D{{"dynamic", true}}}}
34
 indexModel := mongo.SearchIndexModel{
35
  Definition: definition,
36
  Options: options.SearchIndexes().SetName(indexName),
37
 }
38
39
 // Create the index
40
 searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, indexModel)
41
 if err != nil {
42
  log.Fatalf("failed to create the search index: %v", err)
43
 }
44
 log.Println("New search index named " + searchIndexName + " is building.")
45
}

1
import com.mongodb.client.MongoClient;
2
import com.mongodb.client.MongoClients;
3
import com.mongodb.client.MongoCollection;
4
import com.mongodb.client.MongoDatabase;
5
import org.bson.Document;
6
7
public class CreateIndex {
8
    public static void main(String[] args) {
9
        // connect to your Atlas cluster
10
        String uri = "<connection-string>";
11
12
        try (MongoClient mongoClient = MongoClients.create(uri)) {
13
            // set namespace
14
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
15
            MongoCollection<Document> collection = database.getCollection("movies");
16
17
            Document index = new Document("mappings",
18
                    new Document("dynamic", true));
19
            collection.createSearchIndex(index);
20
        }
21
    }
22
}

1
import com.mongodb.MongoException
2
import com.mongodb.client.model.SearchIndexModel
3
import com.mongodb.client.model.SearchIndexType
4
import com.mongodb.kotlin.client.coroutine.MongoClient
5
import kotlinx.coroutines.runBlocking
6
import org.bson.Document
7
8
fun main() {
9
    // Replace the placeholder with your MongoDB deployment's connection string
10
    val uri = "<connection-string>"
11
    val mongoClient = MongoClient.create(uri)
12
    val database = mongoClient.getDatabase("sample_mflix")
13
    val collection = database.getCollection<Document>("movies")
14
    val searchIdx = Document(
15
        "mappings",
16
        Document("dynamic", true)
17
    )
18
    runBlocking {
19
        try {
20
            val result = collection.createSearchIndex("default", searchIdx)
21
            println("Index created: $result")
22
        } catch (e: MongoException) {
23
            println("Failed to create search index: ${e.message}")
24
        } finally {
25
            mongoClient.close()
26
        }
27
    }
28
}

1
const { MongoClient } = require("mongodb");
2
3
// connect to your Atlas deployment
4
const uri =  
5
  "<connection-string>";
6
7
const client = new MongoClient(uri);
8
9
async function run() {
10
  try {
11
12
    // set namespace
13
    const database = client.db("sample_mflix");
14
    const collection = database.collection("movies");
15
    
16
    // define your Atlas Search index
17
    const index = {
18
        name: "default",
19
        definition: {
20
            /* search index definition fields */
21
            "mappings": {
22
                "dynamic": true
23
            }
24
        }
25
    }
26
27
    // run the helper method
28
    const result = await collection.createSearchIndex(index);
29
    console.log(result);
30
  } finally {
31
    await client.close();
32
  }
33
}
34
35
run().catch(console.dir);

1
from pymongo import MongoClient
2
from pymongo.operations import SearchIndexModel
3
4
# connect to your Atlas deployment
5
uri = "<connection-string>"
6
client = MongoClient(uri)
7
8
# set namespace
9
database = client["sample_mflix"]
10
collection = database["movies"]
11
12
# define your Atlas Search index
13
search_index_model = SearchIndexModel(
14
    definition={
15
        "mappings": {
16
            "dynamic": True
17
        },
18
    },
19
    name="default",
20
)
21
22
# create the index
23
result = collection.create_search_index(model=search_index_model)
24
print(result)

1
use mongodb::bson::{doc, Document};
2
use mongodb::{Client, Collection, SearchIndexModel, SearchIndexType};
3
4
#[tokio::main]
5
async fn main() -> mongodb::error::Result<()> {
6
    // Connects to your Atlas deployment
7
    let uri = 
8
        "<connection-string>";
9
10
    let client = Client::with_uri_str(uri).await?;
11
12
    // Sets the namespace
13
    let collection: Collection<Document> = client
14
        .database("sample_mflix")
15
        .collection("movies");
16
17
    // Defines your Atlas Search index
18
    let index = doc! {
19
        "mappings": doc! {
20
            "dynamic": true
21
        }
22
    };  
23
24
    let idx_model = SearchIndexModel::builder()
25
        .definition(index)
26
        .name("search_idx".to_string())
27
        .index_type(SearchIndexType::Search)
28
        .build();
29
30
    // Runs the helper method
31
    let result = collection.create_search_index(idx_model).await?;
32
    println!("{}", result);
33
34
    Ok(())
35
}