Client applications can communicate with Tamino using APIs that are available for JScript, Java and ActiveX. This is more convenient than using the native HTTP protocol. The APIs then communicate with Tamino at the HTTP protocol level. The basic functionality of the three HTTP Client APIs is the same, independent of the language environment. The names of classes and methods may differ.
The three APIs are called client APIs because the application or program that communicates with Tamino is a client with respect to the server Tamino. In this context, a servlet would also be a client. Each of the APIs supports the W3C DOM (Document Object Model) Level 1 specification. The APIs are also called Tamino DOM APIs. DOM support is implemented in such a way that the API's methods supply a DOM object as a result, or require a DOM object as input. The programmer can then use standardized DOM methods and interfaces to further manipulate the result or navigate through a DOM tree.
The DOM is designed to be used with any programming language. It defines the logical structure of documents and the way a document is accessed and manipulated. With the Document Object Model, programmers can build documents, navigate their structure, and add, modify, or delete elements and content.
For more information about the DOM specification, see http://www.w3.org/DOM/.
By supporting the DOM specification, the Tamino APIs not only allow their data to be manipulated by other routines, but do so in a way that allows those manipulations to be reused with other DOMs, or to take advantage of solutions already written for those DOMs.
The intention is that any DOM implementation can be plugged together with any DOM-based application. You can use any DOM implementation that supports the W3C specification, and you can change the implementation or parts of it later; your application is independent of the implementation.
The Tamino HTTP Client APIs are object-oriented programming interfaces to Tamino that offer a variety of methods and properties for communicating with the Tamino X-Machine. The implemented APIs provide the same functionality over all supported platforms unless stated otherwise.
The names of methods and properties may differ depending on the language environment.
The main methods that are provided are listed below. A complete list of all methods and properties can be found in the API Reference Section of the respective API documentation. The supported methods can be classified in the following way:
Methods to manipulate data in Tamino via URLs, such as
query
process
insert
inodelete
Methods to manipulate data in Tamino via document names, such as
putDocument
getDocument
deleteDocument
Methods to control sessions and transactions
startSession
endSession
commit
rollback
Methods to manipulate the Tamino query result, such as
getResult
getInoId
getFirst
getPrev
If a program needs to open and close database transactions, then there
must be a mechanism that allows Tamino to keep user contexts. This can be
achieved by invoking the StartSession and
EndSession methods of the APIs. The APIs send the
commands connect and
disconnect via HTTP to Tamino. This enables Tamino
to keep the user context and deliver a session key and session ID back to the
API. Session control is then handled by the API transparently to the user.
If a client program needs to handle session control by itself, there
are methods available to get/set these parameters. For example, it could be
possible for a client and server program to share the same session. The
appropriate methods setSessionId,
getSessionId, setSessionKey
and getSessionKey are not available in JScript.
The StartSession method also has the optional
parameters Isolationlevel and
LockWaitMode. By providing these parameters instead of
using the Tamino defaults a more specific security and/or locking mechanism can
be achieved.
For transaction control, the commit and
rollback methods are available. These methods can only
be called during an open session.