Volume Number: 14 (1998)
Issue Number: 4
Column Tag: Tools Of The Trade

Jovis, a Database Engine in a Tiny Package

by Edward Ringel

A robust database engine for HyperCard and other XCMD compatible environments

Knowledge base development, particularly contract or in-house development, does not require a C, Pascal or C++ environment. To the contrary, many corporate databases and commercially deployed knowledge bases are well supported by database languages such as Fourth Dimension. Other knowledge bases use an authoring front end along with an attached database engine. For example, I use a product called Scientific American Medicine, a complete electronic textbook of internal medicine, that is extensively cross referenced and searchable. It was developed with a MacroMedia Director front end. High level, programmable authoring environments such as HyperCard, SuperCard, and Director can be particularly appropriate when the knowledge base includes pictures, sounds, and videos. These environments are inherently multimedia capable and require little programming knowledge to play a QuickTime clip or show a PICT.

Jovis, by DAS Works, is an extended XFCN that provides broad relational and architectural database capabilities for environments that support XCMD's and XFCN's. This is a comprehensive, well documented product that can support knowledge base development and more traditional database functions in a number of different user settings.

I received a single disk, a serial number, and a big book. The product comes as a single user SDK or an individually configured Client/Server product; I was sent the single user product for review. In order to use Jovis, I needed to install the product into a HyperCard stack. I could not install the XFCN's into HyperCard itself. Installation, rather than execution is protected by the serial number. (Licensing is addressed later.) The code I used is 68K based and is just under 400K. A PPC version is also available if requested.

The documentation consists of a 16 lesson tutorial and extensive documentation of the various calls. As with most good documentation, the tutorial builds nicely upon itself and is easy to follow. DAS Works does not supply step by step "solutions" to the tutorials; this forces the reader to actually work through the projects to see if they work. The demo supplied with the product actually is a culmination of the tutorials and is a real world example. The lessons address both the relational and architectural capabilities of the product. An introduction also is provided to show some of the intricacies of multi-user issues such as record locking and transactions.

The reference section comprehensively addresses the Jovis calls. Each entry describes the syntax of the call, provides an example, describes the action of the call, and offers relevant comments.

Although a tutorial for Jovis is provided, there is little in the way of more complex examples or a section on "putting it all together." I think they must assume that the user has a good idea of how to use a database. The tutorial teaches the nomenclature and specifics of this particular environment, but does not address design or the management of a complex environment.

Jovis supports a comprehensive set of relational commands and structures. Relational file creation and open/close operations are very simple and straightforward. Physical files on disk are referred to as "collections," and can contain multiple tables ("relations") and indices. Architectural files are flat file structures that allow the storage, indexing, and rapid retrieval of arbitrary size binary objects (Binary Large Objects, or BLOBs.)

Relation and index construction within a collection requires some work and programming, as with any database system. Jovis offers a shortcut to field and index creation by permitting the creation of a field list or index list. Conceptually, this is like a STR# resource that is then read into the create function, but it is supported as a text string within the scripting language of the front end environment.

Reading and writing records can be performed from script variables or directly into fields in a card or background. Large amounts of data can be read directly into records by an ImportData command. This can be particularly valuable for filling a knowledge base once the structure has been designed and created. There also is an ExportData command.

Obviously, an important feature of a relational engine is the ability to perform a complex search. Jovis does this well. There is a nice section in the tutorial that describes the various comparison operators and how to create compound selection criteria. Jovis supports range searches and the creation of selections. Multiple selections for a given relation are permitted. Merges, which are the same as SQL joins, are supported as a two step process. Selections are first created and then merged. The tutorial completely explains this process.

Record locking and transactions are supported for the multiuser version. There is a section on how the Jovis server works at a file level, but the manual does not teach you how to undertake the design and deployment of a shared, multiuser database system. Calls provided, however, will permit the knowledgeable user to implement a robust, safe multiuser database.

The architectural commands are as important as the relational instructions. Multimedia developers will make heavy use of BLOBs and managing these objects is critical. One very nice feature of Jovis is its ability to embed an architectural file within a relational file, permitting linkage of relational records to architectural indices. As with the relational commands, there is a series of tutorials that teaches the user how to manipulate flat file constructs in the Jovis environment. The tutorial specifically teaches how to use architectural and relational commands and constructs together, which for many developers may be the heart of the product.

Jovis can be used in any XCMD compatible environment. I tested Jovis in a somewhat older version of HyperCard as well as the current version. It also will run in SuperCard, Director, and Oracle Media Objects. Jovis has an initial startup memory requirement of 512K over and above those of the scripting environment. In some cases, the larger the database the greater the memory requirement.

