c# web api pdf : Excel pdf bookmarks application Library cloud windows asp.net html class BerkeleyDB-JE-GSG4-part701

Library Version 12.1.6.0
Direct Persistence Layer First Steps
12/7/2015
Getting Started with JE
Page 32
Usually all of the activity surrounding saving and retrieving data is organized within a class
or classes specialized to that purpose. We describe the construction of these data accessor
classes in SimpleDA.class (page 39). But before you perform any entity store activity, you
need to understand indexes. We therefore describe them in the next chapter.
Excel pdf bookmarks - 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
adding bookmarks to pdf reader; pdf reader with bookmarks
Excel pdf bookmarks - 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
add bookmarks to pdf reader; edit pdf bookmarks
12/7/2015
Getting Started with JE
Page 33
Chapter 4. Working with Indices
All entity classes stored in JE using the DPL must have a primary index, or key, identified for
them. All such classes may also have one or more secondary keys declared for them. This
chapter describes primary and secondary indexes in detail, and shows how to access the
indexes created for a given entity class.
One way to organize access to your primary and secondary indexes is to create a data accessor
class. We show an implementation of a data accessor class in SimpleDA.class (page 39).
Accessing Indexes
In order to retrieve any object from an entity store, you must access at least the primary
index for that object. Different entity classes stored in an entity store can have different
primary indexes, but all entity classes must have a primary index declared for it. The primary
index is just the default index used for the class. (That is, it is the data's primary key for the
underlying database.)
Entity classes can optionally have secondary indexes declared for them. In order to access
these secondary indexes, you must first access the primary index.
Accessing Primary Indices
You retrieve a primary index using the EntityStore.getPrimaryIndex() method. To do this,
you indicate the index key type (that is, whether it is a String, Integer, and so forth) and the
class of the entities stored in the index.
For example, the following retrieves the primary index for an Inventory class (we provide
an implementation of this class in Inventory.java (page 54)). These index keys are of type
String.
PrimaryIndex<String,Inventory> inventoryBySku = 
store.getPrimaryIndex(String.class, Inventory.class); 
Accessing Secondary Indices
You retrieve a secondary index using the EntityStore.getSecondaryIndex() method.
Because secondary indices actually refer to a primary index somewhere in your data store, to
access a secondary index you:
1. Provide the primary index as returned by EntityStore.getPrimaryIndex().
2. Identify the key data type used by the secondary index (String, Long, and so forth).
3. Identify the name of the secondary key field. When you declare the SecondaryIndex
object, you identify the entity class to which the secondary index must refer.
For example, the following first retrieves the primary index, and then uses that to retrieve a
secondary index. The secondary key is held by the itemName field of the Inventory class.
PrimaryIndex<String,Inventory> inventoryBySku = 
store.getPrimaryIndex(String.class, Inventory.class); 
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
document file. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. Also a preview
how to add a bookmark in pdf; add bookmarks to pdf file
C# PDF File Split Library: Split, seperate PDF into multiple files
Split PDF file by top level bookmarks. The following C# codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
auto bookmark pdf; how to create bookmark in pdf with
Library Version 12.1.6.0
Working with Indices
12/7/2015
Getting Started with JE
Page 34
SecondaryIndex<String,String,Inventory> inventoryByName = 
store.getSecondaryIndex(inventoryBySku, String.class, "itemName"); 
Creating Indexes
To create an index using the DPL, you use Java annotations to declare which feature on the
class is used for the primary index, and which features (if any) are to be used as secondary
indexes.
All entity classes stored in the DPL must have a primary index declared for it.
Entity classes can have zero or more secondary indexes declared for them. There is no limit on
the number of secondary indexes that you can declare.
Declaring a Primary Indexes
You declare a primary key for an entity class by using the @PrimaryKey annotation. This
annotation must appear immediately before the data member which represents the class's
primary key. For example:
package persist.gettingStarted;
import com.sleepycat.persist.model.Entity;
import com.sleepycat.persist.model.PrimaryKey;
@Entity
public class Vendor {
private String address;
private String bizPhoneNumber;
private String city;
private String repName;
private String repPhoneNumber;
private String state;
// Primary key is the vendor's name
// This assumes that the vendor's name is
// unique in the database.
@PrimaryKey
private String vendor;
... 
For this class, the vendor value is set for an individual Vendor class object by the
setVendorName() method. If our example code fails to set this value before storing the
object, the data member used to store the primary key is set to a null value. This would result
in a runtime error.
You can avoid the need to explicitly set a value for a class's primary index by specifying a
sequence to be used for the primary key. This results in an unique integer value being used as
the primary key for each stored object.
VB.NET PDF File Split Library: Split, seperate PDF into multiple
Demo Code in VB.NET. The following VB.NET codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
display bookmarks in pdf; pdf bookmarks
C# PDF File Compress Library: Compress reduce PDF size in C#.net
NET framework. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. C# class demo
excel hyperlink to pdf bookmark; create pdf with bookmarks from word
Library Version 12.1.6.0
Working with Indices
12/7/2015
Getting Started with JE
Page 35
You declare a sequence is to be used by specifying the sequence keyword to the @PrimaryKey
annotation. You must also provide a name for the sequence. For example: For example:
@PrimaryKey(sequence="Sequence_Namespace")
long myPrimaryKey; 
Declaring Secondary Indexes
To declare a secondary index, we use the @SecondaryKey annotation. Note that when we do
this, we must declare what sort of an index it is; that is, what is its relationship to other data
in the data store.
The kind of indices that we can declare are:
• ONE_TO_ONE
This relationship indicates that the secondary key is unique to the object. If an object is
stored with a secondary key that already exists in the data store, a run time error is raised.
For example, a person object might be stored with a primary key of a social security
number (in the US), with a secondary key of the person's employee number. Both values are
expected to be unique in the data store.
• MANY_TO_ONE
Indicates that the secondary key may be used for multiple objects in the data store. That is,
the key appears more than once, but for each stored object it can be used only once.
Consider a data store that relates managers to employees. A given manager will have
multiple employees, but each employee is assumed to have just one manager. In this case,
the manager's employee number might be a secondary key, so that you can quickly locate all
the objects related to that manager's employees.
• ONE_TO_MANY
Indicates that the secondary key might be used more than once for a given object. Index
keys themselves are assumed to be unique, but multiple instances of the index can be used
per object.
For example, employees might have multiple unique email addresses. In this case, any given
object can be access by one or more email addresses. Each such address is unique in the
data store, but each such address will relate to a single employee object.
• MANY_TO_MANY
There can be multiple keys for any given object, and for any given key there can be many
related objects.
For example, suppose your organization has a shared resource, such as printers. You might
want to track which printers a given employee can use (there might be more than one).
You might also want to track which employees can use a specific printer. This represents a
many-to-many relationship.
XDoc.Excel for .NET, Comprehensive .NET Excel Imaging Features
zooming & rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Excel Convert. Convert Excel to PDF; Convert Excel
how to bookmark a page in pdf document; how to add bookmarks on pdf
.NET PDF SDK - Description of All PDF Processing Control Feastures
bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Conversion. PDF Create. Create PDF from Word (docx, doc); Create PDF from Excel
how to add bookmarks to a pdf; creating bookmarks in a pdf document
Library Version 12.1.6.0
Working with Indices
12/7/2015
Getting Started with JE
Page 36
Note that for ONE_TO_ONE and MANY_TO_ONE relationships, you need a simple data
member (not an array or collection) to hold the key. For ONE_TO_MANY and MANY_TO_MANY
relationships, you need an array or collection to hold the keys:
@SecondaryKey(relate=ONE_TO_ONE)
private String primaryEmailAddress = new String();
@SecondaryKey(relate=ONE_TO_MANY)
private Set<String> emailAddresses = new HashSet<String>(); 
Foreign Key Constraints
Sometimes a secondary index is related in some way to another entity class that is also
contained in the data store. That is, the secondary key might be the primary key for another
entity class. If this is the case, you can declare the foreign key constraint to make data
integrity easier to accomplish.
For example, you might have one class that is used to represent employees. You might have
another that is used to represent corporate divisions. When you add or modify an employee
record, you might want to ensure that the division to which the employee belongs is known to
the data store. You do this by specifying a foreign key constraint.
When a foreign key constraint is declared:
• When a new secondary key for the object is stored, it is checked to make sure it exists as a
primary key for the related entity object. If it does not, a runtime error occurs.
• When a related entity is deleted (that is, a corporate division is removed from the data
store), some action is automatically taken for the entities that refer to this object (that is,
the employee objects). Exactly what that action is, is definable by you. See below.
When a related entity is deleted from the data store, one of the following actions are taken:
• ABORT
The delete operation is not allowed. A runtime error is raised as a result of the operation.
This is the default behavior.
• CASCADE
All entities related to this one are deleted as well. For example, if you deleted a Division
object, then all Employee objects that belonged to the division are also deleted.
• NULLIFY
All entities related to the deleted entity are updated so that the pertinent data member
is nullified. That is, if you deleted a division, then all employee objects related to that
division would have their division key automatically set to null.
You declare a foreign key constraint by using the relatedEntity keyword. You declare
the foreign key constraint deletion policy using the onRelatedEntityDelete keyword. For
XDoc.Word for .NET, Advanced .NET Word Processing Features
& rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Conversion. Word Create. Create Word from PDF; Create Word
add bookmark to pdf reader; bookmarks pdf reader
XDoc.PowerPoint for .NET, All Mature Features Introductions
& rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. PowerPoint Convert. Convert PowerPoint to PDF; Convert
create bookmark pdf file; export bookmarks from pdf to excel
Library Version 12.1.6.0
Working with Indices
12/7/2015
Getting Started with JE
Page 37
example, the following declares a foreign key constraint to Division class objects, and it
causes related objects to be deleted if the Division class is deleted:
@SecondaryKey(relate=ONE_TO_ONE, relatedEntity=Division.class, 
onRelatedEntityDelete=CASCADE)
private String division = new String(); 
12/7/2015
Getting Started with JE
Page 38
Chapter 5. Saving and Retrieving Objects
To store an object in an EntityStore you must annotate the class appropriately and then
store it using PrimaryIndex.put().
To retrieve and object from an EntityStore you use the get() method from either the
PrimaryIndex or SecondaryIndex, whichever is most appropriate for your application.
In both cases, it simplifies things greatly if you create a data accessor class to organize your
indexes.
In the next few sections we:
1. Create an entity class that is ready to be stored in an entity store. This class will have
both a primary index (required) declared for it, as well as a secondary index (which is
optional).
See the next section for this implementation.
2. Create a data accessor class which is used to organize our data.
See SimpleDA.class (page 39) for this implementation.
3. Create a simple class that is used to put objects to our entity store.
See Placing Objects in an Entity Store (page 40) for this implementation.
4. Create another class that retrieves objects from our entity store.
See Retrieving Objects from an Entity Store (page 42) for this implementation.
A Simple Entity Class
For clarity's sake, this entity class is a simple a class as we can write. It contains only two data
members, both of which are set and retrieved by simple setter and getter methods. Beyond
that, by design this class does not do anything or particular interest.
Its implementation is as follows:
package persist.gettingStarted;
import com.sleepycat.persist.model.Entity;
import com.sleepycat.persist.model.PrimaryKey;
import static com.sleepycat.persist.model.Relationship.*;
import com.sleepycat.persist.model.SecondaryKey;
@Entity
public class SimpleEntityClass {
// Primary key is pKey
@PrimaryKey
private String pKey;
Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 39
// Secondary key is the sKey
@SecondaryKey(relate=MANY_TO_ONE)
private String sKey;
public void setPKey(String data) {
pKey = data;
}
public void setSKey(String data) {
sKey = data;
}
public String getPKey() {
return pKey;
}
public String getSKey() {
return sKey;
}
SimpleDA.class
As mentioned above, we organize our primary and secondary indexes using a specialize data
accessor class. The main reason for this class to exist is to provide convenient access to all the
indexes in use for our entity class (see the previous section, A Simple Entity Class (page 38),
for that implementation).
For a description on retrieving primary and secondary indexes under the DPL, see Working
with Indices (page 33)
package persist.gettingStarted;
import java.io.File;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.persist.EntityStore;
import com.sleepycat.persist.PrimaryIndex;
import com.sleepycat.persist.SecondaryIndex;
public class SimpleDA {
// Open the indices
public SimpleDA(EntityStore store)
throws DatabaseException {
// Primary key for SimpleEntityClass classes
pIdx = store.getPrimaryIndex(
String.class, SimpleEntityClass.class);
// Secondary key for SimpleEntityClass classes
Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 40
// Last field in the getSecondaryIndex() method must be
// the name of a class member; in this case, an 
// SimpleEntityClass.class data member.
sIdx = store.getSecondaryIndex(
pIdx, String.class, "sKey");
}
// Index Accessors
PrimaryIndex<String,SimpleEntityClass> pIdx;
SecondaryIndex<String,String,SimpleEntityClass> sIdx;
Placing Objects in an Entity Store
In order to place an object in a DPL entity store, you must:
1. Open the environment and store.
2. Instantiate the object.
3. Put the object to the store using the put() method for the object's primary index.
The following example uses the SimpleDA class that we show in SimpleDA.class (page 39) to
put a SimpleEntityClass object (see A Simple Entity Class (page 38)) to the entity store.
To begin, we import the Java classes that our example needs. We also instantiate the private
data members that we require.
package persist.gettingStarted;
import java.io.File;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import com.sleepycat.persist.EntityStore;
import com.sleepycat.persist.StoreConfig; 
public class SimpleStorePut {
private static File envHome = new File("./JEDB");
private Environment envmnt;
private EntityStore store;
private SimpleDA sda; 
Next we create a method that simply opens our database environment and entity store for us.
// The setup() method opens the environment and store
// for us.
public void setup()
throws DatabaseException {
Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 41
EnvironmentConfig envConfig = new EnvironmentConfig();
StoreConfig storeConfig = new StoreConfig();
envConfig.setAllowCreate(true);
storeConfig.setAllowCreate(true);
// Open the environment and entity store
envmnt = new Environment(envHome, envConfig);
store = new EntityStore(envmnt, "EntityStore", storeConfig);
We also need a method to close our environment and store.
// Close our environment and store.
public void shutdown()
throws DatabaseException {
store.close();
envmnt.close();
Now we need to create a method to actually write objects to our store. This method creates a
SimpleDA object (see SimpleDA.class (page 39) that we will use to access our indexes. Then
we instantiate a series of SimpleEntityClass (see A Simple Entity Class (page 38)) objects
that we will place in our store. Finally, we use our primary index (obtained from the SimpleDA
class instance) to actually place these objects in our store.
In Retrieving Objects from an Entity Store (page 42) we show a class that is used to retrieve
these objects.
// Populate the entity store
private void run()
throws DatabaseException {
setup();
// Open the data accessor. This is used to store
// persistent objects.
sda = new SimpleDA(store);
// Instantiate and store some entity classes
SimpleEntityClass sec1 = new SimpleEntityClass();
SimpleEntityClass sec2 = new SimpleEntityClass();
SimpleEntityClass sec3 = new SimpleEntityClass();
SimpleEntityClass sec4 = new SimpleEntityClass();
SimpleEntityClass sec5 = new SimpleEntityClass();
sec1.setPKey("keyone");
sec1.setSKey("skeyone");
sec2.setPKey("keytwo");
Documents you may be interested
Documents you may be interested