O pacote oficial go.mongodb.org/mongo-driver para MongoDB em Go fornece uma maneira eficiente de construir filtros para consultas. Os filtros são euqivalentes às cláusulas usadas em operações como find no shell do MongoDB.

Para conectar-se ao banco de dados, utilize uma estrutura similar ao exemplo abaixo, adatpando as credenciais e nomes:

package main

import (
    "context"
    "fmt"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/mongo/readpref"
)

type Registro struct {
    ID    int    `bson:"id"`
    Nome  string `bson:"nome"`
    Valor string `bson:"valor"`
}

func main() {
    uri := "mongodb://admin:minhasenha@localhost:27017/meubanco"
    clientOpts := options.Client().ApplyURI(uri)
    
    client, err := mongo.NewClient(clientOpts)
    if err != nil {
        fmt.Println("Erro ao criar cliente:", err)
        return
    }
    
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()
    err = client.Connect(ctx)
    if err != nil {
        fmt.Println("Erro na conexão:", err)
        return
    }
    defer client.Disconnect(ctx)
    
    err = client.Ping(ctx, readpref.Primary())
    if err != nil {
        fmt.Println("Erro ao verificar conexão:", err)
        return
    }
    
    collection := client.Database("meubanco").Collection("registros")
    ctxFind, cancelFind := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancelFind()
    
    var resultado Registro
    // Filtro usando operador $or com tipos BSON
    filtro := bson.M{"$or": bson.A{
        bson.M{"id": 42},
        bson.M{"nome": "exemplo"},
    }}
    err = collection.FindOne(ctxFind, filtro).Decode(&resultado)
    if err != nil {
        fmt.Println("Erro na consulta:", err)
        return
    }
    fmt.Println(resultado)
}

Os métodos como FindOne e Find recebem um parâmetro de filtro, que no MongoDB corresponde a um documento BSON, por exemplo:

db.registros.find({$or: [{'id': 42}, {'nome': 'exemplo'}]});

Em Go, não é possível definir filtros como strings JSON diretamente. Em vez disso, utiliza-se estruturas fornecidas pelo pacote bson. As principais tipos são:

• bson.M: Representa um documento BSON não ordenado, equivalente a map[string]interface{}.
• bson.A: Representa um array BSON, equivalente a []interface{}.
• bson.D: Representa um documento BSON ordenado, útil quando a ordem dos elementos é importante.

Por exemplo, o filtro pode ser construído assim:

 filtro := bson.M{"$or": bson.A{
     bson.M{"id": 100},
     bson.M{"status": "ativo"},
 }}

Observe que bson.M é apenas um alias para map[string]interface{}, e bson.A para []interface{}. Portanto, o mesmo filtro pode ser escrito usando tipos básicos do Go:

 filtro := map[string]interface{}{
     "$or": []interface{}{
         map[string]interface{}{"id": 100},
         map[string]interface{}{"status": "ativo"},
     },
 }

A razão pela qual filtros em string não funcionam é que a comunicação com o MongoDB ocorre em formato BSON (JSON binário), e o driver precisa de estruturas tipadas para serialização correta. O shell do MongoDB converte strings JSON para BSON internamente, mas em código Go, é necessário usar as estruturas do pacote bson para garantir a compatibilidade.

Ao converter consultas do MongoDB para código Go, mapeie operadores como $or e campos para chaves em mapas, e valores para interfaces correspondentes.