Connect to MongoDB Search Community

• mongosh

• MongoDB Compass

• Um terminal

• Um editor de texto

• dotnet

• A C# project

  Para inicializar um projeto, execute o comando dotnet new console no diretório do seu projeto. Para saber mais, consulte Início rápido do C#.

• Um terminal

• Um editor de texto

• Go

• A Go project

  Para inicializar um projeto, use o comando go mod. Para saber mais, consulte Início rápido do Go.

• MongoDB Go driver

  To download and install the Go driver and driver dependencies, run the following commands:

  go get go.mongodb.org/mongo-driver/v2/mongo
  go get github.com/joho/godotenv

• Java Development Kit (JDK) version 8 or later

• The driver dependencies installed by using Maven or Gradle

  Recomendamos o uso de um ambiente de desenvolvimento integrado (IDE), como o IntelliJ IDEA ou Eclipse IDE para configurar as dependências.

  Para configurar Maven ou Gradle para criar e executar seu projeto, consulte Adicionar MongoDB como dependência.

• Um terminal

• Um editor de texto

• npm

• Node.js

Para instalar o node.js driver, execute o seguinte comando em um prompt de terminal:

npm install mongodb --save

• Um terminal

• Um editor de texto

• Python

  To download the latest version of Python for your operating system, see Python Downloads Page.

• The pip package installer

  Starting with Python 2.7.9 and Python 3.4, packages downloaded from https://python.org include pip.

  To install pip manually, see the pip installation page. This package includes Python.

mongosh -u <USER-NAME> -p <USER-PASSWORD> --authenticationDatabase "<AUTHENTICATION-DB>" --host <HOST-NAME> --port <PORT-NUMBER>

rs0 [direct: primary] test>

To learn more, see Connect to a Deployment.

Para saber mais, consulte Conectar ao MongoDB.

The following sample application connects to your replica set with your connection string and sends a ping to confirm a successful connection. To test the sample application, perform the following steps:

1. Crie um novo diretório chamado connect e inicialize seu projeto usando o comando dotnet new.

   mkdir connect
   cd connect
   dotnet new console

2. Execute o seguinte comando para adicionar o driver .NET/C# ao seu projeto como uma dependência:

   dotnet add package MongoDB.Driver

3. Define your connection settings in the Program.cs file.

   Substitua o conteúdo do arquivo Program.cs pelo seguinte código. O código de exemplo faz o seguinte:

   • Connects to your local deployment.

   • Inserts a collection named movies with one document in the test database.

   • Retrieves all search indexes for the collection.

   1
   using MongoDB.Bson;
   2
   using MongoDB.Driver;
   3
   4
   public class Connect
   5
   {
   6
      // Replace the following with your connection string
   7
      private const string MongoConnectionString = "<CONNECTION-STRING>";
   8
   9
      public static void Main(string[] args)
   10
      {
   11
         // Connect to your replica set
   12
         var client = new MongoClient(MongoConnectionString);
   13
   14
         // Send a ping to confirm a successful connection
   15
         try {
   16
            var result = client.GetDatabase("admin").RunCommand<BsonDocument>(new BsonDocument("ping", 1));
   17
            Console.WriteLine("Successfully connected to Replica Set");
   18
         }
   19
         catch (Exception e) { Console.WriteLine(e);}
   20
   21
         // Insert a document to a collection
   22
         var database = client.GetDatabase("test");
   23
         var collection = database.GetCollection<BsonDocument>("movies");
   24
         var movieDocument = new BsonDocument{{"title", "Back to the Future"}};
   25
         try {
   26
            collection.InsertOne(movieDocument);
   27
            Console.WriteLine("Document inserted successfully.");
   28
         }
   29
         catch (Exception e) {
   30
            Console.WriteLine($"Insertion error: {e.Message}");
   31
         }
   32
   33
         // List search indexes
   34
         try {
   35
            var result = collection.SearchIndexes.List().ToList();
   36
            if (indexes.Count == 0) {
   37
               Console.WriteLine("No indexes found on the collection.");
   38
            }
   39
            else {
   40
               Console.WriteLine("Indexes on the collection:");
   41
               foreach (var index in indexes)
   42
                  {
   43
                     Console.WriteLine(index.ToJson());
   44
                  }
   45
            }
   46
         }
   47
         catch (Exception e) {
   48
            Console.WriteLine($"Error listing indexes: {e.Message}");
   49
         }
   50
      }
   51
   }

