GridFS

Crear un bucket de GridFS

Para almacenar o recuperar archivos de GridFS, cree un bucket u obtenga una referencia a un bucket existente en una base de datos MongoDB. Para crear una instancia GridFSBucket, llame al método NewBucket() con un parámetro de base de datos:

db := client.Database("db")
bucket, err := gridfs.NewBucket(db)
if err != nil {
   panic(err)
}

De forma predeterminada, el nuevo depósito se llama fs. Para crear una instancia de un depósito con un nombre personalizado, llame al método SetName() en una instancia BucketOptions como se indica a continuación:

db := client.Database("db")
opts := options.GridFSBucket().SetName("custom name")
bucket, err := gridfs.NewBucket(db, opts)
if err != nil {
   panic(err)
}

Cargar archivos

Puede cargar un archivo en un depósito GridFS de una de las siguientes maneras:

• Utilice el método UploadFromStream(), que lee desde un flujo de entrada.

• Utilice el método OpenUploadStream(), que escribe en un flujo de salida.

Para cualquiera de los procesos de carga, puedes especificar información de configuración en una instancia de UploadOptions. Para ver una lista completa de los campos UploadOptions, visita la documentación de la API.

file, err := os.Open("path/to/file.txt")
uploadOpts := options.GridFSUpload().SetMetadata(bson.D{{"metadata tag", "first"}})
objectID, err := bucket.UploadFromStream("file.txt", io.Reader(file),
   uploadOpts)
if err != nil {
   panic(err)
}
fmt.Printf("New file uploaded with ID %s", objectID)

New file uploaded with ID 62e00...

file, err := os.Open("path/to/file.txt")
if err != nil {
	panic(err)
}
// Defines options that specify configuration information for files
// uploaded to the bucket
uploadOpts := options.GridFSUpload().SetChunkSizeBytes(200000)
// Writes a file to an output stream
uploadStream, err := bucket.OpenUploadStream("file.txt", uploadOpts)
if err != nil {
	panic(err)
}
fileContent, err := io.ReadAll(file)
if err != nil {
	panic(err)
}
var bytes int
if bytes, err = uploadStream.Write(fileContent); err != nil {
	panic(err)
}
fmt.Printf("New file uploaded with %d bytes written", bytes)
//  Calls the Close() method to write file metadata
if err := uploadStream.Close(); err != nil {
	panic(err)
}

Recuperar información del archivo

Puede recuperar los metadatos de los archivos almacenados en la colección files del bucket GridFS. Cada documento de la colección files contiene la siguiente información:

• El ID del archivo

• La longitud del archivo

• El tamaño máximo del fragmento

• La fecha y hora de carga

• El nombre del archivo

• Un documento metadata en el que puedes almacenar cualquier otra información

Para recuperar datos de archivo, llame al método Find() en una instancia GridFSBucket. Puede pasar un filtro de consulta como argumento a Find() para que coincida solo con ciertos documentos de archivo.

El siguiente ejemplo recupera el nombre de archivo y la longitud de los documentos en la colección files con valores length mayores que 1500:

filter := bson.D{{"length", bson.D{{"$gt", 1500}}}}
cursor, err := bucket.Find(filter)
if err != nil {
   panic(err)
}
type gridfsFile struct {
   Name   string `bson:"filename"`
   Length int64  `bson:"length"`
}
var foundFiles []gridfsFile
if err = cursor.All(context.TODO(), &foundFiles); err != nil {
   panic(err)
}
for _, file := range foundFiles {
   fmt.Printf("filename: %s, length: %d\n", file.Name, file.Length)
}

Descarga de archivos

Puede descargar un archivo GridFS de una de las siguientes maneras:

• Utilice el método DownloadToStream() para descargar un archivo a un flujo de salida.

• Utilice el método OpenDownloadStream() para abrir un flujo de entrada.

id, err := primitive.ObjectIDFromHex("62f7bd54a6e4452da13b3e88")
fileBuffer := bytes.NewBuffer(nil)
if _, err := bucket.DownloadToStream(id, fileBuffer); err != nil {
   panic(err)
}

id, err := primitive.ObjectIDFromHex("62f7bd54a6e4452da13b3e88")
downloadStream, err := bucket.OpenDownloadStream(id)
if err != nil {
   panic(err)
}
fileBytes := make([]byte, 1024)
if _, err := downloadStream.Read(fileBytes); err != nil {
   panic(err)
}

Cambiar nombre de archivos

Puedes actualizar el nombre de un archivo GridFS en tu bucket usando el método Rename(). Pasa un valor de ID de archivo y un nuevo valor filename como argumentos a Rename().

El siguiente ejemplo cambia el nombre de un archivo a "mongodbTutorial.zip":

id, err := primitive.ObjectIDFromHex("62f7bd54a6e4452da13b3e88")
if err := bucket.Rename(id, "mongodbTutorial.zip"); err != nil {
    panic(err)
}

Eliminar archivos

Puedes eliminar un archivo de tu bucket de GridFS con el método Delete(). Pasa un valor de ID de archivo como argumento a Delete().

El siguiente ejemplo elimina un archivo:

id, err := primitive.ObjectIDFromHex("62f7bd54a6e4452da13b3e88")
if err := bucket.Delete(id); err != nil {
   panic(err)
}

Eliminar un depósito GridFS

Puede eliminar un depósito GridFS utilizando el método Drop().

El siguiente ejemplo de código elimina un depósito GridFS:

if err := bucket.Drop(); err != nil {
   panic(err)
}

Documentación de la API

Para obtener más información sobre los métodos o tipos analizados en esta guía, consulte la siguiente documentación de API:

• Nuevo cubo()

• Abrir flujo de carga()

• UploadFromStream()

• find()

• Abrir flujo de descarga()

• Descargar para transmitir()

• Rebautizar()

• Borrar()

• Drop()