what is a potential issue in writing data to mongodb databases?
Key Takeaways
- Even though MongoDB doesn't enforce information technology, it is vital to pattern a schema.
- Too, indexes take to be designed in conjunction with your schema and access patterns.
- Avoid large objects, and specially large arrays.
- Be careful with MongoDB's settings, especially when it concerns security and immovability.
- MongoDB doesn't have a query optimizer, and so you have to exist very careful how you society the query operations.
I've been a database person for an embarrassing length of time, merely I simply started working with MongoDB recently. When I was starting out with MongoDB, there are a few things that I wish I'd known nigh. With general feel, there will always be preconceptions of what databases are and what they do. In hopes of making it easier for other people, hither is a list of mutual mistakes.
Creating a MongoDB server without authentication
Unfortunately, MongoDB installs without hallmark by default. This is fine on a workstation, accessed only locally. But because MongoDB is a multiuser system that likes to use every bit much memory as it can, it is much ameliorate installed on a server, loaded up to the hilt with RAM, even for development work. To install it on a server on the default port without hallmark is asking for trouble, specially when one tin execute arbitrary JavaScript within a query (e.g. $where as a vector for injection attacks).
There are several hallmark methods, merely user ID/password credentials are easy to install and manage. Do that method while you think almost your fancy LDAP-based authentication. While we're talking about security, MongoDB must be kept upwards-to-engagement, and it is always worth checking logs for signs of unauthorized admission. I like to employ a different port to the default.
Forgetting to necktie down MongoDB'due south assail surface
MongoDB'due south security checklist gives good advice on reducing the chance of penetration of the network and of a data alienation. It is easy to shrug and assume that a evolution server doesn't need a high level of security. Not and so: It is relevant to all MongoDB servers. In detail, unless there is a very good reason to utilize mapReduce, group, or $where, you lot should disable the use of arbitrary JavaScript by setting javascriptEnabled:simulated in the config file. Because the information files of standard MongoDB is not encrypted, It is also wise to Run MongoDB with a Dedicated User with full access to the information files restricted to that user so as to use the operating systems own file-access controls.
Failing to design a schema
MongoDB doesn't enforce a schema. This is non the same affair as saying that information technology doesn't demand ane. If you actually want to save documents with no consistent schema, you can store them very apace and easily merely retrieval can exist the very devil.
The classic commodity '6 Rules of Thumb for MongoDB Schema Design' is well worth reading, and features similar Schema Explorer from third-party tools such as Studio 3T is well worth having for regular schema check-ups.
Forgetting about collations (sort society)
This can result in more than frustration and wasted time than whatsoever other misconfiguration. MongoDB defaults to using binary collation. This is helpful to no cultures anywhere. Case-sensitive, accent-sensitive, binary collations were considered curious anachronisms in the eighties along with chaplet, kaftans and curly moustaches. Now, they are inexcusable. In existent life a motorbike is the aforementioned equally a Motorbike. United kingdom is the same place as britain. Lower-case (minuscule) is only a cursive equivalent of an upper-example (majuscule) alphabetic character. Don't get me started nearly the collation of absolute characters (diacritics). When you create a MongoDB database, use an accent-insensitive, case-insensitive collation appropriate to the languages and culture of the users of the system. This makes searches through string data and then much easier.
Creating collections with large documents
MongoDB is happy to accommodate big documents of upwardly to 16 MB in collections, and GridFS is designed for large documents over 16MB. Considering big documents can be accommodated doesn't mean that it is a good idea. MongoDB works best if you keep individual documents to a few kilobytes in size, treating them more like rows in a wide SQL tabular array. Large documents will cause several functioning issues.
Creating documents with large arrays
Documents can contain arrays. It is all-time to keep the number of array elements well below four figures. If the assortment is added to oft, it will outgrow the containing document so that its location on deejay has to exist moved, which in turn means every alphabetize must be updated. A lot of index rewriting is going to take place when a document with a large array is re-indexed, because at that place is a separate alphabetize entry for every array element. This re-indexing also happens when such a document is inserted or deleted.
MongoDB has a 'padding factor' to provide infinite for documents to grow, in order to minimize this problem.
You might think that you could get around this by not indexing arrays. Unfortunately, without the indexes, you can run into other issues. Because documents are scanned from outset to terminate, information technology takes longer to find elements towards the end of an array, and most operations dealing with such a document would be tedious.
Forgetting that the club of stages in an aggregation matters
In a database system with a query optimizer, the queries that y'all write are explanations of what yous want rather than how to get information technology. It is like ordering in a restaurant; you commonly just lodge the dish, rather than requite detailed instructions to the cook.
In MongoDB, y'all are instructing the melt. For case, you need to make sure that the data is reduced equally early on as possible in the pipeline via $match and $project, sorts happen only once the data is reduced, and that lookups happen in the gild y'all intend. Having a query optimizer that removes unnecessary work, orders the stages optimally, and chooses the type of join can spoil you. MongoDB gives y'all more control, but at a cost in convenience.
Tools like Studio 3T make it simpler to build accurate MongoDB assemblage queries. Its Aggregation Editor characteristic lets you apply pipeline operators i phase at a time, and you tin validate inputs and outputs at each stage for easier debugging.
Using fast writes
Never gear up MongoDB for high-speed writes with low durability. This 'file-and-forget' style makes writes announced to be fast because your command returns before actually writing anything. If the system crashes earlier the information is written to deejay, it is lost and risks being in an inconsistent country. Fortunately, 64-bit MongoDB has journaling enabled.
The MMAPv1 and WiredTiger storage engine both utilize journaling to prevent this, though WiredTiger can exist restored to the concluding consequent checkpoint during recovery if journaling is switched off.
Journaling volition ensure that the database is in a consistent state when information technology recovers and will save all the information upwards to the point that the journal is written. The duration between journal writes is configurable using the commitIntervalMs run-time pick.
To be confident of your writes, make sure that journaling is enabled (storage.periodical.enabled) in the configuration file and the commit interval corresponds with what you tin afford to lose.
Sorting without an alphabetize
In searches and aggregations, you volition often desire to sort your data. Hopefully, it is done in one of the final stages, after filtering the consequence, to reduce the amount of information beingness sorted. Even so, you volition need an index that can cover the sort. Either a single or chemical compound alphabetize will do this.
When no suitable alphabetize is available, MongoDB is forced to practise without. There is a 32MB memory limit on the combined size of all documents in the sort performance and if MongoDB hits the limit, it will either produce an error or occasionally only return an empty set of records.
Lookups without supporting indexes
Lookups perform a similar office to a SQL bring together. To perform well, they crave an index on the key value used every bit the foreign key. This isn't obvious because the utilize isn't reported in explicate(). These indexes are in addition to the index recorded by explicate() that is used by the $lucifer and $sort pipeline operators when they occur at the get-go of the pipeline. Indexes tin now embrace any stage an aggregation pipeline.
Not using multi-updates
The db.collection.update() method is used to modify part or all of an existing document or replace an existing document entirely, depending on the update parameter yous provide. It is less obvious that information technology doesn't do all the documents in a collection unless you set the multi parameter to update all documents that match the query criteria.
Forgetting the significance of the order of keys in a hash object
In JSON, an object consists of an unordered drove of null or more name/value pairs, where a proper noun is a string and a value is a string, number, boolean, null, object, or array.
Unfortunately, BSON attaches significance to social club when doing searches. The social club of keys within embedded objects matters in MongoDB, i.e. { firstname: "Phil", surname: "gene" } does not match { { surname: "cistron", firstname: "Phil" }. This means that you have to preserve the order of proper noun/value pairs in your documents if you want to be sure to find them.
Confusing 'naught' and 'undefined'
The 'undefined' value has never been valid in JSON, according to the official JSON standard (ECMA-404, Department v), despite the fact that it is used in JavaScript. Furthermore, information technology is 'deprecated' in BSON and converted to $zilch which isn't always a happy solution. Avoid using 'undefined' in MongoDB.
Using $limit() without $sort()
Often, when you are developing in MongoDB, it useful to just see a sample of the results that are returned from a query or aggregation. $limit() serves this purpose, simply it should never be in the concluding version of the code, unless y'all showtime use $sort. This is because you can't otherwise guarantee the guild of the effect and you won't be able to reliably 'folio' through information. You get different records in the top of the result depending on the way you lot've sorted information technology. To work reliably, queries or aggregations must be 'deterministic', pregnant that they give the same results every time they are executed. Lawmaking that has $limit without $sort isn't deterministic, and tin cause bugs later on that are difficult to track downwards.
Conclusions
The only way that you could end upward feeling disappointed in MongoDB is if you compare it directly with another blazon of database such as an RDBMS, or come to it with item expectations. It is similar comparing an orange with a fork. Database systems have their purposes. Information technology is best to just understand and appreciate these differences. It would be a shame to pressure the developers of MongoDB down a road that forced them towards an RDBMS way of doing things, and I'd like to continue to see new and interesting ways of solving one-time issues such equally ensuring the integrity of data and making data systems resilient to failure and malice.
MongoDB's introduction of ACID transactionality in version 4.0 is a good case of introducing important improvements in an innovative mode. Multi-document, multi-statement transactions are at present atomic, and it is possible to arrange the fourth dimension allowed to acquire locks, and to expire hung transactions, besides as to alter the isolation level.
Near the Author
Phil Factor (real name withheld to protect the guilty), aka Database Mole, has nearly forty years of feel with database-intensive applications. Despite having in one case been shouted at past a furious Beak Gates at an exhibition in the early 1980s, he has remained resolutely bearding throughout his career.
Source: https://www.infoq.com/articles/Starting-With-MongoDB/
0 Response to "what is a potential issue in writing data to mongodb databases?"
ارسال یک نظر