Caché

You’ll make breakthroughs
in
data management 
and rapid development

Der Caché Applikationsserver

Der Applikationsserver von Caché bietet alle Möglichkeiten modernster Objektprogrammierung, verfügt über intelligente Caching-Algorithmen und schafft den einfachen Zugang zu einer Vielfalt von Technologien. Der Applikationsserver ermöglicht die schnelle Entwicklung anspruchsvoller Datenbankanwendungen, die zur Laufzeit höchste Performance und einfache Administration bieten.

Der Applikationsserver von Caché zeichnet sich durch folgende Leistungsmerkmale aus:

  • Die Caché Virtual Machine, die die drei Skriptsprachen von Caché, Caché ObjectScript, Caché Basic, und Caché MVBasic, unterstützt.
  • Zugriff auf die multidimensionalen Datenserver von Caché auf dem gleichen und anderen Rechnern mit transparenter Weiterleitung der Daten.
  • Konnektivität mit Caching auf der Client-Seite, um den schnellen Zugriff auf Caché-Objekte aus allen gängigen Technologien wie Java, .NET, C++, C#, COM und Delphi bereitzustellen. Caché sorgt dabei automatisch für die Vernetzung zwischen Client und Applikationsserver.
  • Kompatibilität zu SOAP und XML.
  • SQL-Zugriff mit ODBC und JDBC einschließlich intelligentem Caching auf Client und Applikationsserver, was höchste Performance sichert.
  • Zugriff auf relationale Datenbanken.
  • Caché Server Pages und Zen garantieren hochperformante und einfach zu erstellende Web-Anwendungen.
  • Caché Studio – eine IDE zur schnellen Entwicklung und dem Debuggen von Anwendungen mit Caché.
  • Der Code der Skriptsprachen wird in der Datenbank gespeichert und kann online geändert werden, wobei die Änderungen automatisch an alle Applikationsserver weitergeleitet werden.

Die Caché Virtual Machine und Skriptsprachen

Im Zentrum des Caché-Applikationsservers steht die extrem schnelle Caché Virtual Machine, die die Skriptsprachen von Caché unterstützt.

  • Caché ObjectScript ist eine leistungsstarke und einfach zu erlernende objektorientierte Sprache mit extrem flexiblen Datenstrukturen.
  • Caché Basic erleichtert Visual Basic-Programmierern den Einstieg in Caché. Es ist VBScript ähnlich und verfügt über Erweiterungen, die den direkten Zugriff auf die multidimensionalen Arrays von Caché ermöglichen.
  • Caché MVBasic ist die Variante der Programmiersprache Basic, die in MultiValue (Pick-)Anwendungen verwendet wird. Das MVBasic von Caché wurde um Objektunterstützung erweitert und ermöglicht den direkten Zugriff auf die multidimensionalen Arrays von Caché.

In der Caché Virtual Machine ist der Datenbankzugriff hochoptimiert. Jeder Benutzerprozess kann hier direkt auf die multidimensionalen Datenstrukturen zugreifen, indem Aufrufe an den gemeinsamen Speicher abgesetzt werden, der wiederum auf einen gemeinsamen Datenbank-Cache zugreift. Alle anderen Technologien (Java, C++, ODBC, JDBC usw.) melden sich über die Caché Virtual Machine für den Zugriff auf die Datenbank an.

Umfassende Interoperabilität

Da Caché ObjectScript, Basic und MVBasic auf derselben Caché Virtual Machine implementiert sind, sind sie vollständig interoperabel:

  • Jede Objektmethode kann in einer beliebigen Sprache erstellt werden – in ein und derselben Klasse lassen sich alle drei Sprachen kombiniert einsetzen.
  • Jede Sprache kann Code aufrufen, der in den anderen Sprachen erstellt wurde.
  • Variablen, Arrays und Objekte werden gemeinsam genutzt.

Schnellere Entwicklung/flexible Bereitstellung

Indem Programmierer so viel Code wie möglich in den Skriptsprachen erstellen, beschleunigen sie in der Regel die Entwicklung von Anwendungen. Darüber hinaus laufen die Anwendungen schneller und sind höher skalierbar. Außerdem muss Code, der in Caché ObjectScript, Basic oder MVBasic geschrieben wurde, bei einem Wechsel der Hardwarekonfiguration oder des Betriebssystems nicht geändert werden. Caché sorgt automatisch für die Berücksichtigung aller Unterschiede bei Betriebssystem und Hardware.

Skriptsprachen

Vorteile mit Caché

Schnelle Anwendungsentwicklung: Mit Caché ObjectScript lassen sich komplexe Datenbankanwendungen bedeutend schneller entwickeln als in anderen verbreiteten Programmiersprachen – häufig 10 bis 100 Prozent schneller. Schnellere Entwicklung bedeutet auch, dass das Projekt höhere Erfolgschancen hat – mit weniger Programmierern – und sofort angepasst werden kann, wenn sich die Anforderungen ändern.

Kürzere Lernkurve: Basic ist wahrscheinlich die weltweit bekannteste Computersprache. Entwickler, die Visual Basic kennen, können sofort Code in Basic schreiben und das Objektmodell von Caché lässt sich schnell erlernen.

Schneller und höher skalierbar: Die Caché Virtual Machine mit ihrem direkten Zugriff auf die Datenbank führt zu schnelleren Anwendungen, deren Skalierung Zehntausende von Benutzern auch auf preiswerter Hardware ermöglicht.