4. Replace the placeholder (line 7) with your connection string and save the file.

5. Run your application.

   dotnet run Program.cs

   OCULTAR SAÍDA

   Successfully connected to MongoDB.
   Document inserted successfully.
   No indexes found on the collection.

   Observação

   The results don't contain any indexes because the sample code didn't create any index for the movies collection.

Para saber mais, consulte Opções de conexão.

The following sample application connects to your replica set with your connection string and sends a ping to confirm a successful connection. Test the sample application with the following steps:

1. Crie um novo diretório chamado connect e inicialize seu projeto usando o comando go mod.

   mkdir connect
   cd connect
   go mod init connect

2. Define your connection settings in a .go file.

   In your project, create a new file called connect.go and paste the following code.

   1
   package main
   2
   3
   import (
   4
      "context"
   5
      "encoding/json"
   6
      "fmt"
   7
      "log"
   8
   9
      "go.mongodb.org/mongo-driver/bson"
   10
      "go.mongodb.org/mongo-driver/mongo"
   11
      "go.mongodb.org/mongo-driver/mongo/options"
   12
      "go.mongodb.org/mongo-driver/mongo/readpref"
   13
   )
   14
   15
   type Movie struct {
   16
      Title string `bson:"title"`
   17
   }
   18
   19
   func main() {
   20
      // Replace with your connection string
   21
      uri := "<CONNECTION-STRING>"
   22
   23
      // Connect to MongoDB
   24
      client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
   25
      if err != nil {
   26
         log.Fatalf("Failed to connect to MongoDB: %v", err)
   27
      }
   28
      defer func() {
   29
         if err = client.Disconnect(context.TODO()); err != nil {
   30
            log.Fatalf("Failed to disconnect MongoDB client: %v", err)
   31
         }
   32
      }()
   33
   34
      // Ping to confirm connection
   35
      if err := client.Ping(context.TODO(), readpref.Primary()); err != nil {
   36
         log.Fatalf("Failed to ping MongoDB: %v", err)
   37
      }
   38
      fmt.Println("Successfully connected to MongoDB")
   39
   40
      // Insert a document to a collection
   41
      coll := client.Database("test").Collection("movies")
   42
      newMovie := Movie{Title: "Back to the Future"}
   43
      result, err := coll.InsertOne(context.TODO(), newMovie)
   44
      if err != nil {
   45
         log.Fatalf("Failed to insert document: %v", err)
   46
      }
   47
      fmt.Printf("Inserted document ID: %v\n", result.InsertedID)
   48
   49
      // List search indexes
   50
      listOpts := options.ListSearchIndexesOptions{}
   51
      ctx := context.TODO()
   52
      cursor, err := coll.SearchIndexes().List(ctx, nil, &listOpts)
   53
      if err != nil {
   54
         log.Fatalf("Failed to list search indexes: %v", err)
   55
      }
   56
   57
      var results []bson.D
   58
      if err = cursor.All(ctx, &results); err != nil {
   59
         log.Fatalf("Failed to iterate over cursor: %v", err)
   60
      }
   61
   62
      res, err := json.Marshal(results)
   63
      if err != nil {
   64
         log.Fatalf("Failed to marshal results to JSON: %v", err)
   65
      }
   66
      fmt.Println("Search indexes found:", string(res))
   67
   }

3. Replace the placeholder (line 15) with your connection string and save the file.

