ExampleInventoryRead.class
Prev | Chapter 5. Reading Data From Entity Stores | Next

## ExampleInventoryRead.class

To illustrate the points that we make in the previous sections, we wrote `ExampleInventoryRead` example application. This program retrieves inventory information from our entity store and displays it. When it displays each inventory item, it also displays the related vendor contact information.

`ExampleInventoryRead` can do one of two things. If you provide no search criteria, it displays all of the inventory items in the store. If you provide an item name (using the `-s` command line switch), then just those inventory items using that name are displayed.

The beginning of our example is almost identical to our `ExampleDatabasePut` example program. We repeat that example code here for the sake of completeness. For a complete walk-through of it, see ExampleDatabasePut.class.

    package persist.gettingStarted;

    import java.io.File;
    import java.io.IOException;

    import com.sleepycat.je.DatabaseException;
    import com.sleepycat.persist.EntityCursor;

    public class ExampleInventoryRead {

        private static File myDbEnvPath =
            new File("/tmp/JEDB");

        private DataAccessor da;

        // Encapsulates the database environment.
        private static MyDbEnv myDbEnv = new MyDbEnv();

        // The item to locate if the -s switch is used
        private static String locateItem;

        private static void usage() {
            System.out.println("ExampleInventoryRead [-h <env directory>]" +
                               "[-s <item to locate>]");
            System.exit(-1);
        }

        public static void main(String args[]) {
            ExampleInventoryRead eir = new ExampleInventoryRead();
            try {
                eir.run(args);
            } catch (DatabaseException dbe) {
                System.err.println("ExampleInventoryRead: " + dbe.toString());
                dbe.printStackTrace();
            } finally {
                myDbEnv.close();
            }
            System.out.println("All done.");
        }

        private void run(String args[])
            throws DatabaseException {
            // Parse the arguments list
            parseArgs(args);

            myDbEnv.setup(myDbEnvPath, // path to the environment home
                          true);       // is this environment read-only?

            // Open the data accessor. This is used to retrieve
            // persistent objects.
            da = new DataAccessor(myDbEnv.getEntityStore());

            // If a item to locate is provided on the command line,
            // show just the inventory items using the provided name.
            // Otherwise, show everything in the inventory.
            if (locateItem != null) {
                showItem();
            } else {
                showAllInventory();
            }
        }

The first method that we provide is used to show inventory items related to a given inventory name. This method is called only if an inventory name is passed to `ExampleInventoryRead` via the `-s` option. Given the sample data that we provide with this example, each matching inventory name will result in the display of three inventory objects.

To display these objects we use the `Inventory` class' `inventoryByName` secondary index to retrieve an `EntityCursor`, and then we iterate over the resulting objects using the cursor.

Notice that this method calls `displayInventoryRecord()` to display each individual object. We show this method a little later in the example.

        // Shows all the inventory items that exist for a given
        // inventory name.
        private void showItem() throws DatabaseException {

            // Use the inventory name secondary key to retrieve
            // these objects.
            EntityCursor<Inventory> items =
                da.inventoryByName.subIndex(locateItem).entities();
            try {
                for (Inventory item : items) {
                    displayInventoryRecord(item);
                }
            } finally {
                items.close();
            }
        }

Next we implement `showAllInventory()`, which shows all of the `Inventory` objects in the store. To do this, we obtain an `EntityCursor` from the `Inventory` class' primary index and, again, we iterate using that cursor.

        // Displays all the inventory items in the store
        private void showAllInventory()
            throws DatabaseException {

            // Get a cursor that will walk every
            // inventory object in the store.
            EntityCursor<Inventory> items =
                da.inventoryBySku.entities();

            try {
                for (Inventory item : items) {
                    displayInventoryRecord(item);
                }
            } finally {
                items.close();
            }
        }

Now we implement `displayInventoryRecord()`. This uses the getter methods on the `Inventory` class to obtain the information that we want to display. The only thing interesting about this method is that we obtain `Vendor` objects within. The vendor objects are retrieved `Vendor` objects using their primary index. We get the key for the retrieval from the `Inventory` object that we are displaying at the time.

        private void displayInventoryRecord(Inventory theInventory)
                throws DatabaseException {

                System.out.println(theInventory.getSku() + ":");
                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: ");

                Vendor theVendor =
                        da.vendorByName.get(theInventory.getVendor());
                assert theVendor != null;

                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());
        }

The last remaining parts of the example are used to parse the command line. This is not very interesting for our purposes here, but we show it anyway for the sake of completeness.

        protected ExampleInventoryRead() {}

        private static void parseArgs(String args[]) {
            for(int i = 0; i < args.length; ++i) {
                if (args[i].startsWith("-")) {
                    switch(args[i].charAt(1)) {
                        case 'h':
                            myDbEnvPath = new File(args[++i]);
                        break;
                        case 's':
                            locateItem = args[++i];
                        break;
                        default:
                            usage();
                    }
                }
            }
        }
    }

This completes our example application. Be aware that this example and supporting classes can be found in your JE distribution in the following location:

JE_HOME/examples/persist/gettingStarted

where `JE_HOME` is the location where you placed your JE distribution.

Prev | Up | Next
Retrieving Multiple Objects | Home | Chapter 6. Other Operations