Flexibilität: Code, der auf der Caché Virtual Machine läuft, kann unverändert auch auf anderer Hardware und anderen Betriebssystemen ausgeführt werden. Code wird in der Datenbank gespeichert und automatisch an die Applikationsserver weitergegeben.

Caché ObjectScript

Caché ObjectScript ist eine leistungsstarke objektorientierte Programmiersprache, zugeschnitten auf die schnelle Entwicklung von Datenbankanwendungen. Im Folgenden werden grundlegende Eigenschaften der Sprache erläutert.

Grundstruktur

Caché ObjectScript ist befehlsorientiert, wie folgende Syntax-Beispiele zeigen:

set x=a+b
do rotate(a,3)
if (x>3)

Es gibt eine Anzahl integrierter Systemfunktionen, die sich besonders für die Textbearbeitung eignen. Ihre Namen beginnen alle mit einem ‘$’-Zeichen, um sie von den Variablen- und Array-Namen zu unterscheiden. Zum Beispiel:

$extract(string,von,bis) // liefert bestimmte Zeichen aus einer Zeichenkette
$length(string) // bestimmt die Länge der Zeichenkette

Analog der Arbeitsweise der meisten Taschenrechner werden Ausdrücke streng von links nach rechts abgearbeitet, es sei denn, die Reihenfolge wird durch Klammern geändert.

Flexible Datenspeicherung

Caché ObjectScript zeichnet sich besonders durch die sehr flexible und dynamische Datenspeicherung aus. Daten können gespeichert werden als:

  • Objekteigenschaften
  • Variablen
  • multidimensionale Spares Arrays mit Subscripts beliebiger Datentypen
  • Datenbankelemente (“Globals”), d.h. persistente multidimensionale Sparse Arrays

Mit ganz wenigen Ausnahmen kann an jeder Stelle der Sprache anstelle einer Variable auch ein Array, eine Objekteigenschaft oder ein Global verwendet werden.

In den meisten Programmiersprachen sind Datentypen eine Erweiterung der Hardware-bezogenen Speicherkonzepte (Integer, Float, Char etc.). Caché ObjectScript geht dagegen von der Philosophie aus, dass Menschen nicht in solchen Kategorien zur Informationsspeicherung denken und deshalb solche computer-zentrierten Datentypen einer produktiven Anwendungsentwicklung ganz einfach im Weg stehen. Der Gebrauch von Deklarationen und Dimensionsanweisungen verursacht mehr Fehler, als er zu vermeiden hilft (man denke nur an den Überlauf eines 2-Byte-Integers oder an das mögliche Problem, dass eine Zeichenkette den zugewiesenen Speicher überschreitet und anderen Speicher damit beschädigt). Eine Objekttypisierung, wie z. B. „Person“, „Rechnung“ oder „Tier“ ist dagegen dem menschlichen Denken angemessen und intuitiv.

Deshalb werden in Caché ObjectScript Objekteigenschaften stark typisiert, die anderen drei Typen der Datenspeicherung (Variablen, Arrays und Globals) sind dagegen polymorphe, typenlose Entitäten, die keiner Deklaration oder Definition bedürfen. Sie treten ganz einfach dann in Erscheinung, wenn sie gebraucht werden, und nehmen genau die Form an, die für die Speicherung der jeweiligen Daten und die Verwendung in einem Ausdruck benötigt wird. Nicht einmal Arrays bedürfen einer Spezifikation hinsichtlich ihrer Größe und Dimension oder der Typen von Subscripts

und Daten. So könnte ein Entwickler ein Array „Person“ einfach folgendermaßen anlegen:

set Person("Schmid","Hans")="Ich bin ein netter Mensch"

In diesem Beispiel werden Daten in einem zweidimensionalen Array mit Strings als Subscripts gespeichert. Andere Datenknoten dieses Arrays könnten über mehr Dimensionen verfügen oder Strings, Integer-Werte und weitere Datentypen in den Subscripts mischen. Zum Beispiel könnten Daten so gespeichert werden:

abc(3)
abc(3,-45.6,”Ja”)
abc(”Zähler”)

Alle Daten werden im selben Array gespeichert.

Direkter Datenbankzugriff

accessEine direkte Referenz auf die Datenbank (eine „Global-Referenz“) ist im Grunde eine multidimensionale Array-Referenz, vor der das ‘^’-Zeichen steht. Dieses Zeichen gibt an, dass es sich um eine Referenz auf die in der Datenbank gespeicherten Daten handelt und nicht um die temporäre Verarbeitung lokaler Daten. Ein solches Datenbank-Array wird dann als “Global” bezeichnet.

Wie bei multidimensionalen Arrays und Variablen sind keine Deklarationen, Definitionen oder Speicherreservierungen erforderlich, um auf die Daten in der Datenbank zuzugreifen oder sie zu speichern. Global-Daten treten einfach in Erscheinung, wenn die Daten erstmals gespeichert werden. Um Informationen in der Datenbank zu speichern, könnte man beispielsweise Folgendes schreiben:

set ^Person("Schmid","Hans")="Ich bin ein sehr netter Mensch"

um es später mit Code wie dem folgenden wieder abzurufen:

set x=^Person("Schmid","Hans")

Der Programmierer ist bei der Strukturierung dieser Global-Daten-Arrays vollkommen frei.
(Siehe auch das multidimensionale Datenmodell.)

Objektreferenzen

Caché Objects implementieren das ODMG-Datenmodell mit einigen mächtigen Erweiterungen.