4. Run your application.

   go run connect.go

   OCULTAR SAÍDA

   Successfully connected to MongoDB
   Inserted document ID: ObjectID("67e42df345bc0b636fe340f0")
   Search indexes found: null

   Observação

   The results don't contain any indexes because the sample code didn't create any index for the movies collection.

To learn more, see Connections.

The following sample application connects to your replica set with your connection string. To test the sample application, perform the following steps:

1. Define your connection settings in a Java class file.

   Copy the following code into a file called Connect.java.

   1
   import com.mongodb.ConnectionString;
   2
   import com.mongodb.MongoClientSettings;
   3
   import com.mongodb.MongoException;
   4
   import com.mongodb.ServerApi;
   5
   import com.mongodb.ServerApiVersion;
   6
   import com.mongodb.client.MongoClient;
   7
   import com.mongodb.client.MongoClients;
   8
   import com.mongodb.client.MongoCollection;
   9
   import com.mongodb.client.MongoCursor;
   10
   import com.mongodb.client.MongoDatabase;
   11
   import org.bson.BsonDocument;
   12
   import org.bson.BsonInt64;
   13
   import org.bson.Document;
   14
   import org.bson.conversions.Bson;
   15
   16
   public class Connect {
   17
      public static void main(String[] args) {
   18
         // Replace the placeholder with your Replica Set connection string
   19
         String uri = "<CONNECTION-STRING>";
   20
   21
         // Construct a ServerApi instance using the ServerApi.builder() method
   22
         ServerApi serverApi = ServerApi.builder()
   23
                  .version(ServerApiVersion.V1)
   24
                  .build();
   25
   26
         MongoClientSettings settings = MongoClientSettings.builder()
   27
                  .applyConnectionString(new ConnectionString(uri))
   28
                  .serverApi(serverApi)
   29
                  .build();
   30
   31
         // Create a new client and connect to the server
   32
         try (MongoClient mongoClient = MongoClients.create(settings)) {
   33
               MongoDatabase adminDatabase = mongoClient.getDatabase("admin");
   34
               try {
   35
                  // Send a ping to confirm a successful connection
   36
                  Bson command = new BsonDocument("ping", new BsonInt64(1));
   37
                  adminDatabase.runCommand(command);
   38
                  System.out.println("Successfully connected to Replica Set");
   39
               } catch (MongoException e) {
   40
                  System.err.println("Ping failed: " + e);
   41
               }
   42
   43
               // Insert a document into a collection
   44
               MongoDatabase database = mongoClient.getDatabase("test");
   45
               MongoCollection<Document> collection = database.getCollection("movies");
   46
               Document movieDocument = new Document("title", "Back to the Future");
   47
               try {
   48
                  collection.insertOne(movieDocument);
   49
                  System.out.println("Document inserted successfully.");
   50
               } catch (MongoException e) {
   51
                  System.err.println("Insertion failed: " + e);
   52
               }
   53
   54
               // List search indexes
   55
               try (MongoCursor<Document> resultsCursor = collection.listSearchIndexes().iterator()) {
   56
                  System.out.println("Search indexes found:");
   57
                  while (resultsCursor.hasNext()) {
   58
                     System.out.println(resultsCursor.next().toJson());
   59
                  }
   60
               } catch (MongoException e) {
   61
                  System.err.println("Error listing indexes: " + e);
   62
               }
   63
         } catch (MongoException e) {
   64
               System.err.println("Failed to create MongoClient: " + e);
   65
         }
   66
      }
   67
   }

2. Replace the placeholder (line 14) with your connection string and save the file.

3. Compile e execute o arquivo Connect.java usando um IDE ou os seguintes comandos:

   javac Connect.java
   java Connect

   OCULTAR SAÍDA

   Successfully connected to Replica Set
   Document inserted successfully.
   Search indexes found:

   Observação

   The results don't contain any indexes because the sample code didn't create any index for the movies collection.

