asp.net mvc pdf viewer control : Add pdf together one file Library software component .net wpf html mvc mongodb_%20the%20definitive%20guide%20-%20kristina%20chodorow_14016-part1791

This would push three new elements onto the array. Specify a single-element array to
get equivalent behavior to the non-$each form of "$push".
If you only want the array to grow to a certain length, you can also use the "$slice"
operator in conjunction with "$push" to prevent an array from growing beyond a certain
size, effectively making a “top N” list of items:
> db.movies.find({"genre" : "horror"}, 
... {"$push" : {"top10" : {
...     "$each" : ["Nightmare on Elm Street", "Saw"], 
...     "$slice" : -10}}})
This example would limit the array to the last 10 elements pushed. Slices must always
be negative numbers.
If the array was smaller than 10 elements (after the push), all elements would be kept.
If the array was larger than 10 elements, only the last 10 elements would be kept. Thus,
"$slice" can be used to create a queue in a document.
Finally, you can "$sort" before trimming, so long as you are pushing subobjects onto
the array:
> db.movies.find({"genre" : "horror"}, 
... {"$push" : {"top10" : {
...     "$each" : [{"name" : "Nightmare on Elm Street""rating" : 6.6}, 
...                {"name" : "Saw""rating" : 4.3}], 
...     "$slice" : -10, 
...     "$sort" : {"rating" : -1}}}})
This will sort all of the objects in the array by their "rating" field and then keep the
first 10. Note that you must include "$each"; you cannot just "$slice" or "$sort" an
array with "$push".
Using arrays as sets
You might want to treat an array as a set, only adding values if they are not present. This
can be done using a "$ne" in the query document. For example, to push an author onto
a list of citations, but only if he isn’t already there, use the following:
> db.papers.update({"authors cited" : {"$ne" : "Richie"}},
... {$push : {"authors cited" : "Richie"}})
This can also be done with "$addToSet", which is useful for cases where "$ne" won’t
work or where "$addToSet" describes what is happening better.
For instance, suppose you have a document that represents a user. You might have a set
of email addresses that they have added:
> db.users.findOne({"_id" : ObjectId("4b2d75476cc613d5ee930164")})
{
"_id" : ObjectId("4b2d75476cc613d5ee930164"),
"username" : "joe",
Updating Documents | 39
Add pdf together one file - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
batch combine pdf; add two pdf files together
Add pdf together one file - VB.NET PDF File Merge Library: Merge, append PDF files in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Guide and Sample Codes to Merge PDF Documents in .NET Project
append pdf; split pdf into multiple files
"emails" : [
"joe@example.com",
"joe@gmail.com",
"joe@yahoo.com"
]
}
When adding another address, you can use "$addToSet" to prevent duplicates:
> db.users.update({"_id" : ObjectId("4b2d75476cc613d5ee930164")},
... {"$addToSet" : {"emails" : "joe@gmail.com"}})
> db.users.findOne({"_id" : ObjectId("4b2d75476cc613d5ee930164")})
{
"_id" : ObjectId("4b2d75476cc613d5ee930164"),
"username" : "joe",
"emails" : [
"joe@example.com",
"joe@gmail.com",
"joe@yahoo.com",
]
}
> db.users.update({"_id" : ObjectId("4b2d75476cc613d5ee930164")},
... {"$addToSet" : {"emails" : "joe@hotmail.com"}})
> db.users.findOne({"_id" : ObjectId("4b2d75476cc613d5ee930164")})
{
"_id" : ObjectId("4b2d75476cc613d5ee930164"),
"username" : "joe",
"emails" : [
"joe@example.com",
"joe@gmail.com",
"joe@yahoo.com",
"joe@hotmail.com"
]
}
You can also use "$addToSet" in conjunction with "$each" to add multiple unique
values, which cannot be done with the "$ne"/"$push" combination. For instance, we
could use these modifiers if the user wanted to add more than one email address:
> db.users.update({"_id" : ObjectId("4b2d75476cc613d5ee930164")}, {"$addToSet" :
... {"emails" : {"$each" : 
...     ["joe@php.net""joe@example.com", "joe@python.org"]}}})
> db.users.findOne({"_id" : ObjectId("4b2d75476cc613d5ee930164")})
{
"_id" : ObjectId("4b2d75476cc613d5ee930164"),
"username" : "joe",
"emails" : [
"joe@example.com",
"joe@gmail.com",
"joe@yahoo.com",
"joe@hotmail.com"
"joe@php.net"
"joe@python.org"
40 | Chapter 3: Creating, Updating, and Deleting Documents
C# Word - Merge Word Documents in C#.NET
C# DLLs: Merge Word File. Add references: Combine and Merge Multiple Word Files into One Using C#. You may also combine more Word documents together.
pdf combine files online; acrobat combine pdf
C# PowerPoint - Merge PowerPoint Documents in C#.NET
can easily merge and append one PowerPoint document to can be merged and appended together according to Add necessary XDoc.PowerPoint DLL libraries into your
pdf combine; combine pdf
]
}
Removing elements
There are a few ways to remove elements from an array. If you want to treat the array
like a queue or a stack, you can use "$pop", which can remove elements from either
end. {"$pop" : {"key" : 1}} removes an element from the end of the array. {"$pop" :
{"key" : -1}} removes it from the beginning.
Sometimes an element should be removed based on specific criteria, rather than its
position in the array. "$pull" is used to remove elements of an array that match the
given criteria. For example, suppose we have a list of things that need to be done but
not in any specific order:
> db.lists.insert({"todo" : ["dishes""laundry""dry cleaning"]})
If we do the laundry first, we can remove it from the list with the following:
> db.lists.update({}, {"$pull" : {"todo" : "laundry"}})
Now if we do a find, we’ll see that there are only two elements remaining in the array:
> db.lists.find()
{
"_id" : ObjectId("4b2d75476cc613d5ee930164"),
"todo" : [
"dishes",
"dry cleaning"
]
}
Pulling removes all matching documents, not just a single match. If you have an array
that looks like [1, 1, 2, 1] and pull 1, you’ll end up with a single-element array, [2].
Array operators can be used only on keys with array values. For example, you cannot
push on to an integer or pop off of a string, for example. Use "$set" or "$inc" to modify
scalar values.
Positional array modifications
Array manipulation becomes a little trickier when we have multiple values in an array
and want to modify some of them. There are two ways to manipulate values in arrays:
by position or by using the position operator (the "$" character).
Arrays use 0-based indexing, and elements can be selected as though their index were
a document key. For example, suppose we have a document containing an array with a
few embedded documents, such as a blog post with comments:
> db.blog.posts.findOne()
{
"_id" : ObjectId("4b329a216cc613d5ee930192"),
Updating Documents | 41
VB.NET Word: How to Process MS Word in VB.NET Library in .NET
MSWordDocx.dll", which, when used together with other online tutorial on how to add & insert one powerful & profession imaging controls, PDF document, image to
all jpg to one pdf converter; add pdf files together online
C# Excel - Merge Excel Documents in C#.NET
SDK, C# developers can easily merge and append one Excel document to Excel documents can be merged and appended together according to Add necessary references:
combine pdf online; apple merge pdf
"content" : "...",
"comments" : [
{
"comment" : "good post",
"author" : "John",
"votes" : 0
},
{
"comment" : "i thought it was too short",
"author" : "Claire",
"votes" : 3
},
{
"comment" : "free watches",
"author" : "Alice",
"votes" : -1
}
]
}
If we want to increment the number of votes for the first comment, we can say the
following:
> db.blog.update({"post" : post_id},
... {"$inc" : {"comments.0.votes" : 1}})
In many cases, though, we don’t know what index of the array to modify without query‐
ing for the document first and examining it. To get around this, MongoDB has a posi‐
tional operator, "$", that figures out which element of the array the query document
matched and updates that element. For example, if we have a user named John who
updates his name to Jim, we can replace it in the comments by using the positional
operator:
db.blog.update({"comments.author" : "John"},
... {"$set" : {"comments.$.author" : "Jim"}})
The positional operator updates only the first match. Thus, if John had left more than
one comment, his name would be changed only for the first comment he left.
Modifier speed
Some modifiers are faster than others. $inc modifies a document in place: it does not
have to change the size of a document, only a couple of bytes, so it is very efficient. On
the other hand, array modifiers might change the size of a document and can be slow.
("$set" can modify documents in place if the size isn’t changing but otherwise is subject
to the same performance limitations as array operators.)
When you start inserting documents into MongoDB, it puts each document right next
to the previous one on disk. Thus, if a document gets bigger, it will no longer fit in the
space it was originally written to and will be moved to another part of the collection.
42 | Chapter 3: Creating, Updating, and Deleting Documents
C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
PDF document layout and all the paragraphs are joining together, our C# RasterEdge.XDoc.PDF.dll. RasterEdge.Imaging.Basic' or any other assembly or one of
pdf combine pages; add multiple pdf files into one online
VB.NET Image: VB.NET ISSN Barcode Reader & Scanner; Decode Barcode
be integrated and used in VB.NET class application together. VB.NET ISSN barcode scanner control add-on can barcode recognition from one page PDF file works in
pdf merge; combine pdf files
You can see this in action by creating a new collection with just a few documents and
then making a document that is sandwiched between two other documents larger. It
will be bumped to the end of the collection:
> db.coll.insert({"x" :"a"})
> db.coll.insert({"x" :"b"})
> db.coll.insert({"x" :"c"})
> db.coll.find()
"_id" : ObjectId("507c3581d87d6a342e1c81d3"), "x" : "a" }
"_id" : ObjectId("507c3583d87d6a342e1c81d4"), "x" : "b" }
"_id" : ObjectId("507c3585d87d6a342e1c81d5"), "x" : "c" }
> db.coll.update({"x" : "b"}, {$set: {"x" : "bbb"}})
> db.coll.find()
"_id" : ObjectId("507c3581d87d6a342e1c81d3"), "x" : "a" }
"_id" : ObjectId("507c3585d87d6a342e1c81d5"), "x" : "c" }
"_id" : ObjectId("507c3583d87d6a342e1c81d4"), "x" : "bbb" }
When MongoDB has to move a document, it bumps the collection’s padding factor,
which is the amount of extra space MongoDB leaves around new documents to give
them room to grow. You can see the padding factor by running db.coll.stats(). Be‐
fore doing the update above, the "paddingFactor" field will be 1: allocate exactly the
size of the document for each new document, as shown in Figure 3-1. If you run it again
after making one of the documents larger (as shown in Figure 3-2), you’ll see that it has
grown to around 1.5: each new document will be given half of its size in free space to
grow. If subsequent updates cause more moves, the padding factor will continue to grow
(although not as dramatically as it did on the first move). If there aren’t more moves,
the padding factor will slowly go down, as shown in Figure 3-3.
Figure 3-1. Initially, documents are inserted with no space between them
Figure 3-2. If a document grows and must be moved, free space is left behind and the
padding size in increased
Updating Documents | 43
C# Image: Document Image Processing SDK Programming in C#.NET
RasterEdge.Imaging.MSWordDocx.dll; RasterEdge.Imaging.PDF.dll; Before you use any programming add-ons from your C#.NET project, usually together with integrated
add pdf pages together; acrobat merge pdf
C# PowerPoint: C# Codes to Combine & Split PowerPoint Documents
or a list of PowerPoint documents together and create a String doc in dirs) { docList.Add(doc); } PPTXDocument & profession imaging controls, PDF document, tiff
c# merge pdf pages; best pdf merger
Figure 3-3. Subsequent documents are inserted with the padding factor in free space be‐
tween them. If moves do not occur on subsequent inserts, this padding factor will
decrease.
Moving documents is slow. MongoDB has to free the space the document was in and
write the document somewhere else. Thus, you should try to keep the padding factor
as close to 1 as possible. You cannot manually set the padding factor (unless you’re
compacting the collection: see “Compacting Data” on page 320), but you can design a
schema that does not depend on documents growing arbitrarily large. See Chapter 8 for
more advice on schema design.
A simple program demonstrates the speed difference between in-place updates and
moves. The program below inserts a single key and increments its value 100,000 times:
> db.tester.insert({"x" : 1})
> var timeInc = function() {
... var start = (new Date()).getTime();
...
... for (var i=0; i<100000; i++) {
...     db.tester.update({}, {"$inc" : {"x" : 1}});
...     db.getLastError();
... }
...
... var timeDiff = (new Date()).getTime() - start;
... print("Updates took: "+timeDiff+"ms");
... }
> timeInc()
On a MacBook Air this took 7.33 seconds. That’s more than 13,000 updates per second.
Now, let’s try it with a document with a single array key, pushing new values onto that
array 100,000 times. Change the update call to this:
...    db.tester.update({}, {"$push" : {"x" : 1}})
This program took 67.58 seconds to run, which is less than 1,500 updates per second.
Using "$push" and other array modifiers is encouraged and often necessary, but it is
good to keep in mind the trade-offs of such updates. If "$push" becomes a bottleneck,
it may be worth pulling an embedded array out into a separate collection, manually
padding, or using one of the other techniques discussed in Chapter 8.
As of this writing, MongoDB is not great at reusing empty space, so moving documents
around a lot can result in large swaths of empty data file. If you have a lot of empty space,
you’ll start seeing messages that look like this in the logs:
Thu Apr  5 01:12:28 [conn124727info DFM::findAll(): extent a:7f18dc00 was 
emptyskipping ahead
44 | Chapter 3: Creating, Updating, and Deleting Documents
That means that, while querying, MongoDB looked through an entire extent (see Ap‐
pendix B for a definition, but it’s basically a subset of your collection) without finding
any documents: it was just empty space. The message itself is harmless, but it indicates
that you have fragmentation and may wish to perform a compact.
If your schema requires lots of moves or lots of churn through inserts and deletes, you
can improve disk reuse by using the usePowerOf2Sizes option. You can set this with
the collMod command:
> db.runCommand({"collMod" : collectionName"usePowerOf2Sizes" : true})
All subsequent allocations made by the collection will be in power-of-two-sized blocks.
Only use this option on high-churn collections, though, as this makes initial space al‐
location less efficient. Setting this on an insert- or in-place-update-only collection will
make writes slower.
Running this command with "usePowerOf2Sizes" : false turns off the special allo‐
cation. The option only affects newly allocated records, so there is no harm in running
it on an existing collection or toggling the value.
Upserts
An upsert is a special type of update. If no document is found that matches the update
criteria, a new document will be created by combining the criteria and updated docu‐
ments. If a matching document is found, it will be updated normally. Upserts can be
handy because they can eliminate the need to “seed” your collection: you can often have
the same code create and update documents.
Let’s go back to our example that records the number of views for each page of a website.
Without an upsert, we might try to find the URL and increment the number of views
or create a new document if the URL doesn’t exist. If we were to write this out as a
JavaScript program it might look something like the following:
// check if we have an entry for this page
blog = db.analytics.findOne({url : "/blog"})
// if we do, add one to the number of views and save
if (blog) {
blog.pageviews++;
db.analytics.save(blog);
}
// otherwise, create a new document for this page
else {
db.analytics.save({url : "/blog"pageviews : 1})
}
This means we are making a round trip to the database, plus sending an update or insert,
every time someone visits a page. If we are running this code in multiple processes, we
Updating Documents | 45
are also subject to a race condition where more than one document can be inserted for
a given URL.
We can eliminate the race condition and cut down on the amount of code by just sending
an upsert (the third parameter to update specifies that this should be an upsert):
db.analytics.update({"url" : "/blog"}, {"$inc" : {"pageviews" : 1}}, true)
This line does exactly what the previous code block does, except it’s faster and atomic!
The new document is created using the criteria document as a base and applying any
modifier documents to it.
For example, if you do an upsert that matches a key and has an increment to the value
of that key, the increment will be applied to the match:
> db.users.update({"rep" : 25}, {"$inc" : {"rep" : 3}}, true)
> db.users.findOne()
{
"_id" : ObjectId("4b3295f26cc613d5ee93018f"),
"rep" : 28
}
The upsert creates a new document with a "rep" of 25 and then increments that by 3,
giving us a document where "rep" is 28. If the upsert option were not specified, {"rep" :
25} would not match any documents, so nothing would happen.
If we run the upsert again (with the criteria {"rep" : 25}), it will create another new
document. This is because the criteria does not match the only document in the col‐
lection. (Its "rep" is 28.)
Sometimes a field needs to be seeded when a document is created, but not changed on
subsequent updates. This is what "$setOnInsert" is for. "$setOnInsert" is a modifier
that only sets the value of a field when the document is being inserted. Thus, we could
do something like this:
> db.users.update({}, {"$setOnInsert" : {"createdAt" : new Date()}}, true)
> db.users.findOne()
{
"_id" : ObjectId("512b8aefae74c67969e404ca"),
"createdAt" : ISODate("2013-02-25T16:01:50.742Z")
}
If we run this update again, it will match the existing document, nothing will be inserted,
and so the "createdAt" field will not be changed:
> db.users.update({}, {"$setOnInsert" : {"createdAt" : new Date()}}, true)
> db.users.findOne()
{
"_id" : ObjectId("512b8aefae74c67969e404ca"),
"createdAt" : ISODate("2013-02-25T16:01:50.742Z")
}
46 | Chapter 3: Creating, Updating, and Deleting Documents
Note that you generally do not need to keep a "createdAt" field, as ObjectIds contain
a timestamp of when the document was created. However, "$setOnInsert" can be
useful for creating padding, initializing counters, and for collections that do not use
ObjectIds.
The save shell helper
save is a shell function that lets you insert a document if it doesn’t exist and update it if
it does. It takes one argument: a document. If the document contains an "_id" key, save
will do an upsert. Otherwise, it will do an insert. save is really just a convenience function
so that programmers can quickly modify documents in the shell:
> var x = db.foo.findOne()
> x.num = 42
42
> db.foo.save(x)
Without save, the last line would have been a more cumbersome db.foo.up
date({"_id" : x._id}, x).
Updating Multiple Documents
Updates, by default, update only the first document found that matches the criteria. If
there are more matching documents, they will remain unchanged. To modify all of the
documents matching the criteria, you can pass true as the fourth parameter to update.
update’s behavior may be changed in the future (the server may update
all matching documents by default and update one only if false is
passed as the fourth parameter), so it is recommended that you always
specify whether you want a multiple update.
Not only is it more obvious what the update should be doing, but your
program also won’t break if the default is ever changed.
Multiupdates are a great way of performing schema migrations or rolling out new fea‐
tures to certain users. Suppose, for example, we want to give a gift to every user who
has a birthday on a certain day. We can use multiupdate to add a "gift" to their account:
> db.users.update({"birthday" : "10/13/1978"},
... {"$set" : {"gift" : "Happy Birthday!"}}, false, true)
This would add the "gift" field to all user documents with birthdays on October 13,
1978.
To see the number of documents updated by a multiupdate, you can run the
getLastError database command (which you can think of as “return information about
Updating Documents | 47
the last operation”). The "n" key will contain the number of documents affected by the
update:
> db.count.update({x : 1}, {$inc : {x : 1}}, falsetrue)
> db.runCommand({getLastError : 1})
{
"err" : null,
"updatedExisting" : true,
"n" : 5,
"ok" : true
}
"n" is 5, meaning that five documents were affected by the update. "updatedExist
ing" is true, meaning that the update modified existing documents.
Returning Updated Documents
You can get some limited information about what was updated by calling
getLastError, but it does not actually return the updated document. For that, you’ll
need the findAndModify command. It is handy for manipulating queues and perform‐
ing other operations that need get-and-set style atomicity.
Suppose we have a collection of processes run in a certain order. Each is represented
with a document that has the following form:
{
"_id" : ObjectId(),
"status" : state,
"priority" : N
}
"status" is a string that can be "READY""RUNNING", or "DONE". We need to find the job
with the highest priority in the "READY" state, run the process function, and then update
the status to "DONE". We might try querying for the ready processes, sorting by priority,
and updating the status of the highest-priority process to mark it is "RUNNING". Once
we have processed it, we update the status to "DONE". This looks something like the
following:
var cursor = db.processes.find({"status" : "READY"});
ps = cursor.sort({"priority" : -1}).limit(1).next();
db.processes.update({"_id" : ps._id}, {"$set" : {"status" : "RUNNING"}});
do_something(ps);
db.processes.update({"_id" : ps._id}, {"$set" : {"status" : "DONE"}});
This algorithm isn’t great because it is subject to a race condition. Suppose we have two
threads running. If one thread (call it A) retrieved the document and another thread
(call it B) retrieved the same document before A had updated its status to "RUNNING",
then both threads would be running the same process. We can avoid this by checking
the status as part of the update query, but this becomes complex:
48 | Chapter 3: Creating, Updating, and Deleting Documents
Documents you may be interested
Documents you may be interested