In Caché ObjectScript wird mit einer Objektreferenz (oref) auf ein Objekt zugegriffen (eine Objektreferenz ist inder Regel eine Variable, deren Wert angibt, auf welches Objekt im Speicher verwiesen wird). Auf die Objektreferenzfolgt ein Punkt und dann der Name der Eigenschaft oder der Methode. Objektreferenzen können immer anstellevon Ausdrücken verwendet werden. Ein Beispiel:

set name=person.Name
// 'person' ist eine Variable, deren Wert eine oref ist.
// Der Name der Person wird in die Variable 'name' geschrieben the variable 'name'

if (person.Alter>x)
// prüfe, ob das Alter der Person
// über 'x'liegt

set betrag=rechnung.summe()
// 'summe()' ist eine Methode, die die Summe
// alle Rechnungspositionen ermittelt.

Methoden können auch mit einem DO-Befehl ausgeführt werden, wenn kein Rückgabewert benötigt wird. Zum Beispiel:

do artikel.Erhöhe()
// 'Erhöhe()' ist eine Methode deren
// falls vorhanden,
// nicht relevant ist.

Man darf die Objektreferenz (oref) nicht mit der Objekt-ID verwechseln. Die Objekt-ID ist ein Wert, der einem Datenbankobjekt fest zugeordnet ist. Sie dient zum Abruf und zur Speicherung eines Datenbankobjekts. Befindet sich ein Objekt im Speicher, wird ihm ein wiederverwendbarer Objektreferenzwert zugewiesen, mit dem man dann auf die Objektdaten zugreift. Wenn dasselbe Datenbankobjekt das nächste Mal in den Speicher geladen wird, wird ihm höchstwahrscheinlich eine andere Objektreferenz zugewiesen.

HTML- und SQL-Zugriff

In Caché ObjectScript-Code kannt HTML für Web-Anwendungen sowie SQL eingebettet werden.

Code aufrufen

In einigen objektorientierten Sprachen muss der gesamte Code immer Teil einer Methode sein. Caché ObjectScript verzichtet auf diese Einschränkung – Code kann direkt oder über die Objektsyntax aufgerufen werden.

Code wird häufig mit dem DO-Befehl aufgerufen.

do rotate(a,3)

Code, der einen Wert liefert, kann auch als Funktion aufgerufen werden. Ein Beispiel:

set x=a+$$insert(3,y)

ruft die vom Programmierer erstellte Prozedur oder Subroutine „insert“ auf.

Code kann auch als Objektmethode aufgerufen werden.

set betrag=rechnung.summe()
// summe() liefert den
// Gesamtbetrag der Rechnung
do artikel.Erhöhe()
// 'Erhöhe()' ist eine Methode
// deren Rückgabewert,
// falls vorhanden, nicht relevant ist

Für Parameter wird sowohl die Übergabe von Werten (Call by Value) wie auch die Übergabe von Referenzen (Call by Reference) unterstützt.

Routinen

Mit Caché ObjectScript erstellter Code wird prinzipiell in „Routinen“ organisiert. Jede Routine bildet eine elementare Einheit und kann unabhängig von anderen Routinen editiert, gespeichert, kompiliert und ausgeführt werden. Die Verknüpfung von Routinen erfolgt dynamisch zur Laufzeit; Programmierer müssen sich nicht zusätzlich darum kümmern. Der Code von Routinen ist in der Datenbank gespeichert; so können sie dynamisch im gesamten Netzwerk aufgerufen werden und müssen nicht auf jedem einzelnen Rechner installiert werden.

Der Code einer Routine wiederum ist als ein Satz von Prozeduren und/oder Subroutinen aufgebaut. (Eine Objektmethode ist ebenfalls eine Prozedur, auf sie wird aber über eine spezielle Syntax zugegriffen.)

Beim Aufruf von Code, der sich in der gleichen Routine befindet, wird nur der Name der Prozedur oder der Subroutine benötigt. Anderenfalls muss der Routinenname angehängt werden.

do transfer()
// ruft 'transfer' in
// derselben Routine auf
do summe^rechnung()
// ruft 'summe' in der
// Routine "rechnung" auf

Ist der zurückgegebene Wert einer Prozedur oder einer Subroutine relevant, sollte der Aufruf über die Funktionssyntax „$$“ erfolgen.

set x=$$summe^rechnung()
// ruft die gleiche Prozedur
// 'summe' auf,
// verwendet aber den Rückgabewert

Routinen können in Caché Studio bearbeitet und kompiliert werden.

Objektmethoden

Klassendefinitionen und deren Methoden-Code werden in Globals gespeichert; der Class Compiler kompiliert dann jede Klasse in eine oder mehrere Routinen. Jede Methode ist einfach eine Prozedur in einer Routine, obwohl sie nur über die Objektsyntax aufgerufen werden kann. Wenn die Klasse „Patient“ beispielsweise eine Methode „Aufnahme“ definiert und die Variable „Pat“ eine Referenz auf ein konkretes Objekt „Patient“ darstellt, dann rufen wir die Methode „Aufnahme“ für dieses Objekt mit der folgenden Syntax auf:

do Pat.Aufnahme()
// Aufruf der Methode
// Aufnahme für Patient
set x = Pat.Aufnahme()
// Ruft die gleiche Methode auf,
// verwendet aber den Rückgabewert

Prozeduren und öffentliche bzw. private Variablen

Eine Prozedur ist ein Code-Block in einer Routine und entspricht in etwa einer Funktion in anderen Programmiersprachen. Prozeduren bestehen aus einem Namen, einer Liste von formalen Parametern, einer Liste von öffentlichen Variablen und einem Code-Block, der durch ‘{}’ begrenzt wird. Zum Beispiel:

Aufnahme(x,y)[name,pid] { ...hier folgt der Code}

In Caché ObjectScript sind Variablen entweder öffentlich (allgemein verfügbar) oder nur innerhalb einer bestimmten Prozedur sichtbar, also privat. Jede in einer Prozedur verwendete Variable wird als privat für diese Prozedur betrachtet, sofern sie nicht in der öffentlichen Liste aufgeführt wird. Im obigen Beispiel sind „name“ und „pid“ öffentliche Variablen, wohingegen alle anderen Variablen nur während der Ausführung dieser Prozedur existieren. Variablennamen, die mit dem Prozentzeichen ‘%’ beginnen, sind implizit öffentlich.

Prozeduren können nicht verschachtelt werden, aber eine Prozedur kann Subroutinen enthalten.

Subroutinen

Routinen können auch Subroutinen enthalten, die weniger strikt als Prozeduren sind. Eine Subroutine kann eine Parameterliste enthalten und einen Wert zurückgeben. Sie hat aber keine Public-Liste und keine formale Blockstruktur. Subroutinen können in Prozeduren eingebettet werden oder sich auf der gleichen Ebene wie eine Prozedur in einer Routine befinden.

Subroutinen erlauben den Aufruf von Code mit der gleichen öffentlichen/privaten Variablenmenge wie das aufrufende Programm, und sie können schneller aufgerufen werden als Prozeduren. Eine Subroutine, die in einer Prozedur eingebettet ist, verwendet denselben Variablenbereich wie die Prozedur und kann nur innerhalb dieser Prozedur aufgerufen werden. Variablenreferenzen einer Subroutine, die nicht zu einer Prozedur gehören, verweisen alle auf öffentliche Variablen.

Basic

56501510_11_smBasic ist wahrscheinlich die weltweit bekannteste Sprache zur Anwendungsentwicklung. In Caché wurde Basic um den direkten Zugriff auf die zentralen Datenstrukturen – die multidimensionalen Arrays – des Datenservers wie auch um andere Funktionen des Applikationsservers von Caché erweitert. Es unterstützt direkt das Objektmodell von Caché über die Syntax von Visual Basic und läuft in der Caché Virtual Machine.

Basic kann entweder in Form von Klassenmethoden oder als Caché-Routinen zum Einsatz kommen (vgl. die Beschreibung der Routinen von Caché ObjectScript). Basic kann Caché ObjectScript aufrufen und umgekehrt, wobei beide Sprachen auf die gleichen Variablen, Arrays und Objekte im Prozessspeicher zugreifen.

Die Funktionsweise von Arrays wurde erheblich erweitert:

  • Steht vor dem Array-Namen das ^-Zeichen, so weist dies auf eine Referenz auf ein multidimensionales Datenbank-Array hin – solche persistenten Arrays oder „Globals“ werden mit anderen Prozessen gemeinsam genutzt.
  • Die Datentypen von Subscripts können frei gewählt werden – Strings, Integer, Dezimalzahlen usw.
  • Daten können auf mehreren Subscript-Ebenen im selben Array gespeichert werden – beispielsweise unter A(“Farben”) und A(“Farben”,3).
  • Arrays müssen nicht deklariert werden und sind immer sogenannte Sparse Arrays, für die Caché nur dann Platz reserviert, wenn Knoten eingefügt werden.
  • Die Funktion „Traverse“ erlaubt die Ermittlung des nächsten (oder vorherigen) Subscripts auf einer bestimmten Subscript-Ebene.

Zu den Erweiterungen gehören darüber hinaus:

  • Transaktionsverarbeitungsbefehle, um eine Transaktion zu starten (Start), festzuschreiben (Commit) und zurückzurollen (Rollback).
  • Eine atomare Inkrementierungsfunktion, die auf die Datenbank angewendet werden kann.
  • Erweiterungen, die eine bessere Integration in die Applikationsserver-Funktionalitäten von Caché ermöglichen.
Objektzugriff mit Basic

In Caché werden Klassen in Packages strukturiert und die Klassennamen beinhalten den Package-Namen gefolgt von einem Punkt. So ist beispielsweise „Lohnbuchhaltung.Person“ die Klasse „Person“ des Packages „Lohnbuchhaltung“:

person = New Lohnbuchhaltung.Person()
// Erstellt ein neues
// Objekt "Person"

Um auf ein bestehendes Objekt zugreifen zu können, wurde Basic um einen OpenID-Befehl erweitert:

person = OpenID Lohnbuchhaltung.Person(54)
// Öffnet das Objekt
// "Person" mit der
// Objekt-ID 54

Hier einige Code-Beispiele, die auf die Eigenschaften von “Person” zugreifen:

person.Name = "Schmid, Hans"
// Legt den Namen der Person fest

Person.Privatanschrift.Ort
// Gibt den Wohnort
// der Person an

person.Arbeitgeber.Name
// Holt das Objekt
// "Arbeitgeber" der Person
// und greift auf den Namen
// des Arbeitgebers zu

Datenbankklassen können mit der Methode „Save“ auf Festplatte gespeichert werden:

person.Save()

speichert beispielsweise eine Person. Falls das Objekt das erste Mal gespeichert wird, wird eine Objekt-ID vergeben. Geänderte verknüpfte Objekte (wie „Arbeitgeber“) werden ebenfalls automatisch gespeichert.

2People-on-cubes

MVBasic

