EventExample


1   /*-
2    * See the file LICENSE for redistribution information.
3    *
4    * Copyright (c) 2004,2006 Oracle.  All rights reserved.
5    *
6    * $Id: EventExample.java,v 1.1 2006/11/02 16:34:58 linda Exp $
7    */
8   
9   package persist;
10  
11  import java.io.File  ;
12  import java.io.Serializable  ;
13  import java.util.Calendar  ;
14  import java.util.Date  ;
15  import java.util.HashSet  ;
16  import java.util.Random  ;
17  import java.util.Set  ;
18  
19  import com.sleepycat.bind.EntryBinding;
20  import com.sleepycat.bind.serial.SerialBinding;
21  import com.sleepycat.bind.serial.StoredClassCatalog;
22  import com.sleepycat.bind.tuple.IntegerBinding;
23  import com.sleepycat.bind.tuple.LongBinding;
24  import com.sleepycat.je.Cursor;
25  import com.sleepycat.je.Database;
26  import com.sleepycat.je.DatabaseConfig;
27  import com.sleepycat.je.DatabaseEntry;
28  import com.sleepycat.je.DatabaseException;
29  import com.sleepycat.je.Environment;
30  import com.sleepycat.je.EnvironmentConfig;
31  import com.sleepycat.je.OperationStatus;
32  import com.sleepycat.je.SecondaryConfig;
33  import com.sleepycat.je.SecondaryCursor;
34  import com.sleepycat.je.SecondaryDatabase;
35  import com.sleepycat.je.SecondaryKeyCreator;
36  import com.sleepycat.je.Transaction;
37  
38  /**
39   * EventExample is a trivial example which stores Java objects that represent
40   * an event. Events are primarily indexed by a timestamp, but have other 
41   * attributes, such as price, account reps, customer name and quantity.
42   * Some of those other attributes are indexed.
43   * <p>
44   * The example simply shows the creation of a JE environment and database,
45   * inserting some events, and retrieving the events.
46   * <p>
47   * This example is meant to be paired with its twin, EventExampleDPL.java. 
48   * EventExample.java and EventExampleDPL.java perform the same functionality,
49   * but use the Base API and the Direct Persistence Layer api, respectively.
50   * This may be a useful way to compare the two apis.
51   * <p>
52   * To run the example:
53   * <pre>
54   * cd jehome/examples
55   * javac je/EventExample.java
56   * java -cp "../lib/je.jar;." je.EventExample -h <environmentDirectory>
57   * </pre>
58   */
59  public class EventExample {
60  
61      /* 
62       * The Event class embodies our example event and is the application
63       * data. JE data records are represented at key/data tuples. In this
64       * example, the key portion of the record is the event time, and the data
65       * portion is the Event instance.
66       */
67      static class Event implements Serializable   {
68  
69          /* This example will add secondary indices on price and accountReps. */
70          private int price;              
71          private Set  <String  > accountReps;
72  
73          private String   customerName;
74          private int quantity;
75  
76          Event(int price,
77                String   customerName) {
78  
79              this.price = price;
80              this.customerName = customerName;
81              this.accountReps = new HashSet  <String  >();
82          }
83  
84          void addRep(String   rep) {
85              accountReps.add(rep);
86          }
87  
88          @Override  
89          public String   toString() {
90              StringBuilder   sb = new StringBuilder  ();
91              sb.append(" price=").append(price);
92              sb.append(" customerName=").append(customerName);
93              sb.append(" reps=");
94              if (accountReps.size() == 0) {
95                  sb.append("none");
96              } else {
97                  for (String   rep: accountReps) {
98                      sb.append(rep).append(" ");
99                  }
100             }
101             return sb.toString();
102         }
103 
104         int getPrice() {
105             return price;
106         }
107     }
108 
109     /* A JE environment is roughly equivalent to a relational database. */
110     private Environment env;
111 
112     /* 
113      * A JE table is roughly equivalent to a relational table with a
114      * primary index.
115      */
116     private Database eventDb;
117 
118     /* A secondary database indexes an additional field of the data record */
119     private SecondaryDatabase eventByPriceDb;
120 
121     /*
122      * The catalogs and bindings are used to convert Java objects to the byte
123      * array format used by JE key/data in the base api. The Direct Persistence
124      * Layer api supports Java objects as arguments directly.
125      */
126     private Database catalogDb;
127     private EntryBinding eventBinding;
128 
129     /* Used for generating example data. */
130     private Calendar   cal; 
131 
132 
133     /*
134      * First manually make a directory to house the JE environment.
135      * Usage: java -cp je.jar EventExample -h <envHome>
136      * All JE on-disk storage is held within envHome.
137      */
138     public static void main(String  [] args)
139         throws DatabaseException {
140 
141         if (args.length != 2 || !"-h".equals(args[0])) {
142             System.err.println
143                 ("Usage: java " + EventExample.class.getName() +
144                  " -h <envHome>");
145             System.exit(2);
146         }
147         EventExample example = new EventExample(new File  (args[1]));
148         example.run();
149         example.close();
150     }
151 
152     private EventExample(File   envHome)
153         throws DatabaseException {
154 
155         /* Open a transactional Berkeley DB engine environment. */
156         System.out.println("-> Creating a JE environment");
157         EnvironmentConfig envConfig = new EnvironmentConfig();
158         envConfig.setAllowCreate(true);
159         envConfig.setTransactional(true);
160         env = new Environment(envHome, envConfig);
161 
162         init();
163         cal = Calendar.getInstance();
164     }
165 
166     /** 
167      * Create all primary and secondary indices.
168      */
169     private void init() 
170         throws DatabaseException {
171 
172         System.out.println("-> Creating a JE database");
173         DatabaseConfig dbConfig = new DatabaseConfig();
174         dbConfig.setTransactional(true); 
175         dbConfig.setAllowCreate(true);
176         eventDb = env.openDatabase(null,      // use auto-commit txn
177                                      "eventDb", // database name
178                                      dbConfig);
179 
180 
181         /* 
182          * In our example, the database record is composed of a key portion
183          * which represents the event timestamp, and a data portion holds an
184          * instance of the Event class.
185          *
186          * JE's base api accepts and returns key and data as byte arrays, so we
187          * need some support for marshaling between objects and byte arrays. We
188          * call this binding, and supply a package of helper classes to support
189          * this. It's entirely possible to do all binding on your own.
190          *
191          * A class catalog database is needed for storing class descriptions
192          * for the serial binding used below. This avoids storing class
193          * descriptions redundantly in each record.
194          */
195         DatabaseConfig catalogConfig = new DatabaseConfig();
196         catalogConfig.setTransactional(true); 
197         catalogConfig.setAllowCreate(true);
198         catalogDb = env.openDatabase(null, "catalogDb", catalogConfig);
199         StoredClassCatalog catalog = new StoredClassCatalog(catalogDb);
200 
201         /* 
202          * Create a serial binding for Event data objects.  Serial
203          * bindings can be used to store any Serializable object.
204          * We can use some pre-defined binding classes to convert 
205          * primitives like the long key value to the a byte array.
206          */
207         eventBinding = new SerialBinding(catalog, Event.class);
208 
209         /*
210          * Open a secondary database to allow accessing the primary
211          * database a secondary key value. In this case, access events
212          * by price.
213          */
214         SecondaryConfig secConfig = new SecondaryConfig();
215         secConfig.setTransactional(true); 
216         secConfig.setAllowCreate(true);
217         secConfig.setSortedDuplicates(true);
218         secConfig.setKeyCreator(new PriceKeyCreator(eventBinding));
219         eventByPriceDb = env.openSecondaryDatabase(null,
220                                                    "priceDb",
221                                                    eventDb,
222                                                    secConfig);
223 
224     }
225 
226     private void run()
227         throws DatabaseException {
228 
229         Random   rand = new Random  ();
230 
231         /* DatabaseEntry represents the key and data of each record */
232         DatabaseEntry key = new DatabaseEntry();
233         DatabaseEntry data = new DatabaseEntry();
234 
235         /* 
236          * Create a set of events. Each insertion is a separate, auto-commit
237          * transaction.
238          */
239         System.out.println("-> Inserting 4 events");
240         LongBinding.longToEntry(makeDate(1), key);
241         eventBinding.objectToEntry(new Event(100, "Company_A"),
242                                    data);
243         eventDb.put(null, key, data);
244 
245         LongBinding.longToEntry(makeDate(2), key);
246         eventBinding.objectToEntry(new Event(2, "Company_B"),
247                                    data);
248         eventDb.put(null, key, data);
249 
250         LongBinding.longToEntry(makeDate(3), key);
251         eventBinding.objectToEntry(new Event(20, "Company_C"),
252                                    data);
253         eventDb.put(null, key, data);
254 
255         LongBinding.longToEntry(makeDate(4), key);
256         eventBinding.objectToEntry(new Event(40, "CompanyD"),
257                                    data);
258         eventDb.put(null, key, data);
259 
260         /* Load a whole set of events transactionally. */
261         Transaction txn = env.beginTransaction(null, null);
262         int maxPrice = 50;
263         System.out.println("-> Inserting some randomly generated events");
264         for (int i = 0; i < 25; i++) {
265             long time = makeDate(rand.nextInt(365));
266             Event e = new Event(rand.nextInt(maxPrice),"Company_X");
267             if ((i%2) ==0) {
268                 e.addRep("Jane");
269                 e.addRep("Nikunj");
270             } else {
271                 e.addRep("Yongmin");
272             }
273             LongBinding.longToEntry(time, key);
274             eventBinding.objectToEntry(e, data);
275             eventDb.put(txn, key, data);
276         }
277         txn.commitWriteNoSync();
278 
279         /* 
280          * Windows of events - display the events between June 1 and Aug 31
281          */
282         System.out.println("\n-> Display the events between June 1 and Aug 31");
283         long startDate = makeDate(Calendar.JUNE, 31);
284         long endDate = makeDate(Calendar.AUGUST, 31);
285 
286         /* Position the cursor and print the first event. */
287         Cursor eventWindow = eventDb.openCursor(null, null);
288         LongBinding.longToEntry(makeDate(Calendar.JUNE, 1), key);
289 
290         if ((eventWindow.getSearchKeyRange(key,  data, null)) !=
291             OperationStatus.SUCCESS) {
292             System.out.println("No events found!");
293             eventWindow.close();
294             return;
295         }     
296         try {
297             printEvents(key, data, eventWindow, endDate);
298         } finally {
299             eventWindow.close();
300         }
301         
302         /*
303          * Display all events, ordered by a secondary index on price.
304          */
305         System.out.println("\n-> Display all events, ordered by price");
306         SecondaryCursor priceCursor =
307             eventByPriceDb.openSecondaryCursor(null, null);
308         try {
309             printEvents(priceCursor);
310         } finally {
311             priceCursor.close();
312         }
313     }
314 
315     private void close()
316         throws DatabaseException {
317 
318         eventByPriceDb.close();
319         eventDb.close();
320         catalogDb.close();
321         env.close();
322     }
323     
324     /**
325      * Print all events covered by this cursor up to the end date.  We know
326      * that the cursor operates on long keys and Event data items, but there's
327      * no type-safe way of expressing that within the JE base api.
328      */
329     private void printEvents(DatabaseEntry firstKey,
330                              DatabaseEntry firstData,
331                              Cursor cursor, 
332                              long endDate) 
333         throws DatabaseException {
334         
335         System.out.println("time=" +
336                            new Date  (LongBinding.entryToLong(firstKey)) +
337                            eventBinding.entryToObject(firstData));
338         DatabaseEntry key = new DatabaseEntry();
339         DatabaseEntry data = new DatabaseEntry();
340 
341         while (cursor.getNext(key, data, null) ==
342                OperationStatus.SUCCESS) {
343             if (LongBinding.entryToLong(key) > endDate) {
344                 break;
345             }
346             System.out.println("time=" +
347                                new Date  (LongBinding.entryToLong(key)) +
348                                eventBinding.entryToObject(data));
349         }
350     }
351 
352     private void printEvents(SecondaryCursor cursor) 
353         throws DatabaseException {
354         DatabaseEntry timeKey = new DatabaseEntry();
355         DatabaseEntry priceKey = new DatabaseEntry();
356         DatabaseEntry eventData = new DatabaseEntry();
357 
358         while (cursor.getNext(priceKey, timeKey, eventData, null) ==
359                OperationStatus.SUCCESS) {
360             System.out.println("time=" +
361                                new Date  (LongBinding.entryToLong(timeKey)) +
362                                eventBinding.entryToObject(eventData));
363         }
364     }
365 
366     /**
367      * Little utility for making up java.util.Dates for different days, just
368      * to generate test data. 
369      */
370     private long makeDate(int day) {
371 
372         cal.set((Calendar.DAY_OF_YEAR), day);
373         return cal.getTime().getTime();
374     }
375     /**
376      * Little utility for making up java.util.Dates for different days, just
377      * to make the test data easier to read.
378      */
379     private long makeDate(int month, int day) {
380 
381         cal.set((Calendar.MONTH), month);
382         cal.set((Calendar.DAY_OF_MONTH), day);
383         return cal.getTime().getTime();
384     }
385 
386     /**
387      * A key creator that knows how to extract the secondary key from the data
388      * entry of the primary database.  To do so, it uses both the dataBinding
389      * of the primary database and the secKeyBinding.
390      */
391     private static class PriceKeyCreator implements SecondaryKeyCreator {
392 
393         private EntryBinding dataBinding;
394 
395         PriceKeyCreator(EntryBinding eventBinding) {
396             this.dataBinding = eventBinding;
397         }
398 
399         public boolean createSecondaryKey(SecondaryDatabase secondaryDb,
400                                           DatabaseEntry keyEntry,
401                                           DatabaseEntry dataEntry,
402                                           DatabaseEntry resultEntry)
403             throws DatabaseException {
404 
405             /*
406              * Convert the data entry to an Event object, extract the secondary
407              * key value from it, and then convert it to the resulting
408              * secondary key entry.
409              */
410             Event e  = (Event) dataBinding.entryToObject(dataEntry);
411             int price = e.getPrice();
412             IntegerBinding.intToEntry(price, resultEntry);
413             return true;
414         }
415     }
416 }
417
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags