How to Allow User to Upload File to Mongodb Database

Docs Domicile → MongoDB Manual

GridFS is a specification for storing and retrieving files that exceed the BSON-document size limit of 16 MB.

Instead of storing a file in a single document, GridFS divides the file into parts, or chunks [ ane ], and stores each chunk every bit a separate certificate. By default, GridFS uses a default chunk size of 255 kB; that is, GridFS divides a file into chunks of 255 kB with the exception of the concluding chunk. The terminal chunk is simply every bit large as necessary. Similarly, files that are no larger than the chunk size just have a final clamper, using only as much space as needed plus some additional metadata.

GridFS uses 2 collections to store files. I collection stores the file chunks, and the other stores file metadata. The section GridFS Collections describes each collection in detail.

When you lot query GridFS for a file, the driver will reassemble the chunks as needed. You tin can perform range queries on files stored through GridFS. You can also access data from arbitrary sections of files, such as to "skip" to the center of a video or audio file.

GridFS is useful not only for storing files that exceed sixteen MB but as well for storing any files for which you want access without having to load the unabridged file into retentivity. Meet also When to Use GridFS.

In MongoDB, utilise GridFS for storing files larger than 16 MB.

In some situations, storing large files may be more efficient in a MongoDB database than on a system-level filesystem.

• If your filesystem limits the number of files in a directory, yous can use GridFS to store every bit many files as needed.
• When you desire to access data from portions of large files without having to load whole files into retention, you can utilize GridFS to retrieve sections of files without reading the entire file into memory.
• When yous want to keep your files and metadata automatically synced and deployed across a number of systems and facilities, yous can employ GridFS. When using geographically distributed replica sets, MongoDB tin can distribute files and their metadata automatically to a number of mongod instances and facilities.

Do non use GridFS if y'all need to update the content of the entire file atomically. As an culling yous can store multiple versions of each file and specify the current version of the file in the metadata. You lot can update the metadata field that indicates "latest" status in an atomic update after uploading the new version of the file, and later remove previous versions if needed.

Furthermore, if your files are all smaller than the sixteen MB BSON Document Size limit, consider storing each file in a single document instead of using GridFS. Yous may utilize the BinData information type to shop the binary information. See your drivers documentation for details on using BinData.

To store and call back files using GridFS, utilise either of the following:

• A MongoDB commuter. Run into the drivers documentation for information on using GridFS with your commuter.
• The mongofiles control-line tool. See the mongofiles reference for documentation.

GridFS stores files in two collections:

• chunks stores the binary chunks. For details, encounter The chunks Collection.
• files stores the file's metadata. For details, encounter The files Collection.

GridFS places the collections in a mutual bucket by prefixing each with the bucket name. By default, GridFS uses two collections with a bucket named fs:

• fs.files
• fs.chunks

You lot can cull a different bucket proper name, too as create multiple buckets in a single database. The full collection proper noun, which includes the saucepan name, is field of study to the namespace length limit.

Each document in the chunks [ 1 ] collection represents a distinct chunk of a file as represented in GridFS. Documents in this collection have the post-obit form:

                                      
                      
                        
                          
{
                        
                        
                          
                            "_id"                                                        : <                            ObjectId                            >                            ,
                        
                        
                          
                            "files_id"                                                        : <                            ObjectId                            >                            ,
                        
                        
                          
                            "n"                                                        : <                            num                            >                            ,
                        
                        
                          
                            "data"                                                        : <                            binary                            >
                        
                        
                          
}
                        
                      
                    
                                  

A document from the chunks drove contains the following fields:

chunks._id

The unique ObjectId of the chunk.

chunks.files_id

The _id of the "parent" document, as specified in the files collection.

chunks.north

The sequence number of the clamper. GridFS numbers all chunks, starting with 0.

chunks.data

The chunk's payload as a BSON Binary type.

Each document in the files drove represents a file in GridFS.

                                      
                      
                        
                          
{
                        
                        
                          
                            "_id"                                                        : <                            ObjectId                            >                            ,
                        
                        
                          
                            "length"                                                        : <                            num                            >                            ,
                        
                        
                          
                            "chunkSize"                                                        : <                            num                            >                            ,
                        
                        
                          
                            "uploadDate"                                                        : <                            timestamp                            >                            ,
                        
                        
                          
                            "md5"                                                        : <                            hash                            >                            ,
                        
                        
                          
                            "filename"                                                        : <                            string                            >                            ,
                        
                        
                          
                            "contentType"                                                        : <                            cord                            >                            ,
                        
                        
                          
                            "aliases"                                                        :                             <string array>,
                        
                        
                          
                            "metadata" : <whatsoever>,
                        
                        
                          
}
                        
                      
                    
                                  

Documents in the files collection contain some or all of the following fields:

files._id

The unique identifier for this certificate. The _id is of the data type you lot chose for the original document. The default type for MongoDB documents is BSON ObjectId.

files.length

The size of the document in bytes.

files.chunkSize

The size of each chunk in bytes. GridFS divides the document into chunks of size chunkSize, except for the last, which is merely every bit large as needed. The default size is 255 kilobytes (kB).

files.uploadDate

The engagement the document was offset stored by GridFS. This value has the Appointment type.

files.md5

Deprecated

The MD5 algorithm is prohibited past FIPS 140-two. MongoDB drivers deprecate MD5 back up and volition remove MD5 generation in future releases. Applications that require a file digest should implement information technology outside of GridFS and shop in files.metadata.

An MD5 hash of the complete file returned past the filemd5 command. This value has the String type.

files.filename

Optional. A homo-readable proper name for the GridFS file.

files.contentType

Deprecated

Optional. A valid MIME type for the GridFS file. For awarding utilise only.

Use files.metadata for storing information related to the MIME type of the GridFS file.

files.aliases

Deprecated

Optional. An array of alias strings. For application use just.

Use files.metadata for storing information related to the MIME type of the GridFS file.

files.metadata

Optional. The metadata field may be of any data type and can hold any additional data y'all want to store. If you lot wish to add additional arbitrary fields to documents in the files collection, add them to an object in the metadata field.

GridFS uses indexes on each of the chunks and files collections for efficiency. Drivers that adjust to the GridFS specification automatically create these indexes for convenience. Yous can also create whatsoever additional indexes every bit desired to suit your application'south needs.

GridFS uses a unique, compound alphabetize on the chunks collection using the files_id and n fields. This allows for efficient retrieval of chunks, as demonstrated in the following instance:

                                      
db                      .fs                      .chunks                      .notice                      (                       {                      files_id:                       myFileID } )                      .sort                      (                       {                      n:                      1                      } )
                                  

Drivers that adapt to the GridFS specification will automatically ensure that this alphabetize exists before read and write operations. Meet the relevant driver documentation for the specific behavior of your GridFS application.

If this index does not exist, you tin can issue the post-obit operation to create it using mongosh:

                                      
db                      .fs                      .chunks                      .createIndex                      (                       {                      files_id:                      1,                      n:                      one                      }                      ,                       {                      unique:                      true                      } )                      ;
                                  

GridFS uses an index on the files drove using the filename and uploadDate fields. This index allows for efficient retrieval of files, as shown in this case:

                                      
db                      .fs                      .files                      .detect                      (                       {                      filename:                       myFileName } )                      .sort                      (                       {                      uploadDate:                      ane                      } )
                                  

Drivers that conform to the GridFS specification volition automatically ensure that this index exists before read and write operations. Run across the relevant driver documentation for the specific behavior of your GridFS awarding.

If this index does not exist, y'all tin issue the following operation to create information technology using mongosh:

                                      
db                      .fs                      .files                      .createIndex                      (                       {                      filename:                      1,                      uploadDate:                      1                      } )                      ;
                                  

[ ane ]

(i, 2) The use of the term chunks in the context of GridFS is not related to the use of the term chunks in the context of sharding.

There are two collections to consider with GridFS - files and chunks.

To shard the chunks collection, utilize either { files_id : 1, n : 1 } or { files_id : 1 } as the shard central index. files_id is an ObjectId and changes monotonically.

For MongoDB drivers that do not run filemd5 to verify successful upload (for instance, MongoDB drivers that support MongoDB 4.0 or greater), you can utilize Hashed Sharding for the chunks collection.

If the MongoDB driver runs filemd5, yous cannot utilise Hashed Sharding. For details, run into SERVER-9888.

The files collection is pocket-sized and only contains metadata. None of the required keys for GridFS lend themselves to an even distribution in a sharded environment. Leaving files unsharded allows all the file metadata documents to live on the primary shard.

If you must shard the files collection, utilise the _id field, possibly in combination with an awarding field.

fordsuation1976.blogspot.com

Source: https://www.mongodb.com/docs/manual/core/gridfs/

Share this post