KVLite provides an API for Java application programs.

• KVLite is a stand-alone Java application that can be started as follows.

  DOS> cd C:\kv-X.Y.Z
  DOS> java -jar lib/kvstore.jar kvlite

  Notes:

  • If you need to grant more memory to KVlite, you can add these parameters to the call to Java: -Xmx256m -Xms256m
  • You can stop KVLite using ctrl-C in the DOS command window.

• Copy the sample KVLite application (see code/13postrelational/HelloKVLite.java) into a new Intellij IDEA Java project (under cs342/13postrelational/Lab13) and add the KVLite library to the application build path, see:

  C:\kv-X.Y.Z\lib\kvclient.jar

  Run the program as a Java application.

• When you understand the program and its output, add commands to create/read/update/delete a second key-value pair.

Save this modified program for submission. Also, save answers to the following questions in a notes.txt file in the root of your project.

1. Compare and contrast the store.put() command used here for KVLite and the em.persist() command you used for the GlassFish entity manager in the previous lab.

2. Compare and contrast the store.put() command with the standard Java hashtable’s myHashTable.put() command.

Build a new HelloRecords.java application whose output is similar to the following.

New movie record:
	/movie/92616/-/name	: Dr. Strangelove
	/movie/92616/-/year	: 1964
	/movie/92616/-/rating	: 8.7

To achieve this, follow the model shown in HelloKVLite.java noting the following.

• Include the instantiation and closing of a store entity.

• Create/put a separate key-value pair for each field value in the Movie record (i.e., name, year and rating in the example above).
  Note how the key structure shown in the example bundles the field values of a record together using a common major key path (i.e., /movie/$id/) and heterogeneous minor key paths (i.e., /$fieldname), where the $ indicates a varying key path entry. The values are simple strings.

• You create the major and minor key paths as follows.

  Key.createKey(Arrays.asList("movie", movieIdString), Arrays.asList(fieldName))

  Here, the two arguments to createKey() are ArrayLists of the major and the minor paths. The result is an instance of Key. In this case, the “movie” is hard-coded in order to distinguish this key-value pair from other key-value pairs for actors, directors, etc. All the key path elements are strings. You can add more or less elements to each Arrays.asList() element as required by your chosen key structure.

• Remember to convert your value string into a byte array using myValueString.getBytes().

Store this application so that you can upgrade it below. Also, save answers to the following questions in your notes.txt file.

1. Compare and contrast KVLite keys with relational database keys.

KVLite supports multi-valued gets of various kinds. For this exercise, modify your program by refactoring the output code. Right now, it probably uses separate calls to get(), one for each field. Replace this with a single call to multiget(), configured as follows.

Key majorKeyPathOnly = Key.createKey(Arrays.asList("movie", movieIdString));
Map<Key, ValueVersion> fields = store.multiGet(majorKeyPathOnly, null, null);
for (Map.Entry<Key, ValueVersion> field : fields.entrySet()) {
	String fieldName = field.getKey().getMinorPath().get(0);
	String fieldValue = new String(field.getValue().getValue().getValue());
	System.out.println("\t" + fieldName + "\t: " + fieldValue);
}

Note the following about this code segment.

1. When given the major key path (and not the minor key path), multiGet() retrieves a full-key-path-to-value map that contains entries for each key-value pair sharing the given major key path. In the example output above, that’s the pairs for each of movie 92616’s field values.
2. You can get the elements of full retrieved keypath using myKey.getMinorPath().get(keyPathIndex) as shown. A similar function, getMajorPath(), is also provided.
3. The output of your program should be the same as it was in the previous exercise.

Save this upgraded version of the application. Also, add answers to the following in your notes.txt file.

1. So far, the implementation has only dealt with records in one relational table, Movie. Explain how a key-value database might implement the one-to-many join relationships commonly implemented in relational databases using foreign keys.

2. KVLite requires that there be a key, but it is possible to have an “empty” value. Such a value can be created using Value.createValue(new byte[0]). Where might one need such a construct?