I found the product difficult to benchmark in a meaningful way. Particularly in a multimedia setting, with various scripting environments and different hardware configurations, any comparison might well be irrelevant to the user/programmer. My overall impression was that performance was more than adequate.

Use of the product requires that the programmer follow some conventions regarding the need for the programmer to create several global variables which would then be for the use of the database engine rather than the stack. One very nice feature of this product is very good error management. In addition to the XFCN managing and communicating errors, it is possible for your script to intercept and handle error conditions as well. The ability to provide more than "plain vanilla" dialogs reporting an error condition with graceful recovery is critical to a commercial product.

It was difficult to pick a representative complete script to give a flavor of how the product is used. In the end, I simply took the first one in the tutorial, demonstrating creation of a relational file:

function CreateNewFile
   global myDB, JovisErrorCode
   --myDB is reserved for exclusive use by Jovis 
   if myDB = empty then
      put "Jovis" into myDB
   --initialize myDB
      get Jovis("CreateCollection", "myDB")
      --all calls to Jovis are in the format get Jovis(),
      --with the first parameter the action selector
      if item 1 of JovisErrorCode = "error" then
         answer JovisErrorCode
         put empty into myDB
         return "false"
      else if item 1 of JovisErrorCode = "Warning" then
         answer JovisErrorCode
         put empty into myDB
         return "false"
      end if
    else
      return "false"
   end if
   return "true"
end CreateNewFile

Here are some other brief examples:

Create a relation named customers in the file myDB:

on CreateDemoRelation
   get Jovis("CreateRelation", "myDB", "Customers")
end CreateDemoRelation

Create an text index of 8 character length named Last_Name in the relation Customers in the file "myDB"

on CreateTextIndex
   get Jovis("CreateIndex", "myDB", "Customers",  
                     "Last_Name", "text", 8)
end CreateTextIndex

Perform a selection searching on Last_Name in our hypothetical Customers database:

on DemoSelect

   ask "Enter last name to set selection to:"
   if the result = "cancel" then exit DemoScript
   put it into Last_Name
   Put "Field Last_Name = ["& Last_Name &"]" into Criteria
   Put "Last_Name, phone, Customer_ID, Account_Start"  
                  into FieldList
   get Jovis("Set Selection", "myDB", "Customers", 
                  fieldList,Criteria)
end DemoSelect

While I have not commented this code, I think the general sense of the steps and syntax is apparent.

This product has a somewhat complex licensing arrangement. The basic price for a single user license (single computer for non-commercial distribution) is $345. Thus, the person creating a database for personal use is spared the expense of a full commercial license. If the database will be used on more than a single computer, an additional fee of $350 is required. This additional fee covers everything from unlimited commercial distribution to simultaneous use of the single user product on a second computer in the same office. Hypothetically, a knowledge base with a HyperCard front end and a Jovis database that sells 1000 copies still only costs you $695 in license fees to DAS Works. Not too shabby.

The server version is more expensive, but again within reason. The basic multiuser package comes with a server and a three user license and costs $435. Each additonal user costs $85. The server product is protected by a hardware ADB lock. Licenses for the commercial distribution of a multiuser product developed with Jovis are handled on a case by case basis.

Jovis is a relational and flat file engine that lives in the XCMD world. It has a complete set of relational commands nicely complemented by architectural commands. The two schemes can be used together to create traditional relations supplemented by BLOBs: a perfect combination to implement multimedia presentations. Although difficult to judge, it appears that performance is more than adequate. The pricing scheme has many steps but is fair. Were I developing multimedia on Macintosh, I would give this product serious consideration to implement my work.

It would be very helpful if DAS Works created a "User Manual." The reference manual and tutorial are both quite good. However, once the user is acquainted with the product, he or she will want a document on putting it all together without needing to browse the tutorials again, and something more cohesive than a function call reference. Additionally, Jovis is sufficiently different in structure and nomenclature from SQL that some in depth solutions to complex examples are warranted. Finally, I respectfully suggest a set of text files containing the scripts for each of the tutorials.

Jovis Single User SDK version 1.04. DAS Works, Inc. 250 West 104th St, Suite 84. New York, NY 10025-4292. Toll free (800) 972-2483. Fax (212) 663-4503. email to info@dasworks.com or sales@dasworks.com. There is a website at http://www.dasworks.com/.

Ed Ringel is Contributing Editor for product reviews for MacTech Magazine. When he's not working at the computer or enjoying the Maine lakes and woods, he's a respiratory and critical care physician in Waterville, Maine. He can be reached at eringel@mint.net.