1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
// file MyDbEnv.java
// $Id: MyDbEnv.java,v 1.8 2007/11/12 18:29:42 cwl Exp $
package je.gettingStarted;
import java.io.File;
import com.sleepycat.bind.serial.StoredClassCatalog;
import com.sleepycat.bind.tuple.TupleBinding;
import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import com.sleepycat.je.SecondaryConfig;
import com.sleepycat.je.SecondaryDatabase;
public class MyDbEnv {
private Environment myEnv;
// The databases that our application uses
private Database vendorDb;
private Database inventoryDb;
private Database classCatalogDb;
private SecondaryDatabase itemNameIndexDb;
// Needed for object serialization
private StoredClassCatalog classCatalog;
// Our constructor does nothing
public MyDbEnv() {}
// The setup() method opens all our databases and the environment
// for us.
public void setup(File envHome, boolean readOnly)
throws DatabaseException {
EnvironmentConfig myEnvConfig = new EnvironmentConfig();
DatabaseConfig myDbConfig = new DatabaseConfig();
SecondaryConfig mySecConfig = new SecondaryConfig();
// If the environment is read-only, then
// make the databases read-only too.
myEnvConfig.setReadOnly(readOnly);
myDbConfig.setReadOnly(readOnly);
mySecConfig.setReadOnly(readOnly);
// If the environment is opened for write, then we want to be
// able to create the environment and databases if
// they do not exist.
myEnvConfig.setAllowCreate(!readOnly);
myDbConfig.setAllowCreate(!readOnly);
mySecConfig.setAllowCreate(!readOnly);
// Allow transactions if we are writing to the database
myEnvConfig.setTransactional(!readOnly);
myDbConfig.setTransactional(!readOnly);
mySecConfig.setTransactional(!readOnly);
// Open the environment
myEnv = new Environment(envHome, myEnvConfig);
// Now open, or create and open, our databases
// Open the vendors and inventory databases
vendorDb = myEnv.openDatabase(null,
"VendorDB",
myDbConfig);
inventoryDb = myEnv.openDatabase(null,
"InventoryDB",
myDbConfig);
// Open the class catalog db. This is used to
// optimize class serialization.
classCatalogDb =
myEnv.openDatabase(null,
"ClassCatalogDB",
myDbConfig);
// Create our class catalog
classCatalog = new StoredClassCatalog(classCatalogDb);
// Need a tuple binding for the Inventory class.
// We use the InventoryBinding class
// that we implemented for this purpose.
TupleBinding inventoryBinding = new InventoryBinding();
// Open the secondary database. We use this to create a
// secondary index for the inventory database
// We want to maintain an index for the inventory entries based
// on the item name. So, instantiate the appropriate key creator
// and open a secondary database.
ItemNameKeyCreator keyCreator =
new ItemNameKeyCreator(inventoryBinding);
// Set up additional secondary properties
// Need to allow duplicates for our secondary database
mySecConfig.setSortedDuplicates(true);
mySecConfig.setAllowPopulate(true); // Allow autopopulate
mySecConfig.setKeyCreator(keyCreator);
// Now open it
itemNameIndexDb =
myEnv.openSecondaryDatabase(
null,
"itemNameIndex", // index name
inventoryDb, // the primary db that we're indexing
mySecConfig); // the secondary config
}
// getter methods
// Needed for things like beginning transactions
public Environment getEnv() {
return myEnv;
}
public Database getVendorDB() {
return vendorDb;
}
public Database getInventoryDB() {
return inventoryDb;
}
public SecondaryDatabase getNameIndexDB() {
return itemNameIndexDb;
}
public StoredClassCatalog getClassCatalog() {
return classCatalog;
}
//Close the environment
public void close() {
if (myEnv != null) {
try {
//Close the secondary before closing the primaries
itemNameIndexDb.close();
vendorDb.close();
inventoryDb.close();
classCatalogDb.close();
// Finally, close the environment.
myEnv.close();
} catch(DatabaseException dbe) {
System.err.println("Error closing MyDbEnv: " +
dbe.toString());
System.exit(-1);
}
}
}
}
|
