c# web api pdf : Bookmark pdf in preview Library SDK class asp.net wpf azure ajax BerkeleyDB-JE-GSG2-part699

Library Version
Introduction to Berkeley DB Java Edition
Getting Started with JE
Page 12
For information on how to use the jconsole plugin see:
Bookmark pdf in preview - add, remove, update PDF bookmarks in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your C# Project with Rapid PDF Internal Navigation Via Bookmark and Outline
copy pdf bookmarks to another pdf; how to bookmark a pdf in reader
Bookmark pdf in preview - VB.NET PDF bookmark library: add, remove, update PDF bookmarks in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your VB.NET Project with Rapid PDF Internal Navigation Via Bookmark and Outline
edit pdf bookmarks; bookmarks in pdf files
Library Version
Introduction to Berkeley DB Java Edition
Getting Started with JE
Page 13
Getting and Using JE
You can obtain JE by visiting the JE download page: http://www.oracle.com/technetwork/
To install JE, simple untar or unzip the distribution to the directory of your choice. If you use
unzip, make sure to specify the -U option in order to preserve case.
For more information on installing JE, see JE_HOME/docs/relnotes.html, where JE_HOME is
the directory where you unpacked JE.
JE is compatible with Java SE 7 and later, and has been tested and certified
against Oracle Java SE 7, IBM Java SE Version 7 and IBM J9 on the AIX platform. It is
recommended that you upgrade to the latest Java releases to take advantage of the
latest bug fixes and performance improvements. The release notes included in the JE
download specify the exact Java versions that have been used for certification.
You can use JE with your application by adding JE_HOME/lib/je-<version>.jar to your
application's classpath.
Beyond this manual, you can find documentation for JE at JE_HOME/docs/index.html
directory. In particular, complete Javadoc for the JE API set is available at JE_HOME/docs/
JE Exceptions
Before describing the Java API usage, it is first useful to examine the exceptions thrown by
those APIs. So, briefly, this section describes the exceptions that you can expect to encounter
when writing JE applications.
All of the JE APIs throw DatabaseException. DatabaseException extends
java.lang.Exception. Also, the following classes are subclasses of DatabaseException:
• DatabaseNotFoundException
Thrown whenever an operation requires a database, and that database cannot be found.
• LockConflictException
The common base class for all exceptions that result from record lock conflicts. Upon
receiving this exception, any open cursors must be closed, the enclosing transaction aborted
and, optionally, the transaction retried. Transactions are described in the Berkeley DB, Java
Edition Getting Started with Transaction Processing guide.
• RunRecoveryException
Thrown whenever JE experiences a catastrophic error such that recovery needs to be run
on the database. If you receive this exception, you must reopen your environment so as to
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. Also a preview component enables compressing and
create bookmarks in pdf reader; creating bookmarks in pdf files
How to C#: Preview Document Content Using XDoc.Word
How to C#: Preview Document Content Using XDoc.Word. Get Preview From File. You may get document preview image from an existing Word file in C#.net.
how to bookmark a pdf file; add bookmarks to pdf preview
Library Version
Introduction to Berkeley DB Java Edition
Getting Started with JE
Page 14
allow normal recovery to run. See Databases and Log Files (page 151) for more information
on how normal recovery works.
Note that when reopening your environment, you should stop all database read and write
activities, close all your cursors, close all your databases, and then close and reopen your
Note that DatabaseException and its subclasses belong to the com.sleepycat.je package.
Six Things Everyone Should Know about JE Log Files
JE log files are not like the log files of other database systems. Nor are they like the log files
or database files created by Berkeley DB C Edition. In this guide you will learn more about log
files as you go along, but it is good to keep the following points in mind as you begin using JE.
1. JE log files are "append only". Record insertions, deletions, and updates are always added
at the end of the current file. The first file is named 00000000.jdb. When that file grows
to a certain size (10 MB by default) a new file named 00000001.jdb becomes the current
file, and so on.
2. There are no separate database files. Unlike Berkeley DB C Edition, databases are not
stored in files that are separate from the transaction log. The transaction log and the
database records are stored together in a single sequential log consisting of multiple log
3. The JE cleaner is responsible for reclaiming unused disk space. When the records in a log
file are superseded by deletions or updates recorded in a later log file, the older log file
is no longer fully utilized. The cleaner, which operates by default as a separate thread,
determines the least utilized log files, copies any still utilized records in those files to the
end of the current log file, and finally deletes the now completely un-utilized log file.
See The Cleaner Thread (page 159) for more information on the cleaner.
4. Cleaning does not start immediately and never produces 100% utilization. Until you
have written enough data to create several log files, and some of that data is obsoleted
through deletions and updates, you will not notice any log files being deleted by the
cleaner. By default cleaning occurs in the background and maintains the log files at
50% utilization. You can configure a higher utilization value, but configuring too high a
utilization value will reduce overall performance.
5. Cleaning is not automatically performed when closing the environment. If you wish to
reduce unused disk space to a minimum at a particular point in time, you must explicitly
call a method to perform log cleaning. See the Closing Database Environments (page
19) for more information.
6. Log file deletion only occurs after a checkpoint. The cleaner prepares log files to be
deleted, but file deletion must be performed after a checkpoint to ensure that the files
are no longer referenced. Checkpoints occur on their own schedule, which is every 20 MB
of log written, by default. This is part of the reason that you will not see log files being
deleted until after several files have been created.
How to C#: Preview Document Content Using XDoc.PowerPoint
How to C#: Preview Document Content Using XDoc.PowerPoint. Get Preview From File. You may get document preview image from an existing PowerPoint file in C#.net.
how to add bookmarks to a pdf; creating bookmarks in pdf from word
C# WinForms Viewer: Load, View, Convert, Annotate and Edit PDF
It makes users easy to view PDF document and edit PDF document in preview. PDF Annotation. • Add sticky notes to PDF document in preview.
pdf bookmarks; bookmark pdf in preview
Library Version
Introduction to Berkeley DB Java Edition
Getting Started with JE
Page 15
7. Log files can be spread across multiple directories, and therefore across multiple disks
through the use of links or mount points. See Multiple Environment Subdirectories (page
18) for more information.
VB.NET PDF File Split Library: Split, seperate PDF into multiple
Split PDF document by PDF bookmark and outlines in VB.NET. Independent component for splitting PDF document in preview without using external PDF control.
bookmark template pdf; adding bookmarks to pdf reader
VB.NET PDF insert image library: insert images into PDF in vb.net
NET. An independent .NET framework component supports inserting image to PDF in preview without adobe PDF control installed. Access
how to bookmark a pdf page; add bookmark pdf file
Getting Started with JE
Page 16
Chapter 2. Database Environments
Regardless of whether you are using the DPL or the base API, you must use a database
environment. Database environments encapsulate one or more databases. This encapsulation
provides your threads with efficient access to your databases by allowing a single in-memory
cache to be used for each of the databases contained in the environment. This encapsulation
also allows you to group operations performed against multiple databases inside a single
transaction (see the Berkeley DB, Java Edition Getting Started with Transaction Processing
guide for more information).
If you are using the base API, most commonly you use database environments to create and
open databases (you close individual databases using the individual database handles). You
can also use environments to delete and rename databases. For transactional applications,
you use the environment to start transactions. For non-transactional applications, you use the
environment to sync your in-memory cache to disk.
If you are using the DPL, all of these things are still being done, but the DPL takes care of it
for you. Under the DPL, the most common thing you will explicitly use an environment for is
to obtain transaction handles.
Regardless of the API that you use, you also use the database environment for administrative
and configuration activities related to your database log files and the in-memory cache. See
Administering Berkeley DB Java Edition Applications (page 158) for more information.
To find out how to use environments with a transaction-protected application, see the
Berkeley DB, Java Edition Getting Started with Transaction Processing guide.
Opening Database Environments
You open a database environment by instantiating an Environment object. You must provide
to the constructor the name of the on-disk directory where the environment is to reside. This
directory location must exist or the open will fail.
By default, the environment is not created for you if it does not exist. Set the creation
property to true if you want the environment to be created. For example:
package je.gettingStarted;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import java.io.File;
// Open the environment. Allow it to be created if it does not 
// already exist.
Environment myDbEnvironment = null;
C# PDF File Split Library: Split, seperate PDF into multiple files
Split PDF document by PDF bookmark and outlines. Advanced component for splitting PDF document in preview without any third-party plug-ins installed.
export pdf bookmarks to text file; how to add bookmarks on pdf
C# PDF insert text Library: insert text into PDF content in C#.net
Supports adding text to PDF in preview without adobe reader installed in ASP.NET. Powerful .NET PDF edit control allows modify existing scanned PDF text.
export pdf bookmarks to excel; bookmark a pdf file
Library Version
Database Environments
Getting Started with JE
Page 17
try {
EnvironmentConfig envConfig = new EnvironmentConfig();
myDbEnvironment = new Environment(new File("/export/dbEnv"), 
} catch (DatabaseException dbe) {
// Exception handling goes here
Opening an environment usually causes some background threads to be started. JE uses these
threads for log file cleaning and some administrative tasks. However, these threads will only
be opened once per process, so if you open the same environment more than once from within
the same process, there is no performance impact on your application. Also, if you open the
environment as read-only, then the background threads (with the exception of the evictor
thread) are not started.
Note that opening your environment causes normal recovery to be run. This causes your
databases to be brought into a consistent state relative to the changed data found in your log
files. See Databases and Log Files (page 151) for more information.
Multiple Environments
Most JE applications only need a single database environment because any number of
databases can be created in a single environment, and the total size of the data in
an environment is not limited. That said, your application can open and use as many
environments as you have disk and memory to manage. Also, you can instantiate multiple
Environment objects for the same physical environment.
The main reason for multiple environments is that an application must manage multiple
unique data sets. By placing each data set in a separate environment, the application can gain
real advantages in manageability of the data, and with application performance. By placing
each data set in a unique environment, a separate set of log files is created and maintained
in a separate directory, and so you can manipulate the log files for each data set separately.
That is, you can:
• Backup, restore or delete a single data set separately by copying or removing the files for
its environment.
• Balance the load between machines by moving the files for a single data set from one
machine to another.
• Improve I/O performance by placing each data set on a separate physical disk.
• Delete individual data sets very efficiently by removing the environment's log files. This is
much more efficient than deleting individual database records and is also move efficient
than removing databases, and so can be a real benefit if you are managing large temporary
data sets that must be frequently deleted.
Be aware that there is a downside to using multiple environments. In particular, understand
that a single transaction cannot include changes made in more than one environment. If
VB.NET PDF url edit library: insert, remove PDF links in vb.net
Link access to variety of objects, including website, image, document, bookmark, PDF page number, flash, etc. Edit PDF url in preview without adobe PDF
pdf create bookmarks; how to create bookmark in pdf automatically
VB.NET PDF remove image library: remove, delete images from PDF in
pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET search text in PDF, C#.NET edit PDF bookmark, C#.NET Remove PDF image in preview without adobe
how to bookmark a pdf in reader; creating bookmarks in pdf documents
Library Version
Database Environments
Getting Started with JE
Page 18
you need to perform a set of operations in more than one data set atomically (with a single
transaction), use a single environment and distinguish the data sets using some other method.
For example, an application running a hosted service for multiple clients may wish to keep
each client's data set separate. You can do this with multiple environments, but then you can
operate on all data sets atomically. If you need to wrap operations for multiple data sets in a
single transaction, consider some other approach to keeping the data sets separate.
You can, for example, distinguish each data set using a unique key range within a single
database. Or you can create a secondary key that identifies the data set. Or you could use
separate databases for each dataset. All of these approaches allow you to maintain multiple
distinct dataset within a single environment, but each obviously adds a level of complexity to
your code over what is required to simply use a unique environment for each data set.
Multiple Environment Subdirectories
You can spread your JE environment across multiple subdirectories. This allows you to improve
data throughput by spreading disk I/O across multiple disks or filesystems. Environment
subdirectories reside in the environment home directory and are named data001/ through
dataNNN/, consecutively, where NNN is the number of subdirectories that you want to use.
Typically, each of the dataNNN/ names are symbolic links to actual directories which reside
on separate file systems or disks. Alternatively, each subdirectory can be mount points for
filesystems which reside on different disk drives.
You control the number of subdirectories you want to use with the
je.log.nDataDirectories property in the je.properties file. This value must be set prior
to opening the environment, and the subdirectories must already exist at that time. The
value set for this property can not change over the course of the environment's lifetime, or an
exception is thrown when you attempt to open the environment.
The default value for je.log.nDataDirectories is 0, and this means no subdirectories are in
use for the environment. A value greater than 0 indicates the number of subdirectories to use,
and that number of subdirectories must exist prior to opening the environment.
For example, if you set je.log.nDataDirectories to 3, then the first time you open the
environment (and for every environment open after that) your environment home directory
must contain three subdirectories named data001, data002 and data003. This causes your
JE log files (the *.jdb files) to be spread evenly across those three subdirectories. Finally, if
you change the value of je.log.nDataDirectories without first completely deleting your
environment, then your application will throw exceptions when you open your environment.
Configuring a Shared Cache for Multiple Environments
By default, each distinct JE environment has a separate, private in-memory cache. If a
single JVM process will keep open multiple environments at the same time, it is strongly
recommended that all such environments are configured to use a shared cache. A shared
cache makes much more efficient use of memory than separate private caches.
For example, imagine that you open 5 environments in a single process and a total of 500 MB
of memory is available for caching. Using private caches, you could configure each cache to
Library Version
Database Environments
Getting Started with JE
Page 19
be 100 MB. If one of the environments has a larger active data set than the others, it will not
be able to take advantage of unused memory in the other environment caches. By using a
shared cache, multiple open environments will make better use of memory because the cache
LRU algorithm is applied across all information in all enviornments sharing the cache.
In order to configure an environment to use a shared cache, set
EnvironmentConfig.setSharedCache() to true. This must be set for every environment in
the process that you want to use the shared cache. For example:
package je.gettingStarted;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import java.io.File;
// Open the environment. Allow it to be created if it does not 
// already exist.
Environment myEnv1 = null;
Environment myEnv2 = null;
try {
EnvironmentConfig envConfig = new EnvironmentConfig();
myEnv1 = new Environment(new File("/export/dbEnv1"), envConfig);
myEnv2 = new Environment(new File("/export/dbEnv2"), envConfig);
} catch (DatabaseException dbe) {
// Exception handling goes here
Closing Database Environments
You close your environment by calling the Environment.close() method. This method
performs a checkpoint, so it is not necessary to perform a sync or a checkpoint explicitly
before calling it. For information on checkpoints, see the Berkeley DB, Java Edition
Getting Started with Transaction Processing guide. For information on syncs, see Database
Modifications and Syncs (page 152).
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
try {
Library Version
Database Environments
Getting Started with JE
Page 20
if (myDbEnvironment != null) {
} catch (DatabaseException dbe) {
// Exception handling goes here
If you are using the DPL, then close your environment(s) only after all other store activities
have completed and you have closed any stores currently opened in the environment. If you
are using the base API, then close your environment(s) only after all other database activities
have completed and you have closed any databases currently opened in the environment.
It is possible for the environment to close before JE's cleaner thread has finished its
work. This happens if you perform a large number of deletes immediately before
shutting down your environment. The result is that your log files may be quit a lot
larger than you expect them to be because the cleaner thread has not had a chance to
finish its work.
See The Cleaner Thread (page 159) for details on the cleaner threads.
If you want to make sure that the cleaner has finished running before the environment
is closed, call Environment.cleanLog() before calling Environment.close():
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
try {
if (myDbEnvironment != null) {
myDbEnvironment.cleanLog(); // Clean the log before closing
} catch (DatabaseException dbe) {
// Exception handling goes here
Closing the last environment handle in your application causes all internal data structures to
be released and the background threads to be stopped. If there are any opened databases,
then JE will complain before closing them as well. At this time, and any on-going transactions
are aborted. Also at this time any open cursors are also closed. However, it is recommended
that you always close all cursor handles immediately after their use to ensure concurrency and
to release resources such as page locks.
Environment Properties
You set properties for the Environment using the EnvironmentConfig class. You can also set
properties for a specific Environment instance using EnvironmentMutableConfig.
Library Version
Database Environments
Getting Started with JE
Page 21
The EnvironmentConfig Class
The EnvironmentConfig class makes a large number of fields and methods available to you.
Describing all of these tuning parameters is beyond the scope of this manual. However, there
are a few properties that you are likely to want to set. They are described here.
Note that for each of the properties that you can commonly set, there is a corresponding
getter method. Also, you can always retrieve the EnvironmentConfig object used by your
environment using the Environment.getConfig() method.
You set environment configuration parameters using the following methods on the
EnvironmentConfig class:
• EnvironmentConfig.setAllowCreate()
If true, the database environment is created when it is opened. If false, environment
open fails if the environment does not exist. This property has no meaning if the database
environment already exists. Default is false.
• EnvironmentConfig.setReadOnly()
If true, then all databases opened in this environment must be opened as read-only. If you
are writing a multi-process application, then all but one of your processes must set this
value to true. Default is false.
You can also set this property using the je.env.isReadOnly parameter in your env_home/
je.properties file.
If true, configures the database environment to support transactions. Default is false.
You can also set this property using the je.env.isTransactional parameter in your
env_home/je.properties file.
For example:
package je.gettingStarted;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import java.io.File;
Environment myDatabaseEnvironment = null;
try {
EnvironmentConfig envConfig = new EnvironmentConfig();
Documents you may be interested
Documents you may be interested