asp.net mvc pdf viewer control : Reader merge pdf application Library tool html asp.net winforms online mongodb_%20the%20definitive%20guide%20-%20kristina%20chodorow_14019-part1794

sort takes an object: a set of key/value pairs where the keys are key names and the values
are the sort directions. Sort direction can be 1 (ascending) or −1 (descending). If multiple
keys are given, the results will be sorted in that order. For instance, to sort the results
by "username" ascending and "age" descending, we do the following:
> db.c.find().sort({username : 1age : -1})
These three methods can be combined. This is often handy for pagination. For example,
suppose that you are running an online store and someone searches for mp3. If you
want 50 results per page sorted by price from high to low, you can do the following:
> db.stock.find({"desc" : "mp3"}).limit(50).sort({"price" : -1})
If that person clicks Next Page to see more results, you can simply add a skip to the
query, which will skip over the first 50 matches (which the user already saw on page 1):
> db.stock.find({"desc" : "mp3"}).limit(50).skip(50).sort({"price" : -1})
However, large skips are not very performant; there are suggestions for how to avoid
them in the next section.
Comparison order
MongoDB has a hierarchy as to how types compare. Sometimes you will have a single
key with multiple types: for instance, integers and booleans, or strings and nulls. If you
do a sort on a key with a mix of types, there is a predefined order that they will be sorted
in. From least to greatest value, this ordering is as follows:
1. Minimum value
2. null
3. Numbers (integers, longs, doubles)
4. Strings
5. Object/document
6. Array
7. Binary data
8. Object ID
9. Boolean
10. Date
11. Timestamp
12. Regular expression
13. Maximum value
Cursors | 69
Reader merge pdf - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
add pdf pages together; break pdf file into multiple files
Reader merge pdf - 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
batch pdf merger online; c# merge pdf files into one
Avoiding Large Skips
Using skip for a small number of documents is fine. For a large number of results, skip
can be slow, since it has to find and then discard all the skipped results. Most databases
keep more metadata in the index to help with skips, but MongoDB does not yet support
this, so large skips should be avoided. Often you can calculate the next query based on
the result from the previous one.
Paginating results without skip
The easiest way to do pagination is to return the first page of results using limit and
then return each subsequent page as an offset from the beginning:
> // do not use: slow for large skips
> var page1 = db.foo.find(criteria).limit(100)
> var page2 = db.foo.find(criteria).skip(100).limit(100)
> var page3 = db.foo.find(criteria).skip(200).limit(100)
...
However, depending on your query, you can usually find a way to paginate without
skips. For example, suppose we want to display documents in descending order based
on "date". We can get the first page of results with the following:
> var page1 = db.foo.find().sort({"date" : -1}).limit(100)
Then, we can use the "date" value of the last document as the criteria for fetching the
next page:
var latest = null;
// display first page
while (page1.hasNext()) {
latest = page1.next();
display(latest);
}
// get next page
var page2 = db.foo.find({"date" : {"$gt" : latest.date}});
page2.sort({"date" : -1}).limit(100);
Now the query does not need to include a skip.
Finding a random document
One fairly common problem is how to get a random document from a collection. The
naive (and slow) solution is to count the number of documents and then do a find,
skipping a random number of documents between 0 and the size of the collection:
> // do not use
> var total = db.foo.count()
> var random = Math.floor(Math.random()*total)
> db.foo.find().skip(random).limit(1)
70 | Chapter 4: Querying
XImage.Barcode Scanner for .NET, Read, Scan and Recognize barcode
VB.NET File: Merge PDF; VB.NET File: Split PDF; VB.NET VB.NET Annotate: PDF Markup & Drawing. XDoc.Word for C#; C#; XImage.OCR for C#; XImage.Barcode Reader for C#
asp.net merge pdf files; acrobat merge pdf files
C# Imaging - Scan Barcode Image in C#.NET
RasterEdge Barcode Reader DLL add-in enables developers to add barcode image recognition & barcode types, such as Code 128, EAN-13, QR Code, PDF-417, etc.
best pdf merger; combine pdfs online
It is actually highly inefficient to get a random element this way: you have to do a count
(which can be expensive if you are using criteria), and skipping large numbers of ele‐
ments can be time-consuming.
It takes a little forethought, but if you know you’ll be looking up a random element on
a collection, there’s a much more efficient way to do so. The trick is to add an extra
random key to each document when it is inserted. For instance, if we’re using the shell,
we could use the Math.random() function (which creates a random number between 0
and 1):
> db.people.insert({"name" : "joe""random" : Math.random()})
> db.people.insert({"name" : "john""random" : Math.random()})
> db.people.insert({"name" : "jim""random" : Math.random()})
Now, when we want to find a random document from the collection, we can calculate
a random number and use that as query criteria, instead of doing a skip:
> var random = Math.random()
> result = db.foo.findOne({"random" : {"$gt" : random}})
There is a slight chance that random will be greater than any of the "random" values in
the collection, and no results will be returned. We can guard against this by simply
returning a document in the other direction:
> if (result == null) {
...     result = db.foo.findOne({"random" : {"$lt" : random}})
... }
If there aren’t any documents in the collection, this technique will end up returning
null, which makes sense.
This technique can be used with arbitrarily complex queries; just make sure to have an
index that includes the random key. For example, if we want to find a random plumber
in California, we can create an index on "profession", "state", and "random":
> db.people.ensureIndex({"profession" : 1"state" : 1"random" : 1})
This allows us to quickly find a random result (see Chapter 5 for more information on
indexing).
Advanced Query Options
There are two types of queries: wrapped and plain. A plain query is something like this:
> var cursor = db.foo.find({"foo" : "bar"})
There are a couple options that “wrap” the query. For example, suppose we perform a
sort:
> var cursor = db.foo.find({"foo" : "bar"}).sort({"x" : 1})
Cursors | 71
C# PDF: PDF Document Viewer & Reader SDK for Windows Forms
On this page, besides brief introduction to RasterEdge C#.NET PDF document viewer & reader for Windows Forms application, you can also see the following aspects
add pdf together one file; reader combine pdf pages
.NET PDF Document Viewing, Annotation, Conversion & Processing
File & Page Process. Create new file, load PDF from existing files. Merge, split PDF files. Insert, delete PDF pages. Re-order, rotate PDF pages. PDF Read.
pdf mail merge plug in; merge pdf online
Instead of sending {"foo" : "bar"} to the database as the query, the query gets wrapped
in a larger document. The shell converts the query from {"foo" : "bar"} to
{"$query" : {"foo" : "bar"}, "$orderby" : {"x" : 1}}.
Most drivers provide helpers for adding arbitrary options to queries. Other helpful
options include the following:
$maxscan : integer
Specify the maximum number of documents that should be scanned for the query.
> db.foo.find(criteria)._addSpecial("$maxscan"20)
This can be useful if you want a query to not to take too long but are not sure how
much of a collection will need to be scanned. This will limit your results to whatever
was found in the part of the collection that was scanned (i.e., you may miss other
documents that match).
$min : document
Start criteria for querying. document must exactly match the keys of an index used
for the query. This forces the given index to be used for the query.
This is used internally and you should generally use "$gt" instead of "$min". You
can use "$min" to force the lower bound on an index scan, which may be helpful
for complex queries.
$max : document
End criteria for querying. document must exactly match the keys of an index used
for the query. This forces the given index to be used for the query.
If this is used internally, you should generally use "$lt" instead of "$max". You can
use "$max" to force bounds on an index scan, which may be helpful for complex
queries.
$showDiskLoc : true
Adds a "$diskLoc" field to the results that shows where on disk that particular result
lives. For example:
> db.foo.find()._addSpecial('$showDiskLoc',true)
"_id" : 0"$diskLoc" : { "file" : 2"offset" : 154812592 } }
"_id" : 1"$diskLoc" : { "file" : 2"offset" : 154812628 } }
The file number shows which file the document is in. In this case, if we’re using the
test database, the document is in test.2. The second field gives the byte offset of each
document within the file.
Getting Consistent Results
A fairly common way of processing data is to pull it out of MongoDB, change it in some
way, and then save it again:
72 | Chapter 4: Querying
C# PDF insert image Library: insert images into PDF in C#.net, ASP
inserting image to PDF in preview without adobe PDF reader installed. Able to zoom and crop image and achieve image resizing. Merge several images into PDF.
add multiple pdf files into one online; split pdf into multiple files
XDoc, XImage SDK for .NET - View, Annotate, Convert, Edit, Scan
Adobe PDF. XDoc PDF. Scanning. XImage OCR. Microsoft Office. XDoc Word. XDoc Excel. XDoc PowerPoint. Barcoding. XImage Barcode Reader. XImage Barcode Generator.
how to combine pdf files; batch merge pdf
cursor = db.foo.find();
while (cursor.hasNext()) {
var doc = cursor.next();
doc = process(doc);
db.foo.save(doc);
}
This is fine for a small number of results, but MongoDB can return the same result
multiple times for a large result set. To see why, imagine how the documents are being
stored. You can picture a collection as a list of documents that looks something like
Figure 4-1. Snowflakes represent documents, since every document is beautiful and
unique.
Figure 4-1. A collection being queried
Now, when we do a find, the cursor starts returning results from the beginning of the
collection and moves right. Your program grabs the first 100 documents and processes
them. When you save them back to the database, if a document does not have the
padding available to grow to its new size, like in Figure 4-2, it needs to be relocated.
Usually, a document will be relocated to the end of a collection (Figure 4-3).
Figure 4-2. An enlarged document may not fit where it did before
Cursors | 73
C# PDF: How to Create PDF Document Viewer in C#.NET with
The PDF document viewer & reader created by this C#.NET imaging toolkit can be used by developers for reliably & quickly PDF document viewing, PDF annotation
add two pdf files together; pdf merger online
C# WPF PDF Viewer SDK to view, annotate, convert and print PDF in
VB.NET File: Merge PDF; VB.NET File: Split PDF; VB.NET VB.NET Annotate: PDF Markup & Drawing. XDoc.Word for C#; C#; XImage.OCR for C#; XImage.Barcode Reader for C#
pdf combine files online; combine pdf files
Figure 4-3. MongoDB relocates updated documents that don’t fit in their original
position
Now our program continues to fetch batches of documents. When it gets toward the
end, it will return the relocated documents again (Figure 4-4)!
Figure 4-4. A cursor may return these relocated documents again in a later batch
The solution to this problem is to snapshot your query. If you add the option, the query
will be run by traversing the "_id" index, which guarantees that you’ll only return each
document once. For example, instead of db.foo.find(), you’d run:
> db.foo.find().snapshot()
Snapshotting makes queries slower, so only use snapshotted queries when necessary.
For example, mongodump (a backup utility covered in Chapter 22) uses snapshotted
queries by default.
All queries that return a single batch of results are effectively snapshotted. Inconsis‐
tencies arise only when the collection changes under a cursor while it is waiting to get
another batch of results.
74 | Chapter 4: Querying
Immortal Cursors
There are two sides to a cursor: the client-facing cursor and the database cursor that the
client-side one represents. We have been talking about the client-side one up until now,
but we are going to take a brief look at what’s happening on the server.
On the server side, a cursor takes up memory and resources. Once a cursor runs out of
results or the client sends a message telling it to die, the database can free the resources
it was using. Freeing these resources lets the database use them for other things, which
is good, so we want to make sure that cursors can be freed quickly (within reason).
There are a couple of conditions that can cause the death (and subsequent cleanup) of
a cursor. First, when a cursor finishes iterating through the matching results, it will clean
itself up. Another way is that, when a cursor goes out of scope on the client side, the
drivers send the database a special message to let it know that it can kill that cursor.
Finally, even if the user hasn’t iterated through all the results and the cursor is still in
scope, after 10 minutes of inactivity, a database cursor will automatically “die.” This way,
if a client crashes or is buggy, MongoDB will not be left with thousands of open cursors.
This “death by timeout” is usually the desired behavior: very few applications expect
their users to sit around for minutes at a time waiting for results. However, sometimes
you might know that you need a cursor to last for a long time. In that case, many drivers
have implemented a function called immortal, or a similar mechanism, which tells the
database not to time out the cursor. If you turn off a cursor’s timeout, you must iterate
through all of its results or kill it to make sure it gets closed. Otherwise, it will sit around
in the database hogging resources until the server is restarted.
Database Commands
There is one very special type of query called a database command. We’ve covered
creating, updating, deleting, and finding documents. Database commands do “every‐
thing else,” from administrative tasks like shutting down the server and cloning data‐
bases to counting documents in a collection and performing aggregations.
Commands are mentioned throughout this text, as they are useful for data manipula‐
tion, administration, and monitoring. For example, dropping a collection is done via
the "drop" database command:
> db.runCommand({"drop" : "test"});
{
"nIndexesWas" : 1,
"msg" : "indexes dropped for collection",
"ns" : "test.test",
"ok" : true
}
Database Commands | 75
You might be more familiar with the shell helper, which wraps the command and pro‐
vides a simpler interface:
> db.test.drop()
Often you can just use the shell helpers, but knowing the underlying commands can be
helpful if you’re stuck on a box with an old version of the shell and connected to a new
version of the database: the shell might not have the wrappers for new database com‐
mands, but you can still run them with runCommand().
We’ve already seen a couple of commands in the previous chapters; for instance, we
used the getLastError command in Chapter 3 to check the number of documents
affected by an update:
> db.count.update({x : 1}, {$inc : {x : 1}}, falsetrue)
> db.runCommand({getLastError : 1})
{
"err" : null,
"updatedExisting" : true,
"n" : 5,
"ok" : true
}
In this section, we’ll take a closer look at commands to see exactly what they are and
how they’re implemented. We’ll also describe some of the most useful commands that
are supported by MongoDB. You can see all commands by running the db.listCom
mands() command.
How Commands Work
A database command always returns a document containing the key "ok". If "ok" is 1,
the command was successful; and if it is 0, the command failed for some reason.
If "ok" is 0 then an additional key will be present, "errmsg". The value of "errmsg" is
a string explaining why the command failed. As an example, let’s try running the drop
command again, on the collection that was dropped in the previous section:
> db.runCommand({"drop" : "test"});
"errmsg" : "ns not found", "ok" : false }
Commands in MongoDB are implemented as a special type of query that gets performed
on the $cmd collection. runCommand just takes a command document and performs the
equivalent query, so our drop call becomes the following:
db.$cmd.findOne({"drop" : "test"});
When the MongoDB server gets a query on the $cmd collection, it handles it using
special logic, rather than the normal code for handling queries. Almost all MongoDB
drivers provide a helper method like runCommand for running commands, but com‐
mands can always be run using a simple query.
76 | Chapter 4: Querying
Some commands require administrator access and must be run on the admin database.
If such a command is run on any other database, it will return an "access denied"
error. If you’re working on another database and you need to run an admin command,
you can use the adminCommand function, instead of runCommand:
> use temp
switched to db temp
> db.runCommand({shutdown:1})
"errmsg" : "access denied; use admin db", "ok" : 0 }
> db.adminCommand({"shutdown" : 1})
Commands are one of the few places that are field-order-sensitive: the command name
must always be the first field in the command. Thus, {"getLastError" : 1, "w" :
2} will work, but {"w" : 2, "getLastError" : 1} will not.
Database Commands | 77
Documents you may be interested
Documents you may be interested