MongoDB

12-byte ID for documents

• pwd():
• run("ls", "-l", "/home/myUser/my-scripts/")

1. define helper function in js
2. load js
3. typeof helper_function

Use .mongorc.js in your home directory, This file is run whenever you start up the shell.

• common example in .mongorc.js: remove some of the more "dangerous" shell helpers

var no = function() {
    print("Not on my watch.");
};

// Prevent dropping databases
db.dropDatabase = DB.prototype.dropDatabase = no;

// Prevent dropping collections
DBCollection.prototype.drop = no;

// Prevent dropping an index
DBCollection.prototype.dropIndex = no;

// Prevent dropping indexes
DBCollection.prototype.dropIndexes = no;

• use --norc option to disable .mongorc.js

Just set the prompt variable

prompt = function() {
    if (typeof db == 'undefined') {
	return '(nodb)> ';
    }

    // Check the last db operation
    try {
	db.runCommand({getLastError:1});
    }
    catch (e) {
	print(e);
    }

    return db+"> ";
};

• contains

db.food.insertOne({"fruit" : ["apple", "banana", "peach"]})
db.food.find({"fruit" : "banana"}) // successfully match the document

• contains all: db.food.find({fruit : {$all : ["apple", "banana"]}})
• exact match: db.food.find({"fruit" : ["apple", "banana", "peach"]})
• index match: db.food.find({"fruit.2" : "peach"})
• $size: not working with $gt
• $slice: db.blog.posts.findOne(criteria, {"comments" : {"$slice" : [23, 10]}}), db.blog.posts.findOne(criteria, {"comments" : {"$slice" : -1}})
• db.blog.posts.find({"comments.name" : "bob"}, {"comments.$" : 1}): return the matching element with the $
• range query on array elements: db.test.find({"x" : {"$elemMatch" : {"$gt" : 10, "$lt" : 20}}})

• db.people.find({"name.first" : "Joe", "name.last" : "Schmoe"})

• Allows you to execute arbitrary JavaScript as part of your query.(Insecure)

"$where" queries should not be used unless strictly necessary: they are much slower than regular queries. Each document has to be converted from BSON to a JavaScript object and then run through the "$where" expression.

limit, skip, sort

• Avoiding Large Skips: large skips are not very efficient

Tells the database not to time out the cursor.

• Batch inserts limit: 48 MB. Drivers will split up the batch insert into multiple 48 MB batch inserts

Old method before mongo 3.0. Use insertOne and insertMany instead

• {"$inc": {"field": 1}}: create or increment 1
• {"$set": {"new/existed field": "newValue"}}, {"$unset": {"field": 1}}
• change embedded documents: {"$set": {"field.sub": "newValue"}}
• {"$setOnInsert" : {"createdAt" : new Date()}}: can be useful for creating padding, initializing counters, and for collections that do not use ObjectIds.
• findOneAndUpdate (after 4.2): can return the item and update it in a single operation
• findOneAndReplace
• findOneAndDelete

Eliminating race condition: query->if exists->update

cursor.explain("executionStats")

• FETCH: "FETCH" stage will retrieve the documents themselves and return them in batches as the client requests them.
• SORT: means MongoDB would have been unable to sort the result set in the database using an index and instead would have had to do an in-memory sort.

• equality filter: {"age": 25}
• multivalue filter: {"age": {"$gte": 40}}
• sort component

Cardinality refers to how many distinct values there are for a field in a collection. e.g. "gender" low cardinality. "username" high cardinality In general, the greater the cardinality of a field, the more helpful an index on that field can be

1. Keys for equality filters should appear first.
2. Keys used for sorting should appear before multivalue fields.
3. Keys for multivalue filters should appear last.

• $ne: they basically have to scan the entire index.
• $not: will fall back to doing a table scan
• $nin: always uses a table scan

Performs two queries and then merges the results. In general, doing two queries and merging the results is much less efficient than doing a single query; thus, whenever possible, prefer $in to $or

• unique. notice: unique index count null as a value.

• poorer write performance on text-indexed collections than on others

TTL indexes expire and remove data from normal collections based on the value of a date-typed field and a TTL value for the index.

db.sessions.createIndex({"lastUpdated" : 1}, {"expireAfterSeconds" : 60*60*24})

// change the expireAfterSeconds
db.runCommand({"collMod" : "someapp.cache",
	       "index" : {"keyPattern" : {"lastUpdated" : 1},
			  "expireAfterSeconds" : 3600 }});

• MongoDB sweeps the TTL index once per minute

like circular queues

• TTL indexes are recommended over capped collections because they perform better with the WiredTiger storage engine

db.createCollection("my_collection",
		    {"capped" : true,
		     "size" : 100000, // collection has a fixed size of 100,000 bytes
		     "max": 100}); // max number of documents

// convert the test collection to a capped collection of 10,000 bytes
db.runCommand({"convertToCapped" : "test", "size" : 10000});

// chunk in fs.chunks
{
    "_id" : ObjectId("..."),
    "n" : 0,
    "data" : BinData("..."),
    "files_id" : ObjectId("...")
}

• "files_id": The "_id" of the file document that contains the metadata for the file this chunk is from
• "n": The chunk's position in the file, relative to the other chunks
• "data": The bytes in this chunk of the file

• "length": The total number of bytes making up the content of the file.
• "chunkSize": The size of each chunk comprising the file, in bytes. The default is 255 KB, but this can be adjusted if needed.
• "uploadDate": A timestamp representing when this file was stored in GridFS.
• "md5": An MD5 checksum of this file’s contents, generated on the server side.

Fundamental to the group stage is the "_id" field that we specify as part of the document. This is the value of the $group operator itself, using a very strict interpretation.

db.companies.aggregate([
    { $group: {
	_id: { founded_year: "$founded_year" },
	average_number_of_employees: { $avg: "$number_of_employees" }
    } },
    { $sort: { average_number_of_employees: -1 } }

])

db.companies.aggregate( [
    { $match: { "relationships.person": { $ne: null } } },
    { $project: { relationships: 1, _id: 0 } },
    { $unwind: "$relationships" },
    { $group: {
	_id: "$relationships.person",
	count: { $sum: 1 }
    } },
    { $sort: { count: -1 } }
]).pretty()