Para saber mais, consulte Conectar ao MongoDB.

The following sample application connects to your replica set with your connection string and returns a confirmation message. To test the sample application, perform the following steps:

1. Define your connection settings in a .js file.

   Copy the following code into a file called connect.js.

   1
   const { MongoClient } = require("mongodb");
   2
   3
   const url = "<CONNECTION-STRING>";
   4
   5
   // Connect to your  Replica Set
   6
   const client = new MongoClient(url);
   7
   8
   async function run() {
   9
      try {
   10
      await client.connect();
   11
      console.log("Successfully connected to Replica Set");
   12
   13
      // Insert a document in a collection
   14
      const database = client.db("test");
   15
      const coll = database.collection("movies");
   16
      const doc = { title: "Back to the Future" };
   17
      const insertResult = await coll.insertOne(doc);
   18
      console.log(`Document inserted with _id: ${insertResult.insertedId}`);
   19
   20
      // List search indexes for the collection
   21
      const searchIndexesResult = await coll.listSearchIndexes().toArray();
   22
      console.log("Search indexes:", searchIndexesResult);
   23
      } catch (err) {
   24
      console.log("Error occurred:", err.stack);
   25
      } finally {
   26
      await client.close();
   27
      }
   28
   }
   29
   30
   run().catch(console.dir);

2. Replace the placeholder (line 4) with your connection string and save the file.

3. Run the sample application using the following command:

   node connect.js

   OCULTAR SAÍDA

   Successfully connected to Replica Set
   Document inserted with _id: 67e432123504d5a7ed2156eb
   Search indexes: []

   Observação

   The results don't contain any indexes because the sample code didn't create any index for the movies collection.

To learn more, see Connection.

1. Importar MongoClient do PyMongo.

   Para se conectar a uma instância do MongoDB em execução, o PyMongo requer MongoClient. No shell do Python em execução no seu terminal, execute o seguinte comando para importar MongoClient:

   from pymongo import MongoClient

2. Define your connection settings in a .py file.

   Copy the following code to a file named connect.py.

   1
   from pymongo import MongoClient, errors
   2
   3
   # Replace '<connection-string>' with your actual MongoDB connection string
   4
   connection_string = '<CONNECTION-STRING>'
   5
   6
   # Connect to MongoDB
   7
   try:
   8
      client = MongoClient(connection_string)
   9
      print("Successfully connected to MongoDB.")
   10
   except errors.ConnectionError as e:
   11
      print("Failed to connect to MongoDB:", e)
   12
      exit()
   13
   14
   # Access the database and collection
   15
   database = client["test"]
   16
   collection = database["movies"]
   17
   18
   # Insert a document into the collection
   19
   try:
   20
      result = collection.insert_one({"title": "Back to the Future"})
   21
      print(f"Document inserted with _id: {result.inserted_id}")
   22
   except Exception as e:
   23
      print("Failed to insert document:", e)
   24
   25
   # List search indexes for the collection (ensure method exists)
   26
   try:
   27
      cursor = collection.list_search_indexes()
   28
      indexes = list(cursor)  # Convert cursor to list for ease
   29
      if indexes:
   30
         print("Search indexes found:")
   31
         for index in indexes:
   32
               print(index)
   33
      else:
   34
         print("No search indexes found.")
   35
   except Exception as e:
   36
      print("Failed to list search indexes:", e)
   37
   38
   # Close the client connection (Optionally used here for resource management)
   39
   client.close()

3. Replace the placeholder (line 4) with your connection string and save the file.

4. Run the sample application using the following command.

   python connect.py

   OCULTAR SAÍDA

   Successfully connected to MongoDB.
   Document inserted with _id: 67e43400bd92a83c1a81cbb4
   No search indexes found.

   Observação

   The results don't contain any indexes because the sample code didn't create any index for the movies collection.

Para saber mais, consulte Conectar ao MongoDB.