Go is querying from the wrong database when using multiple databases with godotenv

I'm trying to query from multiple databases. Each database is connected using the following function:

func connectDB(dbEnv str) *sql.DB{
	// Loading environment variables from local.env file
    
	err1 := godotenv.Load(dbEnv)
	if err1 != nil {
		log.Fatalf("Some error occured. Err: %s", err1)
	}
	dialect := os.Getenv("DIALECT")
	host := os.Getenv("HOST")
	dbPort := os.Getenv("DBPORT")
	user := os.Getenv("USER")
	dbName := os.Getenv("NAME")
	password := os.Getenv("PASSWORD")

	// Database connection string
	dbURI := fmt.Sprintf("port=%s host=%s user=%s "+"password=%s dbname=%s sslmode=disable", dbPort, host, user, password, dbName)

	// Create database object
	db, err := sql.Open(dialect,dbURI)

	if err != nil {
		log.Fatal(err)
	}

	return db

}

type order struct{
	OrderID string `json:"orderID"`
	Name string `json:"name"`
}

type book struct{
	OrderID string `json:"orderID"`
	Name string `json:"name"`
}

func getOrders(db *sql.DB) []order {

    var (
        orderID string
        name string
    )

	var allRows = []order{}
    query := `
        SELECT orderID, name
        FROM orders.orders;
`
	//Get rows using the query
	rows, err := db.Query(query)
	if err != nil { //Log if error
		log.Fatal(err)
	}
	defer rows.Close()
	
	// Add each row into the "allRows" slice
	for rows.Next() {

		err := rows.Scan(&orderID, &name, &date)
		if err != nil {
			log.Fatal(err)
		}

		//Create new order struct with the received data
		row := order{
			OrderID: orderID,
			Name:  name,
		}
		allRows = append(allRows, row)
	}
	//Log if error
	err = rows.Err()
	if err != nil {
		log.Fatal(err)
	}

	return allRows
}

func getBooks(db *sql.DB) []book{
    var (
        bookID string
        name string
    )

	var allRows = []book{}
    query := `
        SELECT bookID, name
        FROM books.books;
        `
	//Get rows using the query
	rows, err := db.Query(query)
	if err != nil { //Log if error
		log.Fatal(err)
	}
	defer rows.Close()
	
	// Add each row into the "allRows" slice
	for rows.Next() {

		err := rows.Scan(&bookID, &name)
		if err != nil {
			log.Fatal(err)
		}

		//Create new book struct with the received data
		row := book{
			BookID: bookID,
			Name:  name,
		}
		allRows = append(allRows, row)
	}
	//Log if error
	err = rows.Err()
	if err != nil {
		log.Fatal(err)
	}

	return allRows
}


func main() {

    ordersDB:= connectDB("ordersDB.env")
    booksDB:= connectDB("booksDB.env")

    orders := getOrders(ordersDB)
    books := getBooks(booksDB)
}

The issue is that when I use ordersDB first, the program only recognizes the table in ordersDB. And when I use booksDB first, the program only recognizes the table in booksDB.
When I try to query a table in booksDB after using ordersDB, it is giving me "relation "books.books" does not exist" error. When I try to query a table in ordersDB after using booksDB, it gives "relation "orders.orders" does not exist"
Is there a better way to connect to multiple databases?

You are using github.com/joho/godotenv to load the database configuration from the environment. Summarising (and cutting out a lot of detail) what you are doing is:

godotenv.Load("ordersDB.env")
host := os.Getenv("HOST")
// Connect to DB
godotenv.Load("booksDB.env")
host := os.Getenv("HOST")
// Connect to DB 2

However as stated in the docs "Existing envs take precedence of envs that are loaded later". This is also stated more clearly here "It's important to note that it WILL NOT OVERRIDE an env variable that already exists".

So your code will load in the first .env file, populate the environment variables, and connect to the database. You will then load the second .env file but, because the environmental variables are already set, they will not be changed and you will connect to the same database a second time.

As a work around you could use Overload. However it's probably better to reconsider your use of environmental variables (and perhaps use different variables for the second connection).