MVBasic, eine Basic-Variante, ist eine weitere Skriptsprache von Caché. Sie ist zur Ausführung von Anwendungen gedacht, die für MultiValue (Pick-)Systeme erstellt wurden, und unterstützt daher zusätzliche Funktionalität, einschließlich solcher, um auf MultiValue-Dateien zugreifen und diese bearbeiten zu können.

MVBasic kann entweder in Form von Klassenmethoden oder als Caché-Routinen zum Einsatz kommen (vgl. die Beschreibung der Routinen von Caché ObjectScript). MVBasic kann Caché ObjectScript oder Basic aufrufen und umgekehrt, wobei alle drei Sprachen auf die gleichen Variablen, Arrays und Objekte im Prozessspeicher zugreifen.

Caché MVBasic weist dieselben Erweiterungen wie Caché Basic einschließlich  des Objektzugriffs auf. Aufgrund der möglichen Mehrdeutigkeit wird aber in Objektreferenzen die Zeichenfolge “->“ anstelle des Punkttrennzeichens “.“ verwendet.

C++

Jede Caché-Klasse kann als C++-Klasse projiziert werden, wobei die Methoden den einzelnen Eigenschaften und Methoden der Caché-Klasse entsprechen. Für C++-Programme sehen diese Klassen wie jede andere lokale C++-Klasse aus. Caché sorgt automatisch für die gesamte Kommunikation zwischen Client und Server. Die Objekteigenschaften werden auf dem Client im Cache zwischengespeichert. C++-Methodenaufrufe rufen die entsprechenden Methoden auf der Server-Seite auf – einschließlich Methoden, um ein Objekt in der Datenbank zu speichern und es später wieder aufzurufen.

Caché verfügt zudem über die Technologie Caché eXTreme für C++. Dies ist eine leichte Anbindung („light binding“) die C++ ermöglicht, Objekte direkt in Cachés multidimensionalen Datenspeicher zu schreiben, was zu extrem hohen Performanceraten führt.

Java

100032-199Die objektorientierte Programmiersprache Java ist populär. Die Vielseitigkeit, die sich hinter ihrem „Write once, deploy anywhere“-Ansatz verbirgt, bedeutet aber zugleich, dass sie nicht spezifiziert, wie Daten in eine Datenbank geschrieben oder von dort gelesen werden. Sollen Daten persistiert werden, ist es Aufgabe des Java-Entwicklers, eine Methode des Datenzugriffs zu wählen und zu implementieren.

Caché unterstützt verschiedene Methoden, wie Java-Applikationen auf eine Caché-Datenbank zugreifen können:

  • JDBC bietet einen High-Performance-SQL-Zugriff durch einen vollständig Java-basierten (Typ 4) Treiber.
  • Jede Caché-Klasse kann als Java-Klasse projiziert werden, so dass auf die Eigenschaften und Methoden als Java-Objekte zugegriffen werden kann.
  • Mit Jalapeño verfügt InterSystems über eine Technologie, mit der Caché-Klassen aus vorhandenen Java-Klassenbeschreibungen erstellt werden können. Caché liefert automatisch die Methoden, um Objekte in der Datenbank zu speichern oder auf diese zuzugreifen, ohne dabei die vom Entwickler geschaffenen Klassen zu beeinflussen.
  • Caché eXTreme for Java erlaubt den Zugriff auf Daten in Caché via JNI (Java Native Interface)
  • Java Persistent API (JPA) ist sowohl per Hibernate- als auch EclipseLink-Implementierung umgesetzt, um Standard Java EE Persistence zu ermöglichen.

Caché eXTreme for Java

Caché eXTreme for Java eröffnet die Möglichkeit, auf die Elemente in Caché, die für unternehmenskritische Aspekte und höchste Performance zuständig sind, via JNI (Java Native Interface) zuzugreifen. Das führt zu “in-process”-Kommunikation zwischen Java und Caché, die sich durch extrem kleine Latenzzeiten bei der Speicherung und dem Abrufen von Daten auszeichnet.

Caché eXTreme for Java gibt Entwicklern ein Java API (Application Programming Interface), das in-process-Kommunikation für nachfolgende Aspekte ermöglicht:

  • Speichern und Abfragen relationaler Daten via JDBC (JDBC over JNI)
  • Speichern und Abragen von Java-Objekten
  • Speichern und Abfragen von multidimensionalen Daten

Die Option der Globals API gewährt Java-Entwicklern direkten Zugriff auf Cachés effiziente, multidimensionale Datenstruktur.

Caché eXTreme for Java Architektur

Die Vorteile mit Caché

Extrem hohe Performance einschließlich Persistenz: Caché eXTreme for Java beschleunigt Datenbank-I/O für Java-Anwendungen. Dieser Vorteil kommt insbesondere dann zum Tragen, wenn Java-Applikationen geschrieben oder erweitert werden, die mit Streaming Data, extrem großen Datenmengen oder sich sehr schnell verändernden Daten zu tun haben.

Verschiedenste Modi des Datenzugriffs: Caché eXTreme for Java liefert blitzschnelle “in-process”-Kommunikation zwischen Java und Caché via JDBC, Objektzugriff oder direktem multidimensionalem Zugang.

Kurze Lernkurve: Caché eXTreme for Java verwendet Java-Standards für den Zugriff auf die Datenbank, was dazu führt, dass Entwickler überwiegend innerhalb ihrer Java-Umgebung arbeiten können. Üblicherweise kann ein Java-Entwickler mit einem Jahr Programmiererfahrung schon nach ein paar Tagen Caché eXTreme produktiv einsetzen.

