Download FastObjects Database Components

Database Components
featured by Poet Software.
PROGRAMMING INTERFACES (API)
JDO 1.0 Java API
ODMG 3.0 Java API
Java Enhancer as post-processor
C++ API
QUERY LANGUAGES AND QUERY INTERFACES
JDOQL (API based on Java query interface, standardized)
OQL (Object Query Language, standardized ad hoc query language)
PtQL (API based on C++ query interface)
Advanced Query Optimizer (server-side query optimization)
Filter expressions on any data collections
Fast Look-up (for quick positioning in object collections)
Verity full text indexing
Compound indices, even beyond object limits
OBJECT MODEL
Fast navigation in objects and object networks
Locking and Access mechanisms at object level
(complete support of all concurrency levels)
Watch-Notify (Callbacks support: observation and
notification framework upon data changes)
Storage of unknown data types (3rd party class support)
Transport of objects via VM or transaction limits
SECURITY
User Administration
Rights Management at class level
Database encryption
(Transparent encryption of data and indices with user-defined keys)
Encrypted Client-Server Communication
INTERFACES AND STANDARDS
SQL Object Factory (transparent access to relational databases)
Integration with Enterprise-Application Servers
via J2EE-Connector-Architecture (JCA)
Support of J2EE Transaction model
(Session Beans und Bean-Managed Persistence)
XML Support (complete import and export of objects)
ODBC Driver
FastObjects Database Components
Features in Detail, Page 2
SCALABILITY AND PERFORMANCE
Multi-Threaded Server and Load Balancing
Active Cache (transparent, client-based "Object Cache")
Extensive polymorphic indexing, especially on "collections”
Access path (configurable bundling of reading operations)
DATA SECURITY AND AVAILABILITY
High availability (combination of replication and
fail-over technology, support MS-Cluster Server)
Shadow database
(user-defined database copy to increase security in case of failure)
Complete online-backup
(complete data backup in an ongoing business)
Incremental online-backup
(configurable partial backup in an ongoing business)
In-Memory databases (complete database functionality in RAM
for non-disk systems. Substantial
performance optimization in connection with shadow databases)
Online Replication for load balancing and data security
Fail-Over (Transparent, uninterrupted reactivation
within seconds after server failure)
RELIABILITY AND NO MAINTENANCE
Checksums
(permits recognition of hard disks, memory and networks errors)
Automatic Recovery
Online Database Check
(Check of consistency in database in an ongoing business)
Free space management
Simple installation
Schema Versioning “Versioning on the “Fly”
(Changes to DB schemas in existing databases)
INTERNATIONALIZATION AND SYSTEM INDEPENDENCE
UNICODE strings and language-specific sorting (ISO-14651)
Programming language independence
Operating system independence
PRODUCTIVITY AND INTEGRATION IN DEVELOPMENT ENVIRONMENT
Java IDE Integration (JBuilder, Forte)
UML Integration (Rational Rose, Together J)
Visual database tools
FastObjects Database Components
Features in Detail, Page 3
FastObjects Features in Detail
Programming Interface (API)
If you program in object-oriented language, you should store in OO too. After all,
do you know anyone who takes his car apart and then puts the individual parts
carefully on a shelf instead of simply driving the car into the garage?
FastObjects supports the Java and C++ object model. You can concentrate on your
application model instead of writing mapping code. You save code (up to 40 percent less application code) and your application runs significantly faster. The more
complex your model is, the greater the benefits of using FastObjects.
JDO 1.0 Java API
The JDO program interface (Java Data Objects ) is the standard for database access in Java, developed by Sun,
IBM, Oracle and many others. It offers a complete programming model that’s easy to use. Applications developed with JDO are manufacturer-independent and can manage your data with various database technologies
(relational or object-oriented) from all JDO-compatible manufacturers.
FastObjects has worked on the specifications of JDO standards right from the start and was the first database
producer to offer a complete JDO implementation for the entire FastObjects product line in June 2002.
ODMG 3.0 Java API
The Java programming interface of the Object Data Management Group (ODMG) was the first object-oriented
standard for Java persistence. FastObjects contributed substantially to the development of the standard and
has supported the standard in Version 2.0 since 1997. Version 3.0 of the standard was released in 1999 and
implemented in FastObjects.
Like JDO, the ODMG interface offers a transparent programming model that’s elegantly embedded in Java. Any
Java class can be made persistent with its entry in a configuration file.
Java Enhancer as Post-processor
As a FastObjects developer, you can concentrate on your class model. Our post-processor determines the database schema from the configuration file and your class definitions, creates the database and expands the Java
byte code to include database functionality. This ensures that the database schema and class definitions are
always well-matched.
C++ API
FastObjects has had a very efficient C++ API since its first release (1991). The easy-to-use interface permits
precise management of the object model. FastObjects also supports complex language mechanisms such as
multiple inheritance and the embedding of objects. Complicated processes can be reproduced elegantly, thanks
to a highly refined locking concept and a flexible notification model (Watch/Notify). Solid support for multitiered architecture is also offered by parallel transactions and multi-threading capability.
FastObjects Database Components
Features in Detail, Page 4
Query languages and query interfaces
FastObjects offers a whole range of search and indexing possibilities so that you
can query your objects quickly and reliably. They include direct navigation through
the object network, object extents, filter expressions and database queries.
JDOQL (API based on Java query interface, standardized)
Those who want to remain compatible with JDO should use JDOQL, the JDO standard query language. Based on
the Java class model, it follows Java very closely. This allows you to forego the learning curve associated with
another query language.
OQL (Object Query Language, standardized ad hoc query language)
With Object Query Language, the ODMG standard offers a query language that allows ad hoc queries. A query
formulated with SQL-like syntax delivers its results in the form of completely constructed objects. There’s no
need to transfer query results from the SQL buffer into objects. Our OQL implementation is available for Java
and C++.
PtQL (API based on C++ query interface)
Very often the structure of a query is determined during development so that no ad hoc query is necessary. For
these application situations, FastObjects offers an efficient query API in its PtQL. Your advantage: more type
security and less overhead, because preparation of query strings is no longer required.
Advanced Query Optimizer (Server-side query optimizing, possibly to OQL)
Regardless of the best choice of query language for your application, one fact remains: it has to be fast. For
this reason, we have developed a dynamic, server-based query optimizer that improves the runtime of every
query. In the process, the best indices are selected, processing steps are reorganized and path expressions are
optimized.
FastObjects benefit: Filter expressions for any data quantity
Many application developers are familiar with the problem of how to depict large quantities of data in a browser. Due to copious amounts of data, a query takes too long and overburdens main memory.
FastObjects solves this problem with server-based filters. The application formulates the filter expression for
any amount of data and iterates it over suitable objects. The application can begin displaying immediately
and does not have to wait for the end of the query.
FastObjects benefit: Fast Lookup
Your application should interactively search through great amounts of data. For example, after entry of the
first letter, the pointer should go directly to the available entries under that letter.
No problem with the FastObjects search() method. Lightning-fast, it positions you directly in an index. From
this starting point, you can move forward or backward. The whole thing runs directly on the index trees
without a query and without loading time for the object.
FastObjects benefit: Verity full-text indexing
These days, full-text searches are offered by all reasonable databases, at least in extensions. FastObjects
goes even further. We’ve integrated the Verity full-text engine transparently into our query engine. As a result,
it is possible to mix full-text queries with regular attribute queries. A FastObjects benefit.
FastObjects Database Components
Features in Detail, Page 5
Object Model
FastObjects directly supports the Java und C++ object model. Complex class
models that combine several language mechanisms (heredity, polymorphous, aggregation) can also be depicted without modification in the database. There’s no
need for a translation from object model to data model, which means less database code, shorter development times and significantly improved performance.
Fast Navigation in Objects
In addition to queries and filters, FastObjects offers another means of access to objects: navigation. In
FastObjects, C++ pointers or Java references of the object model are translated directly into database references. Pursuit of a reference, therefore, constitutes direct access to memory instead of foreign key access. This
means extremely fast read time for networked objects. If the referenced object is already loaded or is in the
cache, access is a straightforward main memory operation.
Lock and Access Mechanisms at Object Level
In matters involving lock and access mechanisms, FastObjects follows the logic of your programming language.
Complete objects or object trees can be locked through a very finely configurable locking system. It minimizes
locking conflicts and makes possible high-performance multi-user applications even as the transaction logic
becomes more complex.
Watch-Notify
Especially in the management and visualization of secondary processes, FastObjects offers more than the competition. An intelligent observation and notification report (Watch/Notify) informs the client of database
events (insert, update, delete, etc.) and permits quick reaction. It’s a multi-faceted deployable mechanism for
cooperating processes.
FastObjects benefit: Storage of Unknown Data Types
You’d like to use Java classes that are not in the source code? And to store data types whose structure is
unknown? No problem for the Java API from FastObjects. We can also store what we don’t understand. Even
unknown data types that call up "native" code can be read and stored by FastObjects.
FastObjects benefit: Transport of Objects via VM or Transaction Limits (Serializing)
Sometimes you want to hand over database objects from your application server to an applet. Because your
applet contains no database code and can remain small and compact. In Java there is a mechanism called
serializing for just this purpose. With FastObjects, you can serialize database objects among various VMs on
different computers. It also works in two directions (bi-directional), that is, your applet can make changes
and report back using a standard protocol. A FastObjects benefit.
FastObjects Database Components
Features in Detail, Page 6
Security
You really appreciate security once something has gone wrong. So that you’ll never
get to that point, FastObjects offers a thorough security concept from user administration and rights management to database encryption.
User Administration
FastObjects supports a user administration that prevents all users from gaining access to all data and assigns
specific authorization to persons and groups. And because the system allows you to package groups as required, complex roles can be easily constructed.
Rights Management at Class Level
In access authorization, FastObjects distinguishes among reading, changing and deleting of objects. In the
process, access rights apply to all objects in a class, but can be further restricted through attributes.
(Example: Clerk Miller can process only clients A to M.)
Database Encryption
If your database data are stolen, sensitive data have to be protected from unauthorized access. FastObjects
offers you this protection by means of completely transparent database encryption. Both data and index
information are encoded through the Blowfish algorithm. This encryption process is efficient and license-free.
Would you rather use a different algorithm? No problem. The encryption is interchangeable.
Encrypted Client-Server Communication
However, security means more than only the encryption of data. When you’re communicating, no one is allowed to listen in. That’s why we also encrypt data traffic between client and server. With Open SSL, both parties negotiate a secure connection and generate a secure key. Every communication between your application
and the Poet server is then bug-proof. FastObjects offers a recognized high security level, namely SSL 3.0. The
same applies here: if you’d rather use the services of another encryption provider, that’s no problem. This
encryption is also interchangeable.
Interfaces and Standards
Of course we are the best. But one can’t do everything alone. That’s why we have
interfaces to other systems and applications.
SQL Object Factory
Do you already hold relational licenses? Does your customer insist on using a relational database? What you
need is an elegant object-oriented interface. Otherwise, you’ll be short of time.
With the SQL Object Factory, FastObjects offers transparent access to the most important relational database
servers: Oracle, MS SQL Server and DB2. You can use our tested program interfaces in your applications for this
purpose.
FastObjects Database Components
Features in Detail, Page 7
A FastObjects benefit: Integration in J2EE Transaction Schema
Today enterprise applications are developed in Java. With links to transaction servers: Bean-Managed
Persistence with Session Beans. With FastObjects, you are completely up-to-date, as far as beans are concerned. Thanks to the complete support of Enterprise Java Beans 2.0 (EJB) over resource adapter. Simple, transparent and compatible with all EJB 2.0 application servers.
XML Support
An XML schema contains data types and value ranges – enough information to create Java classes. Nothing is
quicker than transferring the XLM structure into Java objects. It goes quickly and requires only a minimum of
application code. The developer has his familiar Java interface and doesn’t have to spend time on analyzing
the XML structure. It’s a simple data-binding tool and very few lines of code. Nothing more is needed to work
with FastObjects XML data.
Furthermore, through use of an XML-based export/import schema, we make it possible to connect to external
tools for all data stored in FastObjects.
ODBC Driver
With its ODBC Driver, FastObjects provides a relational view of object-oriented data. You can easily connect
your application to standard tools for additional analysis with a report generator or further processing with a
spreadsheet.
Scalability and Performance
Higher performance levels with complex models is a given for FastObjects. It’s
especially important to us that performance remain stable even as the number of
users increases. A scalable system.
Multi-Threaded Server and Load Balancing
A FastObjects server can do a lot at one time. Thanks to its multi-threading architecture, FastObjects processes parallel reading access and exploits multi-processing engines to their fullest.
If a multi-processing engine does not suffice, you can call on the load balancing function of the FastObjects
replication mechanism. Our online replication can make as many copies of the database as required on other
servers, update the databases online and make them available for online queries.
Active Cache
The fastest database access is one that doesn’t even have to be executed – because the object is already
there. The FastObjects Active Cache notes the objects read by the client. If the object is once again required,
there’s no need for network transport or disk access. A separate lock server ensures consistency in the caches
of individual clients. The FastObjects Active Cache works in a transparent manner, that is, your application
doesn’t change. It will simply be faster.
FastObjects benefit: Access Paths
In many applications, the bandwidth of the network connections is a bottleneck. In this case, the access
paths of FastObjects help to reduce network loads. The application defines rules for combining sub-objects or
object quantities in read operations. The referenced object is read too and the application is spared network
access. Because the rules for runtime can be selected, the application can react with flexibility to different
contexts.
FastObjects Database Components
Features in Detail, Page 8
Far-reaching polymorphous Indexing
Speed is not sorcery. In database queries, speed essentially depends on available indices. FastObjects has
supported the construction of complex indices since its first release. This support has been systematically
expanded over the course of the past years. All attributes of a persistent class can be indexed individually or
in combination with other attributes. In the process, FastObjects supports not only individual data types but
also the indexing of collections within objects. In keeping with our object-oriented logic, the indexing in
FastObjects is polymorphous, that is, the indices function for derived classes too.
Data Security and Availability
Anything that can go wrong will go wrong at some point. So that everything can
continue to function properly, FastObjects offers server clusters and online backup.
High Availability
There are applications in which a server just can’t fail – or if it does, a replacement server has to jump in
right away. That can’t happen fast enough. In a FastObjects server cluster, the backup server is always running
in tandem. If the main server fails, your application can switch over as fast as lightning.
We can do that even without special support from the operating system. On simple standard hardware. In
seconds. Your application continues running as if nothing at all had happened.
Shadow Database
Protection from failure is also important in configurations without servers. That’s why j2, our real-time database, offers the chance to save a user-defined online copy. That’s security against fails on server-less systems
with a shadow database for j2.
Complete Online Backup
Some systems cannot be shut down, but data backup still has to take place. With FastObjects’ online backup,
the FastObjects server is set to backup mode even while the application is running. The backup can be made
while operations continue. FastObjects stores all transactions completed during backup in a Forward Recovery
Log and then loads them into the database once the backup is complete.
Incremental Online Backup
If a full backup requires too much memory, a partial backup can be carried out. This can also be done online.
Full backups at longer intervals and partial backups in between. With these options, FastObjects offers a truly
flexible security concept.
In-Memory Database
It may sound strange: even systems without drives need database functionality. With j2, you have complete
database functionality in main memory. That also means that you have the speed of the main memory.
FastObjects Database Components
Features in Detail, Page 9
Reliability and No Maintenance
Your application is running at several customer locations. Not everyone has a database administrator on staff. Especially in times of tight budgets, maintenance
expenditure has to be kept low. Whether it’s a matter of hardware errors or new
versions, your customers are entitled to low-maintenance software.
Check Digits
Hard drives can also be defective. Or drive controllers can malfunction. Or the network can corrupt a bit. Or a
memory overwrite can change the byte stream while reading. FastObjects stores a check digit for every object
as a safeguard. This lets us ensure that the content of the object is not changed between write access and
read access. Because malfunctions are recognized immediately, your application can react quickly -- with an
automatic repair, a switch to an online replicate or use of an earlier data backup.
Automatic Recovery
Of course databases have to be secure. Even if the plug is pulled in the middle of operations so that the vacuum cleaner can be plugged in.
FastObjects is "automatically" secure to a certain extent. Our Recovery Log is always running. When the database is brought up, FastObjects checks the status of the log and automatically puts the database into a consistent state. The user simply has to put the plug back into the outlet. It’s "vacuum cleaner-proof”.
FastObjects benefit: Online Database Check
The hardware has failed or your software has a pointer error. You want to be sure that the database is still
consistent. FastObjects offers an online database check that examines the consistency of the database while
the application is running. FastObjects checks the index trees, available memory administration, object consistency and reference completeness. And then repairs any errors.
Available Memory Administration
So that your database remains compact and fast even after running for some time, FastObjects has an integrated available memory administration function. It registers sectors in the database as they become available,
assembles adjacent memory and reassigns it. That keeps your database from coming apart at the seams.
Schema Versioning
Your application was already good. But the new release is even better. Unfortunately, you have to adjust the
data structures, add classes and change data types to accommodate it. The data for hundreds of customers
have to be converted.
No problem with FastObjects. Our Data Dictionary can handle several class descriptions. Your customer installs
the new dictionary and FastObjects recognizes the differences between the old and new class versions and
converts the objects: either in batch mode or while the application is running. Read old objects and write new
ones. We call that "Versioning on the Fly."
FastObjects benefit: Simple Installation
In many applications, the problems begin at installation: installation routines for the database, extensive entries in system tables, new driver versions and all kinds of configurations. Not so with FastObjects. We just go
along for the ride in a "co-installation”. Your installation program copies our library and executables. You can
handle the little bit of configuration with our API – in your installation program. Then your customers won’t
have to call support while they’re still in the installation phase.
FastObjects Database Components
Features in Detail, Page 10
Internationalization and System-Independence
Markets are melding together and you want to market your application internationally, regardless of the hardware. You’ll increase turnover.
Unicode Strings and Language-specific Sorting
FastObjects stores unicode strings and sorts them with lexical correctness, in accordance with ISO-14651. We
sort a German "ü" as "ue" and a Spanish "ll" as "j" instead of strictly following the ANSI table. So that your
application can be really international, every string can have its own language context.
Language and Operating System Independence
Your customers have diverse UNIX servers, Windows clients and NT servers too. With FastObjects, you can support heterogeneous networks. The objects are transparently converted into the client’s processor format. The
programming language plays no role at all.
Java applications can read data written in C++ with no trouble. And vice versa, of course. If you want to
switch servers (for example, from Windows to Unix), you have only to copy the database: binary-compatible,
language-independent objects.
Productivity and Integration in Development Environment
To be able to develop productively, you need the right tools. A simple build-process saves time and money. That’s why we’ve integrated FastObjects into all conventional development environments and modeling tools. So that routine work
won’t hold you up.
UML Tool Integration
You develop your class model with UML and that gives you a well thought out design. We’ve integrated
FastObjects into Rational Rose so that you can define your database design with UML too. It doesn’t matter if
you use C++ or Java ODMG. You can define persistent classes and index descriptions directly in your UML
model.
Java IDE Integration
So that you can build your database and change versions quickly, we’ve integrated FastObjects into Jbuilder
and Forte. Our code enhancer is automatically called up at every build-process. It creates the database schema
or adjusts to its altered class model. Indices are automatically constructed. You take care of your application
while FastObjects looks after your database objects.
Visual Database Tools
You’d like to look into the database quickly to see which objects have been stored or visualize the database
scheme or check database consistency after a system error. For these purposes, FastObjects offers a series of
visual tools from object and class browsers to database check tools. Everything is on hand in our Developer’s
Workbench.
FastObjects Database Components
Features in Detail, Page 11
© Poet Software GmbH 2002. Poet®, Poet Software and FastObjects are trademarks registered trademarks of
Poet Holdings, Inc.
All rights reserved.
Java™ and all Java™-based trademarks and logos are trademarks or registered trademarks of Sun Microsystems,
Inc. in the U.S. or other countries. Poet Software is independent of Sun Microsystems, Inc. Other product
names may be trademarks of the companies with which the product names are associated.
Poet Software GmbH
Kattjahren 4 - 8, 22359 Hamburg, Germany
http://www.fastobjects.com
Tel.: +49(0)40 / 60 990 - 0
http://community.fastobjects.com
Fax +49(0)40 / 60 990 - 113
eMail: [email protected]