|
Caché Executive
Summary
Caché
Architecture
The
hallmarks of Caché, the post-relational
database, are high performance, massive
scalability, rapid application development,
and cost-effectiveness. These values are
reflected in Caché's basic architecture.

Caché
stores data in an extremely efficient
multidimensional form, thus ensuring lightning-fast
performance, even under heavy loads running
on significantly less hardware than other
database systems. Plus, Caché makes its
data accessible through a wide variety
of technologies, which promotes both openness
and rapid application development because
developers can work with familiar, readily-available
tools.
The
Multidimensional Data Engine
Unlike
relational databases, which force data in
two-dimensional tables, Caché stores data
in multidimensional arrays. In addition
to enabling realistic data modeling, multidimensional
arrays are much faster to access because
they eliminate the processing overhead associated
with "table-hopping" and "joins" that typify
relational technology. Another performance-enhancing
feature is Caché's unique Distributed Cache
Protocol, which dramatically reduces network
traffic in distributed systems. In customer
tests, Caché has performed up to 20 times
faster than relational databases.
Although
data is stored in multidimensional form,
Caché gives developers the freedom to
model their data any way they choose:
as objects, as tables, or as multidimensional
arrays. Caché comes with an easy-to-use
graphic interface for creating Caché Objects.
It can also accept input from Rational
Rose (an object modeling tool) and DDL
files (the standard for defining relational
tables).
By
virtue of Caché's Unified Data Architecture,
all data is automatically accessible as
both objects and tables. There is never
a need to "map" from one form to the other,
and no processing overhead required to
convert between forms. The Unified Data
Architecture increases both productivity
and performance.
Caché
also allows choices when it comes to database
and business logic scripting. Caché ObjectScript
supports all data access methods: objects,
SQL, multidimensional, and even embedded
HTML. Caché Basic is similar to Visual
Basic, with a few modifications to take
advantage of unique Caché capabilities.
Web
Access
In
keeping with InterSystems' core values,
Caché's Web connectivity is geared toward
providing high-performance and massive
scalability, coupled with a super-fast
application development platform. In Caché's
unique Web architecture, Caché Server
Pages execute on the data server, close
to the data they need to access. Not only
does this approach boost performance,
it greatly enhances scalability by taking
much of the processing load off the Web
server, leaving it free to handle more
browser requests.
Caché
applies the rapid development power of
object technology to the creation of Caché
Server Pages. Every Caché Server Page
is itself an object, and can inherit session
management behavior (of various levels
of security) from system objects provided
by InterSystems. This frees application
developers from much of the tedious system-level
coding needed to maintain "state" during
user sessions. Object inheritance is also
a quick way to ensure a consistent "look"
across all pages of an application.
Additionally,
Caché simplifies Web development by allowing
Web designers and application developers
to work in parallel to achieve the final
result. Using familiar and readily-available
Web authoring tools, Web designers add
functionality to pages by incorporating
Caché Application Tags (CATs) the same
way they would any standard HTML tag.
CATs for some standard functions come
with Caché, or they can be custom-built.
Application developers can write CATs
that perform useful functions, regardless
of the design of the page that contains
them. As a result, Web applications can
be developed more rapidly and efficiently
to enable the short time-to-market that's
essential on the Web.
Object
Access
These
days, virtually all new application development
is done using object modeling techniques.
Modeling data as objects allows developers
to think about data in a natural, intuitive
way. And because objects are modular,
with well-defined interfaces, they are
reusable, and can be shared between applications,
resulting in significant productivity
gains.
Caché
supports a full range of object modeling
techniques, including multiple inheritance,
encapsulation, polymorphism, references,
collections, relationships, and BLOBs.
Caché Objects can be created with the
Caché Object Architect (an easy-to-use
graphical interface) or through Caché's
bi-directional link to Rational Rose (a
popular object modeling tool). Unlike
some "object-relational" database systems,
Caché allows data schema evolution, so
object definitions can be altered to fit
the changing needs of your applications.
And, thanks to Caché's Unified Data Architecture,
all Caché Objects are automatically ODBC-compatible.
Caché
Objects are also compatible with a wide
range of object-oriented tools and technologies.
They can be used by Java and C++ developers,
and by tools (such as Visual Basic and
Delphi) that use the COM interface. Caché
also comes with a bi-directional CORBA
interface.
SQL
Access
In
their heyday, relational databases were
ubiquitous, and even today they represent
a majority of the databases still in use.
Many software applications, particularly
those for data reporting and analysis,
use SQL as their query language, and require
an ODBC- or JDBC-compliant database at
the other end. Through it's SQL data access,
Caché is available to all these applications.
In addition, the Caché SQL Gateway allows
Caché applications to access data stored
in relational databases - very useful
when there is a need to integrate data
from a variety of sources.
Some
developers may wish to migrate applications
from a relational database to Caché in
order to take advantage of Caché's higher
performance and advanced object technology.
Caché can create data structures from
relational table definitions contained
in DDL files. By virtue of Caché's Unified
Data Architecture, every table definition
becomes a simple object that can be used
as is, or as building blocks for more
complex structures. Then, using the SQL
Gateway, data can be transferred from
the old relational database into Caché.
Multidimensional Access
Multidimensional
data access provides compatibility with
other InterSystems products, all of which
use the same kind of multidimensional
data structures as Caché. MVON is a MultiValue
Basic implementation that, through Caché's
multidimensional access, can point to
Caché as its data repository.
|