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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
|
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Cursor Example</title>
<link rel="stylesheet" href="gettingStarted.css" type="text/css" />
<meta name="generator" content="DocBook XSL Stylesheets V1.73.2" />
<link rel="start" href="index.html" title="Getting Started with Berkeley DB" />
<link rel="up" href="Cursors.html" title="Chapter 9. Using Cursors" />
<link rel="prev" href="ReplacingEntryWCursor.html" title="Replacing Records Using Cursors" />
<link rel="next" href="indexes.html" title="Chapter 10. Secondary Databases" />
</head>
<body>
<div xmlns="" class="navheader">
<div class="libver">
<p>Library Version 12.1.6.1</p>
</div>
<table width="100%" summary="Navigation header">
<tr>
<th colspan="3" align="center">Cursor Example</th>
</tr>
<tr>
<td width="20%" align="left"><a accesskey="p" href="ReplacingEntryWCursor.html">Prev</a> </td>
<th width="60%" align="center">Chapter 9. Using Cursors</th>
<td width="20%" align="right"> <a accesskey="n" href="indexes.html">Next</a></td>
</tr>
</table>
<hr />
</div>
<div class="sect1" lang="en" xml:lang="en">
<div class="titlepage">
<div>
<div>
<h2 class="title" style="clear: both"><a id="cursorJavaUsage"></a>Cursor Example</h2>
</div>
</div>
</div>
<p>In <a class="xref" href="dbtJavaUsage.html" title="Database Usage Example">Database Usage Example</a> we wrote an
application that loaded two <code class="classname">Database</code> objects with vendor
and inventory information. In this example, we will use those databases to
display all of the items in the inventory database. As a part of showing
any given inventory item, we will look up the vendor who can provide the
item and show the vendor's contact information.</p>
<p>To do this, we create the <code class="classname">ExampleDatabaseRead</code>
application. This application reads and displays all inventory records by:</p>
<div class="orderedlist">
<ol type="1">
<li>
<p>Opening the inventory, vendor, and
class catalog <code class="classname">Database</code> objects. We do this using the
<code class="classname">MyDbs</code> class. See <a class="xref" href="dbtJavaUsage.html#dbsStoredClass" title="Example 8.4 Stored Class Catalog Management with MyDbs">Stored Class Catalog Management with MyDbs</a>
for a description of this class.</p>
</li>
<li>
<p>Obtaining a cursor from the inventory <code class="classname">Database</code>.</p>
</li>
<li>
<p>Steps through the <code class="classname">Database</code>, displaying
each record as it goes.</p>
</li>
<li>
<p>To display the Inventory record, the custom tuple binding that
we created in <a class="xref" href="dbtJavaUsage.html#InventoryJavaBinding" title="Example 8.3 InventoryBinding.java">InventoryBinding.java</a> is used.</p>
</li>
<li>
<p><code class="methodname">Database.get()</code> is used to obtain the vendor that corresponds to
the inventory item.</p>
</li>
<li>
<p>A serial binding is used to convert the
<code class="classname">DatabaseEntry</code> returned
by the <code class="methodname">get()</code> to a Vendor object.</p>
</li>
<li>
<p>The contents of the Vendor object are displayed.</p>
</li>
</ol>
</div>
<p>We implemented the <code class="classname">Vendor</code> class in <a class="xref" href="dbtJavaUsage.html#vendorjava" title="Example 8.2 Vendor.java">Vendor.java</a>. We implemented the
<code class="classname">Inventory</code> class in <a class="xref" href="dbtJavaUsage.html#inventoryjava" title="Example 8.1 Inventory.java">Inventory.java</a>.</p>
<p>The full implementation of <code class="classname">ExampleDatabaseRead</code>
can be found in:
</p>
<pre class="programlisting"><span class="emphasis"><em>DB_INSTALL</em></span>/examples/java/db/GettingStarted</pre>
<p>
where <code class="literal"><span class="emphasis"><em>DB_INSTALL</em></span></code> is the location where you
placed your DB distribution.
</p>
<div class="example">
<a id="EDR"></a>
<p class="title">
<b>Example 9.1 ExampleDatabaseRead.java</b>
</p>
<div class="example-contents">
<p>To begin, we import the necessary classes:</p>
<a id="java_cursor10"></a>
<pre class="programlisting">// file ExampleDatabaseRead.java
package db.GettingStarted;
import java.io.File;
import java.io.IOException;
import com.sleepycat.bind.EntryBinding;
import com.sleepycat.bind.serial.SerialBinding;
import com.sleepycat.bind.tuple.TupleBinding;
import com.sleepycat.db.Cursor;
import com.sleepycat.db.DatabaseEntry;
import com.sleepycat.db.DatabaseException;
import com.sleepycat.db.LockMode;
import com.sleepycat.db.OperationStatus;</pre>
<p>Next we declare our class and set up some global variables. Note a
<code class="classname">MyDbs</code> object is instantiated here. We can do
this because its constructor never throws an exception. See <a class="xref" href="CoreJavaUsage.html" title="Database Example">Database Example</a> for its implementation
details.</p>
<a id="java_cursor11"></a>
<pre class="programlisting">public class ExampleDatabaseRead {
private static String myDbsPath = "./";
// Encapsulates the database environment and databases.
private static MyDbs myDbs = new MyDbs();
private static TupleBinding inventoryBinding;
private static EntryBinding vendorBinding; </pre>
<p>
Next we create the <code class="methodname">ExampleDatabaseRead.usage()</code> and
<code class="methodname">ExampleDatabaseRead.main()</code> methods.
We perform almost all of our exception handling from <code class="methodname">ExampleDatabaseRead.main()</code>, and so we
must catch <code class="classname">DatabaseException</code> because the <code class="literal">com.sleepycat.db.*</code>
APIs throw them.
</p>
<a id="java_cursor12"></a>
<pre class="programlisting"> private static void usage() {
System.out.println("ExampleDatabaseRead [-h <env directory>]" +
"[-s <item to locate>]");
System.exit(-1);
}
public static void main(String args[]) {
ExampleDatabaseRead edr = new ExampleDatabaseRead();
try {
edr.run(args);
} catch (DatabaseException dbe) {
System.err.println("ExampleDatabaseRead: " + dbe.toString());
dbe.printStackTrace();
} finally {
myDbs.close();
}
System.out.println("All done.");
}</pre>
<p>In <code class="methodname">ExampleDatabaseRead.run()</code>, we call <code class="methodname">MyDbs.setup()</code> to
open our databases. Then we create the bindings that we need for using our data objects with
<code class="classname">DatabaseEntry</code> objects.
</p>
<a id="java_cursor13"></a>
<pre class="programlisting"> private void run(String args[])
throws DatabaseException {
// Parse the arguments list
parseArgs(args);
myDbs.setup(myDbsPath);
// Setup our bindings.
inventoryBinding = new InventoryBinding();
vendorBinding =
new SerialBinding(myDbs.getClassCatalog(),
Vendor.class);
showAllInventory();
}</pre>
<p>Now we write the loop that displays the <code class="classname">Inventory</code>
records. We do this by opening a cursor on the inventory database and
iterating over all its contents, displaying each as we go.</p>
<a id="java_cursor14"></a>
<pre class="programlisting"> private void showAllInventory()
throws DatabaseException {
// Get a cursor
Cursor cursor = myDbs.getInventoryDB().openCursor(null, null);
// DatabaseEntry objects used for reading records
DatabaseEntry foundKey = new DatabaseEntry();
DatabaseEntry foundData = new DatabaseEntry();
try { // always want to make sure the cursor gets closed
while (cursor.getNext(foundKey, foundData,
LockMode.DEFAULT) == OperationStatus.SUCCESS) {
Inventory theInventory =
(Inventory)inventoryBinding.entryToObject(foundData);
displayInventoryRecord(foundKey, theInventory);
}
} catch (Exception e) {
System.err.println("Error on inventory cursor:");
System.err.println(e.toString());
e.printStackTrace();
} finally {
cursor.close();
}
} </pre>
<p>We use <code class="methodname">ExampleDatabaseRead.displayInventoryRecord()</code>
to actually show the record. This
method first displays all the relevant information from the retrieved
Inventory object. It then uses the vendor database to retrieve and
display the vendor. Because the vendor database is keyed by vendor name,
and because each inventory object contains this key, it is trivial to
retrieve the appropriate vendor record.</p>
<a id="java_cursor15"></a>
<pre class="programlisting"> private void displayInventoryRecord(DatabaseEntry theKey,
Inventory theInventory)
throws DatabaseException {
String theSKU = null;
try {
theSKU = new String(theKey.getData(), "UTF-8");
} catch(java.io.UnsupportedEncodingException e) {
/* Handle the exception here. */
}
System.out.println(theSKU + ":");
System.out.println("\t " + theInventory.getItemName());
System.out.println("\t " + theInventory.getCategory());
System.out.println("\t " + theInventory.getVendor());
System.out.println("\t\tNumber in stock: " +
theInventory.getVendorInventory());
System.out.println("\t\tPrice per unit: " +
theInventory.getVendorPrice());
System.out.println("\t\tContact: ");
DatabaseEntry searchKey = null;
try {
searchKey =
new DatabaseEntry(theInventory.getVendor().getBytes("UTF-8"));
} catch (IOException willNeverOccur) {}
DatabaseEntry foundVendor = new DatabaseEntry();
if (myDbs.getVendorDB().get(null, searchKey, foundVendor,
LockMode.DEFAULT) != OperationStatus.SUCCESS) {
System.out.println("Could not find vendor: " +
theInventory.getVendor() + ".");
System.exit(-1);
} else {
Vendor theVendor =
(Vendor)vendorBinding.entryToObject(foundVendor);
System.out.println("\t\t " + theVendor.getAddress());
System.out.println("\t\t " + theVendor.getCity() + ", " +
theVendor.getState() + " " + theVendor.getZipcode());
System.out.println("\t\t Business Phone: " +
theVendor.getBusinessPhoneNumber());
System.out.println("\t\t Sales Rep: " +
theVendor.getRepName());
System.out.println("\t\t " +
theVendor.getRepPhoneNumber());
}
}</pre>
<p>The remainder of this application provides a utility method used
to parse the command line options. From the perspective of this
document, this is relatively uninteresting. You can see how this is
implemented by looking at:
</p>
<pre class="programlisting"><span class="emphasis"><em>DB_INSTALL</em></span>/examples/java/db/GettingStarted</pre>
<p>
where <code class="literal"><span class="emphasis"><em>DB_INSTALL</em></span></code> is the location where you
placed your DB distribution.
</p>
</div>
</div>
<br class="example-break" />
</div>
<div class="navfooter">
<hr />
<table width="100%" summary="Navigation footer">
<tr>
<td width="40%" align="left"><a accesskey="p" href="ReplacingEntryWCursor.html">Prev</a> </td>
<td width="20%" align="center">
<a accesskey="u" href="Cursors.html">Up</a>
</td>
<td width="40%" align="right"> <a accesskey="n" href="indexes.html">Next</a></td>
</tr>
<tr>
<td width="40%" align="left" valign="top">Replacing Records Using Cursors </td>
<td width="20%" align="center">
<a accesskey="h" href="index.html">Home</a>
</td>
<td width="40%" align="right" valign="top"> Chapter 10. Secondary Databases</td>
</tr>
</table>
</div>
</body>
</html>
|