Persistenz für Java-basierende CEP-Applikationen möglich

Die überwiegende Anzahl von Applikationen für CEP (Complex Event Processing) kann persistente Datenbanken gar nicht nutzen, da die Latenzzeiten, um Daten auf die Festplatten zu schreiben oder von dort abzurufen, schlicht zu groß sind. Stattdessen verwenden sie üblicherweise In-Memory-Datenbanken und gehen dabei bewusst das Risiko ein, Daten oder Transaktionen zu verlieren. Mit Caché eXTreme for Java können Java-basierende CEP-Anwendungen nun Daten persistieren, ohne dafür bei der Performance Abstriche machen zu müssen.

Caché and .NET

Dank seines offenen und flexiblen Datenzugriffs arbeitet Caché nahtlos mit .NET zusammen. Es gibt viele Möglichkeiten, die beiden Systeme zu verbinden, SQL, XML und SOAP eingeschlossen. Entwickler können Anwendungen mit den von ihnen bevorzugten Technologien erstellen. Alle profitieren von der überlegenen Performance und Skalierbarkei von Caché.

ADO.NET

ADO.NET ist die neue Inkarnation von ADO, die für den Einsatz im .NET Framework optimiert ist. Es soll .NET-Anwendungen „datenbankunabhängig“ machen und verwendet in der Regel SQL zur Kommunikation mit Datenbanken. Über den relationalen Datenzugriff unterstützt Caché ADO.NET auf native Weise. Ebenso unterstützt es ODBC.NET von Microsoft und die Read-only SOAP-Konnektivität, die in ADO.NET integriert ist.

Web Services

.NET kennt zwei Möglichkeiten, Web Services zu nutzen. Die eine besteht darin, XML-Dokumente über HTTP zu senden. Die andere Möglichkeit ist, das SOAP-Protokoll zur Vereinfachung des Austauschs von XMLDokumenten zu nutzen. Caché unterstützt beide Darstellungsformen für Daten und kann somit nahtlos mit den Web Services von .NET zusammenarbeiten.

Caché Managed Objects

