How to connect to MongoDB in a separate function?

In this code, I am connecting the MongoDB database with golang and inserting data in it. I want to separate the Connection() function from Insertdata() function (from other functions also that I made like Finddata(), Deletedata(), etc).

But when I try to separate it, the client variable from Connection() function gives me a message that it is declared but not used and the client variable from Insertdata() gives me a message that it is undeclared. How to handle this?

func Connection() {
	// Set client options
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")

	// Connect to MongoDB
	client, err := mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
}
func Insertdata(inputData interface{}) {
    Connection()
	err, collection := client.Database("PMS").Collection("dataStored")
	collection.InsertOne(context.TODO(), inputData)
	if err != nil {
		log.Fatal(err)
	}
}

Please note that the Connection() function in your code does not return the client instance. You would need to return client in order to use it in your other Insertdata function.

Additionally, I suggest to read through the Usage section on the mongo-go-driver Github page. A good example of how to handle MongoDB connections in Go can be also found in https://stackoverflow.com/questions/58365838/how-to-reuse-mongodb-connection-in-go.

In Go, we typically store dependencies in struct type fields. Define some abstraction around the database that will hold a *mongo.Client (or an interface satisfied by that type):

<!-- language: go -->

type DB struct {
  client *mongo.Client
}

Instantiate the client once in a factory function for your DB type:

<!-- language: go -->

func NewDB(ctx context.Context, uri string) (*DB, error) {
    clientOptions := options.Client().ApplyURI(uri)
    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        return nil, err
    }
    db := DB {
        client: client,
    }
    return &db, nil
}

Then declare Insertdata as a method (not a function) on *DB. That way, you'll be able to use (and re-use) the client within that method through its receiver.

<!-- language: go -->

func (db *DB) Insertdata(ctx context.Context, inputData interface{}) error {
    collection := db.client.Database("PMS").Collection("dataStored")
    _, err := collection.InsertOne(ctx, inputData)
    return err
}

Also:

• Don't hardcode context.TODO() in your production code. Add a context.Context parameter to make the relevant functions and methods cancellable from higher up the call stack.
• Don't ignore errors. If you can't handle them within a function or method, return them to the caller.