Jovis, a Database Engine
Volume Number: 14
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.
Out of the Box
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.
The Product
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.
Using Jovis
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.
Licensing and Costs
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.
The Bottom Line
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.
Products Reviewed
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.