Caché kann automatisch .NET-Assemblies (oder C#-Quellcode) aus Caché-Klassen erstellen. Ein Plug-in für Visual Studio ermöglicht Entwicklern, die diese Umgebung bevorzugen, den einfachen Zugriff auf Caché-Objekte.

Vorteile mit Caché

Schnelle Datenbereitstellung: Web-Anwendungen, die Caché als Datenserver einsetzen, profitieren von der hohen Performance und der massiven Skalierbarkeit der multidimensionalen Daten-Engine von Caché.

Schnellere .NET-Entwicklung: Die Entwickler sind produktiver, wenn sie mit ihren bevorzugten Werkzeugen in vertrauter Umgebung arbeiten können. Durch die Bereitstellung des Datenzugriffs sowohl über SQL als auch über Objekte  unterstützt Caché einen Großteil der gängigen Entwicklungstechniken und -werkzeuge.

Caché und XML

Ähnlich wie HTML eine Internet-kompatible Markup-Sprache zur Anzeige von Daten in einem Browser ist, ist XML eine Markup-Sprache für den Austausch von Daten zwischen Anwendungen. Die Struktur von XML-Daten ist hierarchisch und multidimensional, so dass sie sich ideal zum Einsatz mit der multidimensionalen Daten-Engine von Caché eignet.

Export von XML

Damit eine Caché-Klasse kompatibel zu XML wird, muss sie lediglich von der Klasse „%XMLAdaptor“ erben, die in Caché enthalten ist. Diese stellt alle Methoden bereit, die benötigt werden, um:

  • entweder eine DTD (Document Type Definition) oder ein XML-Schema für die Klasse zu erstellen. DTDs und Schemata werden von Caché automatisch erzeugt. Die XML-Darstellung einer Klasse lässt sich aber auch vom Entwickler anpassen.
  • Daten (Instanzen der Klasse) automatisch gemäß der definierten DTD oder des Schemas als XML zu formatieren.

Import von XML

Caché enthält auch Klassen, mit deren Methoden Entwickler:

  • XML-Schemata importieren und automatisch die entsprechenden Caché-Klassen erstellen können.
  • über ein einfaches API die in XML-Dokumenten enthaltenen Daten als Instanzen (Objekte) von Caché-Klassen importieren können.
  • XML-Dokumente mit dem integrierten XML-(SAX-)Parser parsen und validieren können.

Caché und Web Services

rainbow-fpo_smWeb Services ermöglichen die gemeinsame Nutzung von Anwendungsfunktionalität über das Internet, aber auch innerhalb einer Organisation oder eines Systems. Web Services verfügen über eine Schnittstelle, die in WSDL (Web Service Definition Language) beschrieben ist, und liefern in einem „Umschlag“ ein XML-Dokument, das in der Regel gemäß dem SOAP-Protokoll (Simple Object Access Protocol) formatiert ist.

Eine bestehende Caché-Klasse kann einfach, indem sie von der geeigneten System-Level-Klasse in Caché erbt, als Web Service gekennzeichnet werden. Es gibt zudem einen Web Service Wizard, um neue Web Services mit ein paar Mausklicks zu generieren. In beiden Fällen wird Caché, sobald der Web Service kompiliert ist, die erforderliche WSDL-Beschreibung für den Service generieren und auch den benötigten „Umschlag“ erstellen und formatieren. Darüber hinaus vereinfacht Caché die schnelle Anwendungsentwicklung, indem automatisch eine Webseite erzeugt wird, um den Service zu testen, ohne dass eine Client-Anwendung erstellt werden muss.

Vorteile von Caché

Einfache Konnektivität zu XML: Caché nutzt Mehrfachvererbung zur Bereitstellung einer bidirektionalen Schnittstelle zu XML für jede beliebige Caché-Klasse. Das Ergebnis: Caché-Klassen können einfach und schnell in XML-Dokumente und -Schemata umgewandelt werden. Ebenso können XML-Schemata und Dokumente in Caché-Klassendefinitionen und Objekte umgewandelt werden.

Web Services auf Knopfdruck: Jede Caché-Methode kann mit wenigen Mausklicks auch als Web Service veröffentlicht werden. Caché erzeugt automatisch die WSDL-Beschreibung und den SOAP-formatierten Umschlag.

Sichere Web Services: Caché verfügt über Möglichkeiten, die es einfach machen, die Integrität und Vertraulichkeit von Web Services sicherzustellen. Durch die Verwendung des WS-Policy Frameworks wird die Aufgabe, Web Services sicher zu machen, wesentlich vereinfacht.

Beschleunigte Entwicklung schneller XML-Anwendungen: Da die nativen multidimensionalen Datenstrukturen von Caché sehr gut zu XML-Dokumenten passen, müssen Entwickler keine manuelle Übersetzung zwischen XML und der Datenbank codieren. Und der geringere Verarbeitungsaufwand sorgt für einen schnelleren Ablauf der Anwendungen.

Web Services absichern

Web Services stehen stellvertretend für Daten im Transit („data in motion“) und können durchaus aus „unbekannten“ Quellen stammen. Daher erfordern sie besondere Sicherungsmaßnahmen.

Caché unterstützt den Einsatz von SSL und TSL, um Verbindungen abzusichern. Was den Web Service selbst betrifft, sollten die Informationen innerhalb des Umschlags des Services den Empfänger in die Lage versetzen zu verifizieren, woher der Web Service stammt, dass auf dem Weg keine Manipulation stattgefunden hat und schlussendlich den Inhalt zu entschlüsseln.

Caché beherrscht eine Vielzahl der Funktionen, wie sie in den WS-Security-Spezifikationen der OASiSOpen Standards-Organisation veröffentlicht wurden:

  • WS-Security Header
    • Stellt die Nachrichtenintegrität sicher

Der Security Header wird dem Header einer SOAP-Nachricht hinzugefügt. Er enthält alle sicherheitsrelevanten Informationen in Bezug auf die Nachricht, einschließlich der Tokens(Benutzername, Binary Security, Zeitstempel), Signatur-Elemente und die zur Verschlüsselung zentralen Nachrichtenelemente.

  • XML Signature List
    • Stellt die Nachrichtenintegrität sicher

Ermöglicht zu verifizieren, woher ein Web Service stammt

  • WS-Security Token Support
    • Benutzernamen-Tokens

Ermöglichen die Identitätsprüfung gegenüber Web Services, die nach einer Authentifizierung verlangen

    • Benutzernamen-Tokens

Werden als Referenz für Signaturen oder zur Verschlüsselung zentraler Nachrichtenelemente verwendet

  • XML Verschlüsselung: Sorgt für Geheimhaltung bei der Nachrichten

Sichere Einstellungen für Web services

Um die Sicherheitseinstellungen für Web Services einfacher zu konfigurieren und zu verwalten, nutzt Caché das vom W3C (World Wide Web Consortium) entworfene WS-Policy Framework. Es gibt einen Wizard, der Anwendungsentwickler darin unterstützt, die WS-Policy effizient umzusetzen. Er bietet verschiedenste Optionen, um die Details der Regeln festzulegen.

SOAP Log

Es ist häufig von Vorteil, SOAP-Nachrichten zu protokollieren oder nachzuverfolgen, um zu „sehen“ was gesendet wurde. Das Caché SOAP-Log kann (falls gewünscht) eingehende und ausgehende Nachrichten sowie die Sicherheitsinformationen erfassen.

Caché und MultiValue

Caché enthält die gesamte Funktionalität, die zur Entwicklung und Ausführung von MultiValue-Anwendungen (manchmal auch als Pick-Anwendungen bezeichnet) erforderlich ist, einschließlich der MultiValue-Elemente:

  • Sprache MVBasic: 
  • Dateizugriff

Auf MultiValue-Dateien kann mit MultiValue-Programmen über normale READ/WRITE-Befehle und MultiValue-Abfragen zugegriffen werden. Auf sie kann über MVBasic und ebenso die anderen Sprachen zugegriffen werden. Alle normalen Mechanismen von Caché stehen zur Verfügung – einschließlich dem objektorientierten Zugriff, dem direkten Zugriff über multidimensionale Arrays und dem SQL-Zugriff.

  • Abfragesprache

Die Caché MultiValue Query Language (CMQL) sorgt sowohl für die Datenauswahl als auch die Listenformatierung für Multi- Value-Dateien. Da diese Abfragen von der hochperformanten SQL-Engine von Caché ausgeführt werden, wird die Zuverlässigkeit erhöht, die Ausführung optimiert und es stehen sämtliche ausgeklügelten Indexmechanismen von Caché zur Verfügung.

  • Data dictionary (7- und 10-Zeilen Strukturen)

Eine MultiValue-Datei kann eine entsprechende Dateibeschreibung im MultiValue Data Dictionary haben, die über MVBasic- Code und den gewohnten MultiValue „ED“-Editor direkt bearbeitet werden kann. Jede MultiValue-Datei kann auch über eine entsprechende Caché-Klassendefinition verfügen. Nötig ist eine solche Klassendefinition, wenn mit den Daten über den Objektoder SQL-Zugriff gearbeitet werden soll.

  • Procs, Paragraphs, und Phrases
  • Command shell

Die MultiValue Command Shell kann in einer Terminal-Umgebung ausgeführt werden. Zusätzlich zu den normalen MultiValue Command Shell-Funktionen ermöglicht Caché, dass MVBasic- Befehle direkt in der Command Shell ausgeführt werden.

Diese MultiValue-Funktionalität ist ein integraler Bestandteil von Caché und keine separate MultiValue-Implementierung. Sie setzt auf der multidimensionalen Daten-Engine, der Laufzeitfunktionalität und den Entwicklungstechnologien von Caché auf. Dies bedeutet, dass MultiValue- Benutzer die gesamte Funktionalität von Caché hundertprozentig nutzen können.

Vorteile mit Caché

Neues Leben für alte Anwendungen: Mit Caché ist es ein Leichtes, ältere MultiValue-Anwendungen mit Browser-basierten Benutzeroberflächen, objektorientiertem Zugriff, robustem SQL oder Web Services zu modernisieren. MultiValue-Anwendungen erhalten eine stabile Basis durch eine moderne Datenbank, die in heutigen anspruchsvollen Umgebungen gut akzeptiert ist und ständig weiterentwickelt wird.

Neue Anwendungen schnell erstellen: Da MultiValue in Caché als zusätzliche Skriptsprache und Dateizugriff implementiert ist, stehen alle nativen Funktionen von Caché zur Verfügung, um schnell neue Funktionalität zu definieren. MultiValue-Programmierer können die Vorteile der objektorientierten Programmierung nutzen und einfach mit anderen Anwendungen interagieren, während sie weiterhin mit MVBasic arbeiten.

Hohe Performance und Skalierbarkeit mit außergewöhnlicher Zuverlässigkeit für MultiValue Anwender: Caché bietet MultiValue-Anwendern eine signifikant höhere Performance und Skalierbarkeit. Darüber hinaus ist Caché für kritische Umgebungen ausgelegt, bei denen die Verfügbarkeit rund um die Uhr gewährleistet sein muss und Ausfälle nicht akzeptabel sind. Caché bietet ausgefeiltes Journaling, Transaktionsverarbeitung, eine ausfallsichere Datenbank und fehlertolerante Konfigurationen.

Applikationen nach Caché migrieren

Caché verfügt über Funktionen und Hilfsprogramme, die bei der Migration bestehender Anwendungen von einer ganzen Reihe von Technologien nach Caché helfen. So bleiben bestehende Daten erhalten und bestehender Code wird effizient genutzt, während gleichzeitig Performance, Skalierbarkeit und die fortschrittlichen Fähigkeiten von Caché zur Verfügung stehen.

Migration von relationalen Technologien

Caché verfügt über eine spezialisierte Implementierung von SQL, um bei der Portierung von Anwendungen aus folgenden Technologien zu helfen:

  • Microsoft SQL Server und Sybase Adaptive Server

Caché TSQL ist eine Implementierung von Transact-SQL. Sie unterstützt viele der Funktionen sowohl von Microsoft- als auch von Sybase-Implementierungen.

  • Informix

Caché ISQL ist eine Implementierung von Informix ISQL. Sie unterstützt viele Informix ISQL-Merkmale.

Caché verfügt auf Systemebene über Klassen für den Import und die Kompilierung von DDL, DML und Stored Procedures. Zudem gibt es einen Data Migration Wizard für den Import bestehender Daten in Caché.

Migration von MultiValue Technologien

Caché unterstützt die Migration von allen populären MultiValue-Umgebungen einschließlich Niverse, Unidata, JBASE, D3 und Reality.

  • Cachés multidimensionale Arrays (Globals) sind Oberklassen der MultiValue-Dateien, was es einfach macht, bestehende Daten und Schemata von MultiValue nach Caché zu migrieren.Caché MVBasic ist eine hochoptimierte Implementierung der Programmiersprache Basic, wie sie in MultiValue-Anwendungen verwendet wird. Unterschiedlichen Dialekten wird mittels Emulationsweichen Rechnung getragen, was die Code-Anpassungen bei einer Migration minimiert
  • Mit CMQL bietet Caché eine Abfragesprache für MultiValue, die von vornherein ein Teil der hoch- optimierten SQL-Abfrage-Engine ist

Die Vorteile mit Caché

Einfachere Migrationen: Werkzeuge und Wizards machen die Migration von relationalen oder MultiValue-Technologien so einfach wie möglich.

Bessere Performance: Caché-basierende Anwendungen haben gezeigt, dass sie SQL bis zu fünfmal schneller ausführen können als Anwendungen auf Basis relationaler Technologien.

Mehr Optionen für zukünftige Entwicklungen: Sobald die Migration abgeschlossen ist, kann die Verbesserung der Applikation unter Verwendung aller Möglichkeiten von Caché erfolgen, einschließlich der Technologien InterSystems Zen™ und iKnow, objektorientierter Entwicklung und vielem mehr.

Verbesserte Skalierbarkeit, Sicherheit und Belastbarkeit: Caché-basierende Anwendungen profitieren von Fähigkeiten wie dem Enterprise Cache Protocol (ECP), dem Caché Security Model und Mirroring.