1/*-
2 * See the file LICENSE for redistribution information.
3 *
4 * Copyright (c) 2002,2008 Oracle.  All rights reserved.
5 *
6 * $Id: Sample.java,v 12.8 2008/02/07 17:12:22 mark Exp $
7 */
8
9package collections.ship.index;
10
11import java.io.FileNotFoundException;
12import java.util.Iterator;
13import java.util.Map;
14
15import com.sleepycat.collections.TransactionRunner;
16import com.sleepycat.collections.TransactionWorker;
17import com.sleepycat.db.DatabaseException;
18
19/**
20 * Sample is the main entry point for the sample program and may be run as
21 * follows:
22 *
23 * <pre>
24 * java collections.ship.index.Sample
25 *      [-h <home-directory> ]
26 * </pre>
27 *
28 * <p> The default for the home directory is ./tmp -- the tmp subdirectory of
29 * the current directory where the sample is run. The home directory must exist
30 * before running the sample.  To recreate the sample database from scratch,
31 * delete all files in the home directory before running the sample.  </p>
32 *
33 * @author Mark Hayes
34 */
35public class Sample {
36
37    private SampleDatabase db;
38    private SampleViews views;
39
40    /**
41     * Run the sample program.
42     */
43    public static void main(String[] args) {
44
45        System.out.println("\nRunning sample: " + Sample.class);
46
47        // Parse the command line arguments.
48        //
49        String homeDir = "./tmp";
50        for (int i = 0; i < args.length; i += 1) {
51            if (args[i].equals("-h") && i < args.length - 1) {
52                i += 1;
53                homeDir = args[i];
54            } else {
55                System.err.println("Usage:\n java " + Sample.class.getName() +
56				   "\n  [-h <home-directory>]");
57                System.exit(2);
58            }
59        }
60
61        // Run the sample.
62        //
63        Sample sample = null;
64        try {
65            sample = new Sample(homeDir);
66            sample.run();
67        } catch (Exception e) {
68            // If an exception reaches this point, the last transaction did not
69            // complete.  If the exception is RunRecoveryException, follow
70            // the Berkeley DB recovery procedures before running again.
71            e.printStackTrace();
72        } finally {
73            if (sample != null) {
74                try {
75                    // Always attempt to close the database cleanly.
76                    sample.close();
77                } catch (Exception e) {
78                    System.err.println("Exception during database close:");
79                    e.printStackTrace();
80                }
81            }
82        }
83    }
84
85    /**
86     * Open the database and views.
87     */
88    private Sample(String homeDir)
89        throws DatabaseException, FileNotFoundException {
90
91        db = new SampleDatabase(homeDir);
92        views = new SampleViews(db);
93    }
94
95    /**
96     * Close the database cleanly.
97     */
98    private void close()
99        throws DatabaseException {
100
101        db.close();
102    }
103
104    /**
105     * Run two transactions to populate and print the database.  A
106     * TransactionRunner is used to ensure consistent handling of transactions,
107     * including deadlock retries.  But the best transaction handling mechanism
108     * to use depends on the application.
109     */
110    private void run()
111        throws Exception {
112
113        TransactionRunner runner = new TransactionRunner(db.getEnvironment());
114        runner.run(new PopulateDatabase());
115        runner.run(new PrintDatabase());
116    }
117
118    /**
119     * Populate the database in a single transaction.
120     */
121    private class PopulateDatabase implements TransactionWorker {
122
123        public void doWork()
124            throws Exception {
125            addSuppliers();
126            addParts();
127            addShipments();
128        }
129    }
130
131    /**
132     * Print the database in a single transaction.  All entities are printed
133     * and the indices are used to print the entities for certain keys.
134     *
135     * <p> Note the use of special iterator() methods.  These are used here
136     * with indices to find the shipments for certain keys.</p>
137     */
138    private class PrintDatabase implements TransactionWorker {
139
140        public void doWork()
141            throws Exception {
142            printEntries("Parts",
143			 views.getPartEntrySet().iterator());
144            printEntries("Suppliers",
145			 views.getSupplierEntrySet().iterator());
146            printValues("Suppliers for City Paris",
147			views.getSupplierByCityMap().duplicates(
148							"Paris").iterator());
149            printEntries("Shipments",
150			 views.getShipmentEntrySet().iterator());
151            printValues("Shipments for Part P1",
152			views.getShipmentByPartMap().duplicates(
153						new PartKey("P1")).iterator());
154            printValues("Shipments for Supplier S1",
155			views.getShipmentBySupplierMap().duplicates(
156					    new SupplierKey("S1")).iterator());
157        }
158    }
159
160    /**
161     * Populate the part entities in the database.  If the part map is not
162     * empty, assume that this has already been done.
163     */
164    private void addParts() {
165
166        Map parts = views.getPartMap();
167        if (parts.isEmpty()) {
168            System.out.println("Adding Parts");
169            parts.put(new PartKey("P1"),
170                      new PartData("Nut", "Red",
171                                    new Weight(12.0, Weight.GRAMS),
172                                    "London"));
173            parts.put(new PartKey("P2"),
174                      new PartData("Bolt", "Green",
175                                    new Weight(17.0, Weight.GRAMS),
176                                    "Paris"));
177            parts.put(new PartKey("P3"),
178                      new PartData("Screw", "Blue",
179                                    new Weight(17.0, Weight.GRAMS),
180                                    "Rome"));
181            parts.put(new PartKey("P4"),
182                      new PartData("Screw", "Red",
183                                    new Weight(14.0, Weight.GRAMS),
184                                    "London"));
185            parts.put(new PartKey("P5"),
186                      new PartData("Cam", "Blue",
187                                    new Weight(12.0, Weight.GRAMS),
188                                    "Paris"));
189            parts.put(new PartKey("P6"),
190                      new PartData("Cog", "Red",
191                                    new Weight(19.0, Weight.GRAMS),
192                                    "London"));
193        }
194    }
195
196    /**
197     * Populate the supplier entities in the database.  If the supplier map is
198     * not empty, assume that this has already been done.
199     */
200    private void addSuppliers() {
201
202        Map suppliers = views.getSupplierMap();
203        if (suppliers.isEmpty()) {
204            System.out.println("Adding Suppliers");
205            suppliers.put(new SupplierKey("S1"),
206                          new SupplierData("Smith", 20, "London"));
207            suppliers.put(new SupplierKey("S2"),
208                          new SupplierData("Jones", 10, "Paris"));
209            suppliers.put(new SupplierKey("S3"),
210                          new SupplierData("Blake", 30, "Paris"));
211            suppliers.put(new SupplierKey("S4"),
212                          new SupplierData("Clark", 20, "London"));
213            suppliers.put(new SupplierKey("S5"),
214                          new SupplierData("Adams", 30, "Athens"));
215        }
216    }
217
218    /**
219     * Populate the shipment entities in the database.  If the shipment map
220     * is not empty, assume that this has already been done.
221     */
222    private void addShipments() {
223
224        Map shipments = views.getShipmentMap();
225        if (shipments.isEmpty()) {
226            System.out.println("Adding Shipments");
227            shipments.put(new ShipmentKey("P1", "S1"),
228                          new ShipmentData(300));
229            shipments.put(new ShipmentKey("P2", "S1"),
230                          new ShipmentData(200));
231            shipments.put(new ShipmentKey("P3", "S1"),
232                          new ShipmentData(400));
233            shipments.put(new ShipmentKey("P4", "S1"),
234                          new ShipmentData(200));
235            shipments.put(new ShipmentKey("P5", "S1"),
236                          new ShipmentData(100));
237            shipments.put(new ShipmentKey("P6", "S1"),
238                          new ShipmentData(100));
239            shipments.put(new ShipmentKey("P1", "S2"),
240                          new ShipmentData(300));
241            shipments.put(new ShipmentKey("P2", "S2"),
242                          new ShipmentData(400));
243            shipments.put(new ShipmentKey("P2", "S3"),
244                          new ShipmentData(200));
245            shipments.put(new ShipmentKey("P2", "S4"),
246                          new ShipmentData(200));
247            shipments.put(new ShipmentKey("P4", "S4"),
248                          new ShipmentData(300));
249            shipments.put(new ShipmentKey("P5", "S4"),
250                          new ShipmentData(400));
251        }
252    }
253
254    /**
255     * Print the key/value objects returned by an iterator of Map.Entry
256     * objects.
257     */
258    private void printEntries(String label, Iterator iterator) {
259
260        System.out.println("\n--- " + label + " ---");
261        while (iterator.hasNext()) {
262            Map.Entry entry = (Map.Entry) iterator.next();
263            System.out.println(entry.getKey().toString());
264            System.out.println(entry.getValue().toString());
265        }
266    }
267
268    /**
269     * Print the objects returned by an iterator of value objects.
270     */
271    private void printValues(String label, Iterator iterator) {
272
273        System.out.println("\n--- " + label + " ---");
274        while (iterator.hasNext()) {
275            System.out.println(iterator.next().toString());
276        }
277    }
278}
279