Adaptive Server® Anywhere Handbuch für Programmierer - Sybase

Adaptive Server® Anywhere
Handbuch für Programmierer
Stand: Oktober 2002
Bestellnummer: 03946-01-0802-01

Copyright © 1989–2002 Sybase, Inc. Teil-Copyright © 2002 iAnywhere Solutions, Inc. Alle Rechte vorbehalten.
Diese Publikation darf ohne vorheriges schriftliches Einverständnis der iAnywhere Solutions, Inc. weder ganz noch teilweise, weder elektronisch,
mechanisch, manuell, optisch, noch auf sonst eine Weise reproduziert, übertragen oder übersetzt werden. iAnywhere Solutions, Inc ist eine
Tochtergesellschaft der Sybase Inc.
Sybase, das SYBASE-Logo, AccelaTrade, ADA Workbench, Adaptable Windowing Environment, Adaptive Component Architecture, Adaptive
Server, Adaptive Server Anywhere, Adaptive Server Enterprise, Adaptive Server Enterprise Monitor, Adaptive Server Enterprise Replication,
Adaptive Server Everywhere, Adaptive Server IQ, Adaptive Warehouse, AnswerBase, Anywhere Studio, Application Manager, AppModeler,
APT Workbench, APT-Build, APT-Edit, APT-Execute, APT-FORMS, APT-Library, APT-Translator, ASEP, Backup Server, BayCam, Bit-Wise,
BizTracker, Certified PowerBuilder Developer, Certified SYBASE Professional, Certified SYBASE Professional (Logo), ClearConnect, Client
Services, Client-Library, CodeBank, Column Design, ComponentPack, Connection Manager, Convoy/DM, Copernicus, CSP, Data Pipeline, Data
Workbench, DataArchitect, Database Analyzer, DataExpress, DataServer, DataWindow, DB-Library, dbQueue, Developers Workbench, Direct
Connect Anywhere, DirectConnect, Distribution Director, Dynamo, e-ADK, E-Anywhere, e-Biz Integrator, E-Whatever, EC-GATEWAY, ECMAP,
ECRTP, eFulfillment Accelerator, Electronic Case Management, Embedded SQL, EMS, Enterprise Application Studio, Enterprise Client/Server,
Enterprise Connect, Enterprise Data Studio, Enterprise Manager, Enterprise SQL Server Manager, Enterprise Work Architecture, Enterprise Work
Designer, Enterprise Work Modeler, eProcurement Accelerator, eremote, Everything Works Better When Everything Works Together, EWA,
Financial Fusion, Financial Fusion Server, First Impression, Formula One, Gateway Manager, GeoPoint, iAnywhere, iAnywhere Solutions,
ImpactNow, Industry Warehouse Studio, InfoMaker, Information Anywhere, Information Everywhere, InformationConnect, InstaHelp, Intellidex,
InternetBuilder, iremote, iScript, Jaguar CTS, jConnect for JDBC, KnowledgeBase, Logical Memory Manager, MainframeConnect, Maintenance
Express, MAP, MDI Access Server, MDI Database Gateway, media.splash, MetaWorks, MethodSet, ML Query, MobiCATS, MySupport,
Net-Gateway, Net-Library, New Era of Networks, Next Generation Learning, Next Generation Learning Studio, O DEVICE, OASiS, OASiS (logo),
ObjectConnect, ObjectCycle, OmniConnect, OmniSQL Access Module, OmniSQL Toolkit, Open Biz, Open Business Interchange, Open Client,
Open Client/Server, Open Client/Server Interfaces, Open ClientConnect, Open Gateway, Open Server, Open ServerConnect, Open Solutions,
Optima++, Partnerships that Work, PB-Gen, PC APT Execute, PC DB-Net, PC Net Library, PhysicalArchitect, Pocket PowerBuilder,
PocketBuilder, Power Through Knowledge, Power++, power.stop, PowerAMC, PowerBuilder, PowerBuilder Foundation Class Library,
PowerDesigner, PowerDimensions, PowerDynamo, Powering the New Economy, PowerJ, PowerScript, PowerSite, PowerSocket, Powersoft,
Powersoft Portfolio, Powersoft Professional, PowerStage, PowerStudio, PowerTips, PowerWare Desktop, PowerWare Enterprise, ProcessAnalyst,
Rapport, Relational Beans, Replication Agent, Replication Driver, Replication Server, Replication Server Manager, Replication Toolkit, Report
Workbench, Report-Execute, Resource Manager, RW-DisplayLib, RW-Library, S Designor, S-Designor, S.W.I.F.T. Message Format Libraries,
SAFE, SAFE/PRO, SDF, Secure SQL Server, Secure SQL Toolset, Security Guardian, SKILS, smart.partners, smart.parts, smart.script,
SQL Advantage, SQL Anywhere, SQL Anywhere Studio, SQL Code Checker, SQL Debug, SQL Edit, SQL Edit/TPU, SQL Everywhere,
SQL Modeler, SQL Remote, SQL Server, SQL Server Manager, SQL Server SNMP SubAgent, SQL Server/CFT, SQL Server/DBM, SQL SMART,
SQL Station, SQL Toolset, SQLJ, Stage III Engineering, Startup.Com, STEP, SupportNow, Sybase Central, Sybase Client/Server Interfaces, Sybase
Development Framework, Sybase Financial Server, Sybase Gateways, Sybase Learning Connection, Sybase MPP, Sybase SQL Desktop, Sybase
SQL Lifecycle, Sybase SQL Workgroup, Sybase Synergy Program, Sybase User Workbench, Sybase Virtual Server Architecture, SybaseWare,
Syber Financial, SyberAssist, SybMD, SyBooks, System 10, System 11, System XI (Logo), SystemTools, Tabular Data Stream, The Enterprise
Client/Server Company, The Extensible Software Platform, The Future Is Wide Open, The Learning Connection, The Model For Client/Server
Solutions, The Online Information Center, The Power of One, TradeForce, Transact-SQL, Translation Toolkit, Turning Imagination Into Reality,
UltraLite, UNIBOM, Unilib, Uninull, Unisep, Unistring, URK Runtime Kit for UniCode, Viewer, Visual Components, VisualSpeller, VisualWriter,
VQL, Warehouse Control Center, Warehouse Studio, Warehouse WORKS, WarehouseArchitect, Watcom, Watcom SQL, Watcom SQL Server,
Web Deployment Kit, Web.PB, Web.SQL, WebSights, WebViewer, WorkGroup SQL Server, XA-Library, XA-Server und XP Server sind Marken
von Sybase, Inc. oder ihren Tochtergesellschaften.
Alle anderen Marken sind Eigentum ihrer jeweiligen Eigentümer.
Stand: Oktober 2002. Bestellnummer: 03946-01-0802-01.

Inhalt
Über dieses Handbuch.................................................... vii
Dokumentation zu SQL Anywhere Studio ..............................viii
Konventionen in dieser Dokumentation ................................... xi
Adaptive Server Anywhere-Beispieldatenbank.......................xiv
Wenn Sie mehr wissen und uns Ihre Anregungen
mitteilen möchten.................................................................... xv
1 Überblick über die Programmierschnittstelle.................. 1
Die ODBC-Programmierschnittstelle ........................................2
Die Programmierschnittstelle OLE DB......................................3
Die Embedded SQL-Programmierschnittstelle .........................4
Die JDBC-Programmierschnittstelle .........................................5
Die Open Client-Programmierschnittstelle................................6
2 SQL in Anwendungen verwenden .................................... 9
SQL-Anweisungen in Anwendungen ausführen .....................10
Anweisungen vorbereiten .......................................................12
Der Cursor...............................................................................15
Mit Cursorn arbeiten................................................................20
Cursortypen auswählen ..........................................................26
Adaptive Server Anywhere-Cursor .........................................30
Ergebnismengen beschreiben ................................................47
Transaktionen in Anwendungen steuern ................................49
3 Einführung in Java für Datenbanken.............................. 53
Einleitung ................................................................................54
Fragen und Antworten zu Java in der Datenbank ..................57
Ein Java-Seminar....................................................................64
Die Laufzeitumgebung für Java in der Datenbank..................75
Praktische Einführung: Eine Übung mit Java in
der Datenbank.........................................................................84
iii

4 Java in der Datenbank benutzen .................................... 93
Einleitung ................................................................................ 94
Datenbank für Java aktivieren ................................................ 97
Java-Klassen in einer Datenbank installieren....................... 103
Spalten für die Aufnahme von Java-Objekten
erstellen................................................................................. 109
Java-Objekte einfügen, aktualisieren und löschen ............... 111
Java-Objekte abfragen.......................................................... 117
Java-Felder und Objekte vergleichen ................................... 119
Besondere Funktionen von Java-Klassen in der
Datenbank............................................................................. 123
So werden Java-Objekte gespeichert................................... 130
Java-Datenbankdesign ......................................................... 133
Berechnete Spalten mit Java-Klassen verwenden ............... 137
Speicher für Java konfigurieren ............................................ 140
5 Datenzugriff über JDBC ................................................ 143
Überblick über JDBC ............................................................ 144
jConnect-JDBC-Treiber verwenden...................................... 150
JDBC-ODBC-Brücke verwenden.......................................... 155
JDBC-Verbindungen herstellen ............................................ 157
JDBC für den Zugriff auf Daten verwenden.......................... 165
Verteilte Anwendungen erstellen .......................................... 174
6 Programmieren mit Embedded SQL ............................ 181
Überblick ............................................................................... 182
Beispielprogramme mit Embedded SQL .............................. 190
Datentypen in Embedded SQL ............................................. 196
Hostvariable benutzen .......................................................... 200
SQL-Kommunikationsbereich (SQLCA) ............................... 208
Daten abrufen ....................................................................... 214
Statische und dynamische SQL............................................ 223
Der SQL-Deskriptor-Bereich (SQLDA) ................................. 228
Lange Werte senden und abfragen ...................................... 237
Gespeicherte Prozeduren verwenden .................................. 243
Programmiertechniken für Embedded SQL.......................... 247
SQL-Präprozessor ................................................................ 249
Referenz der Bibliotheksfunktion .......................................... 253
Befehlszusammenfassung für Embedded SQL.................... 272
7 ODBC-Programmierung................................................ 277
Einführung in ODBC ............................................................. 278
ODBC-Anwendungen erstellen............................................. 280
ODBC-Beispiele.................................................................... 285
iv

ODBC-Handles .....................................................................287
Verbindung mit einer Datenquelle herstellen........................290
SQL-Anweisungen ausführen ...............................................294
Mit Ergebnismengen arbeiten ...............................................299
Gespeicherte Prozeduren aufrufen.......................................304
Umgang mit Fehlern..............................................................306
8 Die DBTools-Schnittstelle ............................................. 311
Einführung in die DBTools-Schnittstelle................................312
DBTools-Schnittstelle verwenden.........................................314
DBTools-Funktionen .............................................................323
DBTools-Strukturen...............................................................335
DBTools-Aufzählungstypen ..................................................367
9 Die OLE DB- und ADO-Programmierschnittstellen ..... 371
Einführung zu OLE DB..........................................................372
ADO-Programmierung mit Adaptive Server
Anywhere ..............................................................................374
Unterstützte OLE DB-Schnittstellen......................................382
10 Die Open Client-Schnittstelle........................................ 389
Was Sie für die Entwicklung von Open Client-
Anwendungen brauchen .......................................................390
Datentyp-Zuordnungen .........................................................391
SQL in Open Client-Anwendungen verwenden ....................394
Bekannte Open Client-Einschränkungen von
Adaptive Server Anywhere ...................................................398
11 Dreischichtige Datenverarbeitung und verteilte
Transaktionen ................................................................ 399
Einleitung ..............................................................................400
Dreischichtige Datenverarbeitungsarchitektur ......................401
Verteilte Transaktionen verwenden ......................................405
EAServer mit Adaptive Server Anywhere
verwenden.............................................................................407
12 Deployment: Datenbanken und Anwendungen im System
bereitstellen ................................................................... 411
Systemeinführung - Überblick...............................................412
Installationsverzeichnisse und Dateinamen..........................415
InstallShield-Objekte und Vorlagen zum
Bereitstellen verwenden........................................................420
v

vi
Dialogfreie Installation für die Systemeinführung ................. 422
Clientanwendungen im System bereitstellen........................ 426
Tools zur Verwaltung bereitstellen........................................ 437
Datenbankserver im System bereitstellen ............................ 438
Eingebettete Datenbankanwendungen im System
bereitstellen........................................................................... 441
13 Fehlermeldungen des SQL-Präprozessors.................. 445
Fehlermeldungen des SQL-Präprozessors,
sortiert nach Fehlernummern................................................ 446
SQLPP-Fehler....................................................................... 450
Index............................................................................... 467

Über dieses Handbuch
Gegenstand
Zielgruppe
In diesem Handbuch wird beschrieben, wie Datenbankanwendungen in den
Programmiersprachen C, C++ und Java aufgebaut und bereitgestellt werden.
Benutzer von Programmen wie Visual Basic und PowerBuilder können deren
Programmierschnittstellen einsetzen.
Das Handbuch ist für Anwendungsentwickler bestimmt, die Programme
schreiben, welche direkt mit einer der Schnittstellen von Adaptive Server
Anywhere interagieren.
Sie brauchen das Handbuch nicht zu lesen, wenn Sie ein Entwicklungstool
wie PowerBuilder oder Visual Basic verwenden, die eine eigene Datenbank-
Schnittstelle nach dem ODBC-Standard benutzen.
vii

Dokumentation zu SQL Anywhere Studio
viii
Diese Dokumentation ist Teil der SQL Anywhere-Dokumentation. Dieser
Abschnitt enthält eine Liste der Handbücher und Hinweise zu ihrer
Verwendung.
Dokumentation zu SQL Anywhere Studio
Die Dokumentation zu SQL Anywhere Studio besteht aus folgenden
Handbüchern:
♦ SQL Anywhere Studio Erste Orientierung Dieses Handbuch enthält
einen Überblick über die Datenbankverwaltungs- und
Synchronisationstechnologien von SQL Anywhere Studio. Es enthält
praktische Einführungen zu einzelnen Bestandteilen von SQL Anywhere
Studio.
♦ Neues in SQL Anywhere Studio Dieses Handbuch richtet sich an
Benutzer früherer Versionen dieser Software. Es enthält eine Liste neuer
Funktionen in dieser und in früheren Versionen des Programms und eine
Beschreibung der Upgrade-Prozeduren.
♦ Adaptive Server Anywhere Erste Schritte Dieses Handbuch richtet
sich an Personen, die noch nicht mit relationalen Datenbanken bzw. mit
Adaptive Server Anywhere gearbeitet haben. Es enthält eine
Kurzeinführung in das Datenbankverwaltungssystem Adaptive Server
Anywhere und einführende Hinweise zum Entwerfen und Aufbauen von
Datenbanken sowie zur Arbeit mit Datenbanken.
♦ Adaptive Server Anywhere Datenbankadministration Dieses
Handbuch befasst sich mit der Ausführung, Verwaltung und
Konfiguration von Datenbanken.
♦ Adaptive Server Anywhere SQL-Benutzerhandbuch In diesem
Handbuch wird beschrieben, wie Datenbanken entworfen und
eingerichtet, Daten importiert, exportiert, geändert bzw. abgerufen und
gespeicherte Prozeduren und Trigger aufgebaut werden.
♦ Adaptive Server Anywhere SQL-Referenzhandbuch Dieses Handbuch
ist eine umfassende Referenz für die in Adaptive Server Anywhere
verwendete SQL-Sprache. Auch die Adaptive Server Anywhere-
Systemtabellen und Prozeduren werden darin beschrieben.

♦ Adaptive Server Anywhere Handbuch für Programmierer In diesem
Handbuch wird beschrieben, wie Datenbankanwendungen in den
Programmiersprachen C, C++ und Java aufgebaut und bereitgestellt
werden. Benutzer von Programmen wie Visual Basic und PowerBuilder
können deren Programmierschnittstellen einsetzen.
♦ Adaptive Server Anywhere Fehlermeldungen Dieses Handbuch
enthält eine vollständige Liste der Fehlermeldungen in Adaptive Server
Anywhere sowie Diagnosehinweise.
♦ Adaptive Server Anywhere Ergänzung zu C2-Sicherheitssystemen
Adaptive Server Anywhere 7.0 wurde die Sicherheitseinstufung TCSEC
(Trusted Computer System Evaluation Criteria) C2 der US-Regierung
verliehen. Dieses Handbuch kann für den Personenkreis von Interesse
sein, der die aktuelle Version von Adaptive Server Anywhere in einer
Umgebung ausführen möchte, die dem C2-Zertifikat entspricht. Nach
der Zertifizierung hinzugefügte Sicherheitsfunktionen werden im
Handbuch nicht erwähnt.
♦ MobiLink Benutzerhandbuch In diesem Handbuch werden alle
Aspekte des MobiLink-Datensynchronisationssystems für die mobile
Datenverarbeitung erläutert. Mit diesem System können Daten von
einzelnen Oracle-, Sybase-, Microsoft- oder IBM-Datenbanken und
vielen Adaptive Server Anywhere- bzw. UltraLite-Datenbanken
gemeinsam genutzt werden.
♦ SQL Remote Benutzerhandbuch In diesem Handbuch werden alle
Aspekte des SQL Remote-Datenreplikationssystems für mobile
Datenverarbeitung beschrieben, das die gemeinsame Datennutzung von
einer einzelnen Adaptive Server Anywhere- bzw. Adaptive Server
Enterprise-Datenbank und vielen Adaptive Server Anywhere-
Datenbanken über eine indirekte Verbindung wie etwa E-Mail oder
Datenübertragung ermöglicht.
♦ UltraLite Benutzerhandbuch In diesem Handbuch wird beschrieben,
wie Datenbankanwendungen für kleine Geräte wie Organizer mit der
UltraLite-Bereitstellungstechnologie für Adaptive Server Anywhere-
Datenbanken aufgebaut werden.
♦ UltraLite User’s Guide for PenRight! MobileBuilder (nur in
englischer Sprache verfügbar) Dieses Handbuch richtet sich an
Benutzer des Entwicklungsprogramms PenRight! MobileBuilder. Hier
wird beschrieben, wie die UltraLite-Technologie in der MobileBuilder-
Programmierumgebung eingesetzt wird.
♦ SQL Anywhere Studio-Hilfe Dieses Handbuch ist nur online verfügbar.
Es enthält die kontextsensitive Hilfe für Sybase Central, Interactive SQL
und andere grafische Programme.
ix

Dokumentationsformate
x
Zusätzlich zu dieser Dokumentation werden SQL Modeler und InfoMaker
mit eigener Dokumentation geliefert.
SQL Anywhere Studio umfasst Dokumentationen in folgenden Formaten:
♦ Online-Dokumentation Die Online-Dokumentation enthält die
vollständige SQL Anywhere Studio-Dokumentation, einschließlich der
gedruckten Handbücher und der kontextsensitiven Hilfe für die
SQL Anywhere-Dienstprogramme. Die Online-Dokumentation wird mit
jeder Wartungsversion des Produkts aktualisiert. Dies ist die
vollständigste und aktuellste Informationsquelle.
Wenn Sie unter Windows-Betriebssystemen auf die Online-
Dokumentation zugreifen wollen, klicken Sie auf
Start➤Programme➤Sybase SQL Anywhere 8➤Online-Dokumentation.
Der Zugriff auf den Inhalt erfolgt über die HTML-Inhaltsangabe, den
Index und die Suchfunktion im linken Fensterausschnitt sowie über
Links und Menüs im rechten Fensterausschnitt.
Unter UNIX-Betriebssystemen geben Sie den folgenden Befehl in einer
Befehlszeile ein, damit die Dokumentation aufgerufen wird:
dbbooks
♦ Ausdruckbare Handbücher Die SQL Anywhere-Handbücher werden
in Form von PDF-Dateien geliefert, die mit dem Adobe Acrobat Reader
eingesehen werden können.
Die PDF-Dateien finden sich auf der CD-ROM im Verzeichnis
pdf_docs. Während der Installation können Sie entscheiden, ob sie
installiert werden sollen.
♦ Gedruckte Handbücher Die folgenden Handbücher finden Sie in der
SQL Anywhere Studio-Box:
♦ SQL Anywhere Studio Erste Orientierung
♦ Adaptive Server Anywhere Erste Schritte
♦ SQL Anywhere Studio Kurzreferenz. Dieses Handbuch ist nur in
gedruckter Form verfügbar.
Der gesamte Handbuchsatz kann als SQL Anywhere-Dokumentation
über den Sybase-Vertrieb bzw. den e-Shop - den Sybase-Online-
Vertrieb - bezogen werden, und zwar unter der Adresse http://eshop.sybase.com/cgi-bin/eshop.storefront/.

Konventionen in dieser Dokumentation
Syntaxkonventionen
In diesem Abschnitt werden die Konventionen für die Schreibweise und der
grafische Aufbau beschrieben, der in dieser Dokumentation verwendet wird.
Folgende Konventionen werden bei SQL-Syntaxbeispielen verwendet:
♦ Schlüsselwörter Alle SQL-Schlüsselwörter werden wie die Wörter
ALTER TABLE im folgenden Beispiel angezeigt:
ALTER TABLE [ Eigentümer.]Tabellenname
♦ Platzhalter Elemente, die durch entsprechende Identifizierer oder
Ausdrücke ersetzt werden müssen, werden wie die Wörter Eigentümer
und Tabellenname im folgenden Beispiel angezeigt:
ALTER TABLE [ Eigentümer.]Tabellenname
♦ Wiederholungen Listen mit sich wiederholenden Elementen werden mit
einem Element der Liste, gefolgt von drei Punkten gezeigt, wie Spalten-
Integritätsregel im folgenden Beispiel:
ADD Spaltendefinition [ Spalten-Integritätsregel, … ]
Ein oder mehrere Listenelemente sind zulässig. Wenn mehr als ein
Element angegeben wird, muss eine Trennung der Elemente durch
Kommas erfolgen.
♦ Fakultative Bestandteile Fakultative Bestandteile einer Anweisung
werden in eckige Klammern gesetzt.
RELEASE SAVEPOINT [ Savepoint-Name ]
Diese eckigen Klammern zeigen an, dass der Savepoint-Name fakultativ
ist. Die eckigen Klammern werden nicht eingegeben.
♦ Optionen Wenn aus einer Liste kein oder nur ein Element ausgewählt
werden darf, werden die Elemente durch Senkrechtstriche voneinander
getrennt, und die komplette Liste wird in eckige Klammern gesetzt.
[ ASC | DESC ]
Sie können z.B. entweder ASC, DESC oder keines wählen. Die eckigen
Klammern werden nicht eingegeben.
♦ Alternativen Wenn nur eine der vorhandenen Optionen gewählt werden
darf, werden die Alternativen in geschweifte Klammern gesetzt.
[ QUOTES { ON | OFF } ]
xi

Grafische Symbole
xii
Wenn die Option QUOTES ausgewählt wird, muss entweder ON oder
OFF angegeben werden. Eckige und geschweifte Klammern sind nicht
einzugeben.
♦ Eine oder mehrere Optionen Wenn Sie mehr als eine wählen, trennen
Sie die Eingaben durch Kommas.
{ CONNECT, DBA, RESOURCE }
Folgende Symbole werden in dieser Dokumentation verwendet:

Symbol Bedeutung
API
Eine Clientanwendung
Ein Datenbankserver, wie etwa Sybase Adaptive
Server Anywhere oder Adaptive Server Enterprise
Eine UltraLite-Anwendung und der Datenbankserver.
Bei UltraLite sind der Datenbankserver und die
Anwendung Teil des gleichen Prozesses.
Eine Datenbank. In einigen abstrakten Diagrammen
kann dieses Symbol die Datenbank und gleichzeitig
auch den Datenbankserver, der sie steuert,
repräsentieren.
Replikations- oder Synchronisations-Middleware. Mit
Hilfe derartiger Software können Daten in mehreren
Datenbanken gleichzeitig verwendet werden.
Beispiele sind der MobiLink Synchronisationsserver,
der SQL Remote-Nachrichtenagent und der
Replication Agent (Log Transfer Manager), der in
Replication Server eingesetzt wird.
Ein Sybase Replication Server
Eine Programmierschnittstelle
xiii

Adaptive Server Anywhere-Beispieldatenbank
xiv
Viele der in der Dokumentation beschriebenen Beispiele verwenden die
Adaptive Server Anywhere-Beispieldatenbank.
Die Beispieldatenbank befindet sich in einer Datei mit dem Namen
asademo.db im Installationsverzeichnis von SQL Anywhere.
Die Beispieldatenbank stellt ein kleines Unternehmen dar. Sie enthält interne
Informationen über das Unternehmen wie Mitarbeiter (employees),
Abteilungen (departments) und Finanzdaten (finances) sowie
Produktinformationen (products) und Verkaufsinformationen (sales orders,
customers, contacts). Alle Daten in der Datenbank sind frei erfunden.
In der nachstehend abgebildeten Strukturdarstellung werden die Tabellen der
Beispieldatenbank und ihre Beziehungen zueinander erläutert.
product
id integer
name char(15)
description char(30)
size char(18)
color char(6)
quantity integer
unit_price numeric(15,2)
customer
id integer
fname char(15)
lname char(20)
address char(35)
city char(20)
state char(2)
zip char(10)
phone char(12)
company_name char(35)
contact
id integer
last_name char(15)
first_name char(15)
title char(2)
street char(30)
city char(20)
state char(2)
zip char(5)
phone char(10)
fax char(10)
id = prod_id
id = cust_id
asademo.db
sales_order_items
id integer
line_id smallint
prod_id integer
quantity integer
ship_date date
id = id
sales_order
id integer
cust_id integer
order_date date
fin_code_id char(2)
region char(7)
sales_rep integer
code = fin_code_id
fin_code
code char(2)
type char(10)
description char(50)
code = code
fin_data
year char(4)
quarter char(2)
code char(2)
amount numeric(9)
emp_id = sales_rep
employee
emp_id integer
manager_id integer
emp_fname char(20)
emp_lname char(20)
dept_id integer
street char(40)
city char(20)
state char(4)
zip_code char(9)
phone char(10)
status char(1)
ss_number char(11)
salary numeric(20,3)
start_date date
termination_date date
birth_date date
bene_health_ins char(1)
bene_life_ins char(1)
bene_day_care char(1)
sex char(1)
dept_id = dept_id
emp_id = dept_head_id
department
dept_id integer
dept_name char(40)
dept_head_id integer

Wenn Sie mehr wissen und uns Ihre
Anregungen mitteilen möchten
Wir würden gerne Ihre Meinung kennen und sind an Ihren Vorschlägen und
Anregungen zu dieser Dokumentation interessiert.
Sie können uns Ihre Anregungen zu dieser Dokumentation und der Software
übermitteln, indem Sie Newsgroups nutzen, die zur Diskussion über SQL
Anywhere-Technologien eingerichtet wurden. Sie finden diese Newsgroups
auf dem Newsserver forums.sybase.com.
Dazu gehören:
♦ sybase.public.sqlanywhere.general.
♦ sybase.public.sqlanywhere.linux.
♦ sybase.public.sqlanywhere.mobilink.
♦ sybase.public.sqlanywhere.product_futures_discussion.
♦ sybase.public.sqlanywhere.replication.
♦ sybase.public.sqlanywhere.ultralite.
Newsgroup-Verpflichtungsausschluss
Sybase ist weder verpflichtet, Lösungen, Informationen oder Ideen in
seinen Newsgroups bereitzustellen, noch ist Sybase verpflichtet, mehr
bereitzustellen als einen Systemadministrator, der den Service überwacht
und seine Abwicklung sowie die Verfügbarkeit gewährleistet.
Die technischen Mitarbeiter von iAnywhere Solutions stehen, ebenso wie
andere Mitarbeiter, für den Newsgroup-Service bereit, sofern sie Zeit dazu
haben. Sie stellen ihre Hilfe freiwillig zur Verfügung und sind
möglicherweise nicht regelmäßig verfügbar, um Lösungen und
Informationen bereitzustellen. Ihre Einsatzfähigkeit ist abhängig von ihrer
aktuellen Arbeitsauslastung.
xv

xvi

KAPITEL 1
Überblick über die
Programmierschnittstelle
Über dieses
Kapitel
Inhalt
Dieses Kapitel ist eine Einführung in die einzelnen
Programmierschnittstellen für Adaptive Server Anywhere. Alle Client-
Anwendungen verwenden eine dieser Schnittstellen für die Kommunikation
mit der Datenbank.
Thema Seite
Die ODBC-Programmierschnittstelle 2
Die Programmierschnittstelle OLE DB 3
Die Embedded SQL-Programmierschnittstelle 4
Die JDBC-Programmierschnittstelle 5
Die Open Client-Programmierschnittstelle 6
1

Die ODBC-Programmierschnittstelle
Die ODBC-Programmierschnittstelle
2
ODBC (Open Database Connectivity) ist eine Standardschnittstelle auf
Aufrufebene (Call Level Interface, CLI), die von Microsoft entwickelt
wurde. Sie basiert auf der SQL Access Group CLI Spezifikation. ODBC-
Anwendungen können mit jeder Datenquelle ausgeführt werden, die einen
ODBC-Treiber bereitstellt. Sie müssen ODBC verwenden, wenn Ihre
Anwendung auf andere Datenquellen portierbar sein soll, die mit ODBC-
Treibern arbeiten. Auch wenn Sie die Arbeit mit einer API bevorzugen,
sollten Sie ODBC verwenden.
ODBC ist eine Schnittstelle auf niedriger Ebene - etwa auf demselben
Niveau wie Embedded SQL. Fast alle Funktionen von Adaptive Server
Anywhere sind mit dieser Schnittstelle verfügbar. ODBC ist unter Windows
Betriebssystemen außer Windows CE als DLL verfügbar. Unter UNIX steht
der Treiber als Bibliothek zur Verfügung.
Die wichtigste Dokumentation für ODBC ist der Microsoft ODBC Software
Development Kit. Das vorliegende Handbuch enthält einige zusätzliche
Hinweise, die sich an Entwickler richten, die ODBC-Anwendungen für
Adaptive Server Anywhere bereitstellen.
$ ODBC wird im Abschnitt "ODBC-Programmierung" auf Seite 277
beschrieben.

Kapitel 1 Überblick über die Programmierschnittstelle
Die Programmierschnittstelle OLE DB
OLE DB ist eine Gruppe von Component Object Model-Schnittstellen
(COM), die von Microsoft entwickelt wurden und Anwendungen einen
gleichförmigen Zugriff auf Daten bieten, die in unterschiedlichen
Informationsquellen gespeichert sind, und darüber hinaus die Möglichkeit
bieten, zusätzliche Datenbankdienste zu implementieren. Diese Schnittstellen
unterstützen so viele DBMS-Funktionen, wie sie für die gemeinsame
Nutzung des Datenspeichers erforderlich sind.
ADO ist ein Objektmodell, das ermöglicht, über Programme und OLE DB-
Systemschnittstellen auf eine große Anzahl von Datenquellen zuzugreifen,
diese zu ändern und zu aktualisieren. ADO wurde ebenfalls von Microsoft
entwickelt. Die meisten Entwickler, die die OLE DB-
Programmierschnittstelle verwenden, tun dies in dem sie die ADO API
einsetzen und nicht direkt die OLE DB API.
Adaptive Server Anywhere umfasst einen OLE DB-Provider für OLE DBund
ADO-Programmierer.
Die primäre Dokumentation für das Programmieren mit OLE DB und ADO
ist das Microsoft Developer Network. Das vorliegende Handbuch enthält
einige zusätzliche Hinweise, die sich an Entwickler richten, die OLE DBund
ADO-Anwendungen für Adaptive Server Anywhere bereitstellen.
$ Weitere Hinweise finden Sie unter "Die OLE DB- und ADO-
Programmierschnittstellen" auf Seite 371
3

Die Embedded SQL-Programmierschnittstelle
Die Embedded SQL-Programmierschnittstelle
4
Embedded SQL ist ein System, in dem SQL-Befehle direkt in eine C- oder
C++-Quelldatei eingebettet sind. Ein Präprozessor übersetzt diese
Anweisungen in Aufrufe einer Laufzeitbibliothek. Embedded SQL ist ein
ISO/ANSI- und IBM-Standard.
Embedded SQL kann auf andere Datenbanken und andere Umgebungen
portiert werden und ist in allen Betriebsumgebungen funktional äquivalent.
Sie stellt alle im Produkt verfügbaren Funktionen bereit. Die Arbeit mit
Embedded SQL ist einfach und geradlinig, wenn auch eine gewisse
Eingewöhnung erforderlich ist, Embedded SQL Anweisungen (und nicht
Funktionsaufrufe) in einem C-Programmcode zu verwenden.
$ Embedded SQL wird unter "Programmieren mit Embedded SQL" auf
Seite 181 beschrieben.

Kapitel 1 Überblick über die Programmierschnittstelle
Die JDBC-Programmierschnittstelle
JDBC ist eine Schnittstelle auf Aufrufebene für Java-Anwendungen. Der
Treiber wurde von Sun Microsystems entwickelt und bietet Java-
Programmierern eine einheitliche Schnittstelle zu einer Vielzahl von
relationalen Datenbanken, sowie eine gemeinsame Basis, auf der Tools und
Schnittstellen auf höherer Ebene aufgebaut werden können. JDBC ist jetzt
ein Standardbestandteil von Java und wurde in den JDK aufgenommen.
SQL Anywhere enthält einen einen reinen Java-JDBC-Treiber namens
Sybase jConnect an. Dieser enthält außerdem einen JDBC-ODBC-Brücke.
Beide werden im Abschnitt "Datenzugriff über JDBC" auf Seite 143
beschrieben. Hinweise zur Auswahl eines Treibers finden Sie unter "JDBC-
Treiber wählen" auf Seite 145.
Zusätzlich zum Einsatz von JDBC als clientseitige
Anwendungsprogrammierschnittstelle können Sie JDBC innerhalb des
Datenbankservers verwenden, um Java-Daten in der Datenbank abzurufen.
Aus diesem Grund wird JDBC als Teil von Java in der
Datenbankdokumentation dokumentiert.
$ JDBC wird in diesem Handbuch nicht beschrieben. Eine Beschreibung
des JDBC-Treibers entnehmen Sie dem Kapitel "Datenzugriff über JDBC"
auf Seite 143.
5

Die Open Client-Programmierschnittstelle
Die Open Client-Programmierschnittstelle
Einsatzbereich des
Open Clients
Die Open Client-Architektur
Client-Library und
DB-Library
6
Sybase Open Client bietet Kundenanwendungen, Produkten von
Drittanbietern und anderen Sybase-Produkten die erforderlichen
Schnittstellen zur Kommunikation mit dem Adaptive Server Anywhere und
anderen Open Servern.
Der Einsatz der Open Client-Schnittstelle ist zu überlegen, wenn Ihnen die
Kompatibilität von Adaptive Server Enterprise wichtig ist oder wenn Sie
andere Sybase-Produkte verwenden, die die Open Client-Schnittstelle
benötigen, zum Beispiel Replication Server.
$ Eine Beschreibung der Open Client-Schnittstelle entnehmen Sie dem
Abschnitt "Die Open Client-Schnittstelle" auf Seite 389.
$ Weitere Hinweise über die Open Client-Schnittstelle finden Sie unter
"Adaptive Server Anywhere als Open Server" auf Seite 117 der
Dokumentation ASA Datenbankadministration.
Das Konzept "Open Client" kann man sich als System mit zwei
Komponenten vorstellen: Programmierschnittstellen und Netzwerkdiensten.
Open Client bietet zwei Kern-Programmierschnittstellen für das Schreiben
von Clientanwendungen: DB-Library und Client-Library.
Die Open Client DB-Library bietet Unterstützung für ältere Open Client
Anwendungen und ist eine von der Client-Library vollständig getrennte
Programmierschnittstelle. DB-Bibliothek ist dokumentiert im Open Client
DB-Library/C Reference Manual, das zum Lieferumfang des Produkts
Sybase Open Client gehört.
Client-Library-Programme sind auch von der CS-Library abhängig, die
Routinen sowohl für den Einsatz in Client-Library- als auch Server-Library-
Anwendungen bereitstellt. Client-Library-Anwendungen können auch
Routinen der Bulk-Library benutzen, um die Hochgeschwindigkeits-
Datenübertragung zu erleichtern.
Die CS-Library und die Bulk-Library sind in Sybase Open Client enthalten.
Dieses Produkt kann separat erworben werden.

Netzwerkdienste
Kapitel 1 Überblick über die Programmierschnittstelle
Open Client-Netzwerkdienste enthalten die Sybase Net-Library, die die
Unterstützung für bestimmte Netzwerkprotokolle wie TCP/IP und DECnet
bereithält. Die Net-Library-Schnittstelle ist für Anwendungsprogrammierer
unsichtbar. Auf manchen Plattformen benötigt eine Anwendung unter
Umständen einen anderen Net-Library-Treiber für unterschiedliche System-
Netzwerkkonfigurationen. Je nach Ihrer Hostplattform wird der Net-Library-
Treiber entweder durch die Konfiguration der Sybase-Produkte des Systems
bestimmt, oder durch die Kompilierung und Verknüpfung Ihrer Programme.
$ Hinweise zur Treiberkonfiguration finden Sie in der Dokumentation
Open Client/Server Configuration Guide.
$ Hinweise zum Aufbau von Client-Library-Programmen finden Sie in
der Dokumentation Open Client/Server Programmer’s Supplement.
7

Die Open Client-Programmierschnittstelle
8

KAPITEL 2
SQL in Anwendungen verwenden
Über dieses
Kapitel
Inhalt
Viele Aspekte der Entwicklung von Datenbankanwendungen hängen vom
Entwicklungstool, von der Datenbank-Schnittstelle und von der
Programmiersprache ab. Einige Probleme und Grundsätze sind jedoch
allgemein gültig und wirken sich auf mehrere Aspekte der Entwicklung von
Datenbankanwendungen aus.
In diesem Kapitel werden einige Grundsätze und Techniken beschrieben, die
für die meisten oder alle Schnittstellen gelten. Außerdem enthält das Kapitel
Verweise auf weiterführende Informationen. Das Kapitel ist keine detaillierte
Anweisung für die Programmierung mit einer bestimmten Schnittstelle.
Thema Seite
SQL-Anweisungen in Anwendungen ausführen 10
Anweisungen vorbereiten 12
Der Cursor 15
Mit Cursorn arbeiten 20
Cursortypen auswählen 26
Adaptive Server Anywhere-Cursor 30
Ergebnismengen beschreiben 47
Transaktionen in Anwendungen steuern 49
9

SQL-Anweisungen in Anwendungen ausführen
SQL-Anweisungen in Anwendungen ausführen
10
Wie Sie SQL-Anweisungen in Ihre Anwendung einbauen, hängt vom
Entwicklungstool und der Programmierschnittstelle ab, die Sie verwenden.
♦ ODBC Wenn Sie direkt in die ODBC-Programmierschnittstelle
schreiben, erscheinen Ihre SQL-Anweisungen in Funktionsaufrufen.
Beispiel: Der folgende C-Funktionsaufruf führt eine DELETE-
Anweisung aus:
SQLExecDirect( stmt,
"DELETE FROM employee
WHERE emp_id = 105",
SQL_NTS );
♦ JDBC Wenn Sie die JDBC-Programmierschnittstelle verwenden,
können Sie SQL-Anweisungen ausführen, indem Sie Methoden des
Statement-Objekts aufrufen. Zum Beispiel:
stmt.executeUpdate(
"DELETE FROM employee
WHERE emp_id = 105" );
♦ Embedded SQL Wenn Sie Embedded SQL verwenden, erhalten die
SQL-Anweisungen der C-Sprachen das Schlüsselwort EXEC SQL als
Präfix. Der Code wird dann im Präprozessor verarbeitet, bevor er
kompiliert wird. Zum Beispiel:
EXEC SQL EXECUTE IMMEDIATE
’DELETE FROM employee
WHERE emp_id = 105’;
♦ Sybase Open Client Wenn Sie die Sybase Open Client- Schnittstelle
verwenden, erscheinen Ihre SQL-Anweisungen in Funktionsaufrufen.
Die folgenden beiden Aufrufe führen zum Beispiel eine DELETE-
Anweisung aus:
ret = ct_command(cmd, CS_LANG_CMD,
"DELETE FROM employee
WHERE emp_id=105"
CS_NULLTERM,
CS_UNUSED);
ret = ct_send(cmd);
♦ Anwendungs-Entwicklungstools Anwendungs-Entwicklungstools wie
die Mitglieder der Sybase Enterprise-Familie bieten ihre eigenen SQL-
Objekte, die entweder ODBC (PowerBuilder) oder JDBC (Power J)
verwenden.

Anwendungen im
Server
Kapitel 2 SQL in Anwendungen verwenden
$ Genauere Hinweise zur Aufnahme von SQL-Anweisungen in Ihre
Anwendungen finden Sie in der Dokumentation Ihres Entwicklungstools.
Wenn Sie ODBC oder JDBC verwenden, finden Sie weitere Hinweise im
Software Development Kit für diese Schnittstellen.
$ Eine genaue Beschreibung der Programmierung mit Embedded SQL
finden Sie unter "Programmieren mit Embedded SQL" auf Seite 181.
Auf vielerlei Weise funktionieren gespeicherte Prozeduren und Trigger als
Anwendungen oder Teile von Anwendungen, die im Server laufen. Sie
können viele der hier beschriebenen Techniken auch in gespeicherten
Prozeduren verwenden. Gespeicherte Prozeduren benutzen Anweisungen,
die Embedded SQL sehr ähnlich sind.
$ Weitere Hinweise zu gespeicherten Prozeduren und Triggern finden Sie
unter "Prozeduren, Trigger und Anweisungsfolgen verwenden" auf Seite 565
der Dokumentation ASA SQL-Benutzerhandbuch.
Java-Klassen in der Datenbank können die JDBC-Schnittstelle genauso
benutzen wie Java-Anwendungen dies außerhalb des Servers tun. In diesem
Kapitel werden einige Aspekte von JDBC beschrieben. Weitere Hinweise
zur Arbeit mit JDBC finden Sie unter "Datenzugriff über JDBC" auf
Seite 143.
11

Anweisungen vorbereiten
Anweisungen vorbereiten
Die
Wiederverwendung
von vorbereiteten
Anweisungen kann
die Performance
verbessern
12
Jedes Mal, wenn eine Anweisung an eine Datenbank geschickt wird, muss
der Server die Anweisung zunächst vorbereiten. Zur Vorbereitung können
folgende Schritte gehören:
♦ Syntaktische Analyse der Anweisung und Umwandlung in eine interne
Form.
♦ Prüfung der Richtigkeit aller Referenzen auf Datenbankobjekte, z.B.
Prüfung, ob in der Abfrage genannte Spalten existieren.
♦ Optimierer für Abfragen veranlassen, einen Zugriffsplan zu erstellen,
falls die Anweisung Joins oder Unterabfragen umfasst.
♦ Ausführung der Anweisung, nachdem alle diese Schritte durchgeführt
wurden.
Wenn Sie dieselbe Anweisung immer wieder verwenden, etwa das Einfügen
von mehreren Zeilen in eine Tabelle, kommt es zu bedeutenden und
unnötigen Overheads durch die wiederholte Vorbereitung der Anweisung.
Um dies zu vermeiden, bieten einige Datenbank-Programmierschnittstellen
eine Möglichkeit zur Verwendung von vorbereiteten Anweisungen. Eine
vorbereitete Anweisung ist eine Anweisung, die eine Reihe von
Platzhaltern enthält. Wenn Sie die Anweisung ausführen wollen, müssen Sie
den Platzhaltern nur Werte zuweisen, anstatt die gesamte Anweisung erneut
vorzubereiten.
Der Einsatz von vorbereiteten Anweisungen ist besonders dann nützlich,
wenn viele ähnliche Aktionen ausgeführt werden, wie etwa das Einfügen von
vielen Zeilen.
Im Allgemeinen erfordern vorbereitete Anweisungen die folgenden Schritte:
1 Anweisung vorbereiten In diesem Schritt versehen Sie die Anweisung
im Allgemeinen mit einigen Platzhalter-Zeichen anstelle von Werten.
2 Wiederholtes Ausführen der vorbereiteten Anweisung In diesem
Schritt liefern Sie Werte, die jedes Mal benutzt werden sollen, wenn die
Anweisung ausgeführt wird. Die Anweisung braucht nicht jedes Mal
vorbereitet zu werden.
3 Anweisung löschen In diesem Schritt geben Sie die Ressourcen frei,
die für die vorbereitete Anweisung in Beschlag genommen wurden.
Einige Programmierschnittstellen verarbeiten diesen Schritt automatisch.

Bereiten Sie keine
Anweisungen vor,
die nur einmal
verwendet werden.
Kapitel 2 SQL in Anwendungen verwenden
Im Allgemeinen sollten Sie Anweisungen nicht vorbereiten, wenn sie nur
einmal ausgeführt werden sollen. Bei getrennter Vorbereitung und
Durchführung kommt es zu leichten Einbußen bei der Performance, und
außerdem werden dadurch unnötig komplizierte Schritte in die Anwendung
eingefügt.
Bei manchen Schnittstellen müssen Sie allerdings eine Anweisung
vorbereiten, um sie mit einem Cursor zu verbinden.
$ Hinweise zu Cursorn finden Sie unter "Der Cursor" auf Seite 15.
Die Aufrufe für die Vorbereitung und Ausführung von Anweisungen sind
nicht Teil der SQL und unterscheiden sich daher je nach verwendeter
Schnittstelle. Jede Programmierschnittstelle des Adaptive Server Anywhere
bietet eine Methode für die Verwendung von vorbereiteten Anweisungen.
So verwenden Sie vorbereitete Anweisungen
In diesem Abschnitt wird ein kurzer Überblick über die Verwendung von
vorbereiteten Anweisungen gegeben. Die allgemeine Vorgehensweise ist
identisch, aber die Details unterscheiden sich je nach Schnittstelle. Ein
Vergleich der Verwendung von vorbereiteten Anweisungen in den einzelnen
Schnittstellen kann diesen Punkt vielleicht klarer darstellen.
v So verwenden Sie eine vorbereitete Anweisung (generisch):
1 Bereiten Sie die Anweisung vor.
2 Setzen Sie Bindungsparameter, die benutzt werden, um Werte in der
Anweisung zu halten.
3 Weisen Sie den Bindungsparametern in der Anweisung Werte zu.
4 Führen Sie die Anweisung aus.
5 Wiederholen Sie nötigenfalls Schritte 3 und 4.
6 Löschen Sie die Anweisung, wenn Sie fertig sind. Dieser Schritt ist in
JDBC nicht erforderlich, da der Abfalldatenmechanismus von JDBC
dies erledigt.
v So verwenden Sie eine vorbereitete Anweisung (Embedded SQL):
1 Bereiten Sie die Anweisung mit dem Befehl EXEC SQL PREPARE vor.
2 Weisen Sie den Parametern in der Anweisung Werte zu.
3 Führen Sie die Anweisung mit dem Befehl EXE SQL EXECUTE aus.
13

Anweisungen vorbereiten
14
4 Geben Sie die mit der Anweisung verbundenen Ressourcen frei, indem
Sie den Befehl EXEC SQL DROP benutzen.
v So verwenden Sie eine vorbereitete Anweisung (ODBC):
1 Bereiten Sie die Anweisung mit SQLPrepare vor.
2 Binden Sie die Anweisungsparameter mit SQLBindParameter.
3 Führen Sie die Anweisung mit SQLExecute aus.
4 Löschen Sie die Anweisung mit SQLFreeStmt.
$ Weitere Hinweise finden Sie unter "Vorbereitete Anweisungen
ausführen" auf Seite 297 und in der Dokumentation zum ODBC SDK.
v So verwenden Sie eine vorbereitete Anweisung (JDBC):
1 Bereiten Sie die Anweisung mit der Methode prepareStatement des
Verbindungsobjekts vor. Daraus wird ein PreparedStatement-Objekt
erzeugt.
2 Setzen Sie die Anweisungsparameter mit den entsprechenden setType-
Methoden des PreparedStatement-Objekts. Hier ist Type der Datentyp,
der zugewiesen wird.
3 Führen Sie die Anweisung mit der geeigneten Methode für das
PreparedStatement-Objekt aus. Für Einfügungen, Aktualisierungen und
Löschungen ist dies die Methode executeUpdate.
$ Weitere Hinweise zur Verwendung von vorbereiteten
Anweisungen in JDBC finden Sie unter "Vorbereitete Anweisungen für
effizienteren Zugriff verwenden" auf Seite 171.
v So verwenden Sie eine vorbereitete Anweisung (Open Client):
1 Bereiten Sie die Anweisung mit der Funktion ct_dynamic mit
CS_PREPARE als type-Parameter vor.
2 Setzen Sie die Anweisungsparameter ct_param.
3 Führen Sie die Anweisung mit ct_dynamic mit CS_EXECUTE als
Typparameter aus.
4 Geben Sie die mit der Anweisung verbundenen Ressourcen frei, indem
Sie ct_dynamic mit einem CS_DEALLOC-Typparameter verwenden.
Weitere Hinweise über die Verwendung von vorbereiteten Anweisungen
in Open Client finden Sie unter "SQL in Open Client-Anwendungen
verwenden" auf Seite 394.

Der Cursor
Was sind Cursor?
Cursorpositionen
Kapitel 2 SQL in Anwendungen verwenden
Wenn Sie eine Abfrage in einer Anwendung ausführen, besteht die
Ergebnismenge aus einer Reihe von Zeilen. Im Allgemeinen wissen Sie
nicht, wie viele Zeilen die Anwendung empfangen wird, bevor die Abfrage
ausgeführt worden ist. Mit einem Cursor können Sie Ergebnismengen von
Abfragen in Anwendungen verarbeiten.
Wie Sie Cursor einsetzen, und welche Cursorarten verfügbar sind, hängt von
der Programmierschnittstelle ab, die Sie benutzen. JDBC 1.0 bietet nur eine
Basisverarbeitung von Ergebnismengen, während ODBC und Embedded
SQL über viele unterschiedliche Cursorarten verfügen. Mit einem Cursor in
Open Client kann man sich in einer Ergebnismenge nur vorwärts bewegen.
Sie können mit einem Cursor folgende Aufgaben innerhalb einer
Programmierschnittstelle durchführen:
♦ Die Ergebnisse einer Abfrage mittels Schleifen bearbeiten.
♦ Einfügungen, Aktualisierungen und Löschungen auf den
darunterliegenden Daten an einem beliebigen Punkt in einer
Ergebnismenge durchführen
Zusätzlich ermöglichen Ihnen einige Programmierschnittstellen die
Verwendung von Sonderfunktionen, um die Art zu optimieren, wie
Ergebnismengen an Ihre Anwendung zurückgegeben werden, was
beträchtliche Performance-Vorteile für Ihre Anwendung bietet.
$ Weitere Hinweise zur den verfügbaren Cursorarten in den einzelnen
Programmierschnittstellen finden Sie unter "Cursorverfügbarkeit" auf
Seite 26.
Ein Cursor ist ein Name, der einer Ergebnismenge zugeordnet ist. Die
Ergebnismenge erhalten Sie durch eine SELECT-Anweisung oder den
Aufruf einer gespeicherten Prozedur.
Ein Cursor ist ein Handle auf der Ergebnismenge. Zu jedem Zeitpunkt hat
der Cursor eine genau definierte Position innerhalb der Ergebnismenge. Mit
einem Cursor können Sie die Daten zeilenweise untersuchen und
gegebenenfalls bearbeiten. In Adaptive Server Anywhere unterstützen
Cursor Vorwärts- und Rückwärts-Bewegungen durch die Abfrageergebnisse.
Cursor können an den folgenden Stellen positioniert werden:
♦ Vor der ersten Zeile der Ergebnismenge.
15

Der Cursor
Vorteile der Cursorbenutzung
16
♦ Auf einer Zeile in der Ergebnismenge.
♦ Nach der letzten Zeile der Ergebnismenge.
Cursorposition und Ergebnismenge werden im Datenbankserver
aufrechterhalten. Zeilen werden vom Client zur Anzeige oder Verarbeitung
einzeln oder in Gruppen abgerufen. Dem Client muss nicht die gesamte
Ergebnismenge übermittelt werden.
Sie müssen nicht unbedingt Cursor in Datenbankanwendungen verwenden,
aber ihr Einsatz bietet eine Reihe von Vorteilen. Diese Vorteile beruhen
darauf, dass die gesamte Ergebnismenge an den Client zur Ansicht und
Verarbeitung übermittelt werden muss, wenn Sie keine Cursor verwenden:
♦ Clientseitiger Speicher Bei umfangreichen Ergebnismengen kann das
Halten der gesamten Ergebnismenge auf dem Client zu zusätzlichem
Speicherbedarf führen.

Schritte der Cursorbenutzung
Kapitel 2 SQL in Anwendungen verwenden
♦ Antwortzeit Cursor können die ersten Zeilen liefern, bevor die gesamte
Ergebnismenge zusammengestellt wird. Wenn Sie keine Cursor
verwenden, muss die gesamte Ergebnismenge übermittelt werden, bevor
eine Zeile von Ihrer Anwendung angezeigt werden kann.
♦ Parallelitätskontrolle Wenn Sie Ihre Daten aktualisieren und keine
Cursor in Ihrer Anwendung verwenden, müssen Sie separate SQL-
Anweisungen an den Datenbankserver senden, um die Änderungen
anzuwenden. Dadurch können Probleme mit der Parallelität entstehen,
falls sich die Ergebnismenge seit der Abfrage durch den Client geändert
hat. Das wiederum kann möglicherweise zu Aktualisierungsverlusten
führen.
Corsor sind wie Zeiger auf die darunter liegenden Daten und geben
dadurch entsprechende Parallelitätsbeschränkungen für die
durchgeführten Änderungen vor.
Die Verwendung eines Cursors in Embedded SQL unterscheidet sich von der
Verwendung eines Cursors in anderen Schnittstellen.
v So verwenden Sie einen Cursor (Embedded SQL):
1 Bereiten Sie eine Anweisung vor.
Cursor verwenden üblicherweise einen Anweisungs-Handle statt einer
Zeichenfolge. Sie müssen eine Anweisung vorbereiten, damit ein Handle
verfügbar ist.
$ Hinweise über das Vorbereiten einer Anweisung finden Sie unter
"Anweisungen vorbereiten" auf Seite 12.
2 Deklarieren Sie den Cursor.
Jeder Cursor bezieht sich auf eine einzelne SELECT- oder CALL-
Anweisung. Wenn Sie einen Cursor deklarieren, geben Sie den Namen
des Cursors und die Anweisung an, auf die er sich bezieht.
$ Weitere Hinweise finden Sie unter "DECLARE CURSOR-
Anweisung [ESQL] [GP]" auf Seite 412 der Dokumentation ASA SQL-
Referenzhandbuch.
3 Öffnen Sie den Cursor.
$ Weitere Hinweise finden Sie unter "OPEN-Anweisung [ESQL]
[GP]" auf Seite 523 der Dokumentation ASA SQL-Referenzhandbuch.
17

Der Cursor
18
Bei der CALL-Anweisung wird durch das Öffnen des Cursors die
Abfrage bis zu dem Punkt ausgeführt, an dem die erste Zeile bezogen
werden kann.
4 Rufen Sie die Ergebnisse ab.
Obwohl eine einfache Abruf-Operation den Cursor in die nächste Zeile
der Ergebnismenge bewegt, ermöglicht Adaptive Server Anywhere auch
kompliziertere Bewegungen in der Ergebnismenge. Die verfügbaren
Abruf-Operationen hängen davon ab, wie Sie den Cursor deklarieren.
$ Weitere Hinweise finden Sie unter "FETCH-Anweisung [ESQL]
[GP]" auf Seite 458 der Dokumentation ASA SQL-Referenzhandbuch
und "Daten abrufen" auf Seite 214.
5 Schließen Sie den Cursor
Wenn Sie die Arbeit mit dem Cursor abgeschlossen haben, schließen Sie
ihn. Das löst etwaige Sperren auf den darunterliegenden Daten.
$ Weitere Hinweise finden Sie unter "CLOSE-Anweisung [ESQL]
[GP]" auf Seite 285 der Dokumentation ASA SQL-Referenzhandbuch.
6 Löschen Sie die Anweisung.
Um den Speicher freizugeben, der mit dem Cursor und der ihm
zugeordneten Anweisung verbunden war, müssen Sie die Anweisung
freigeben.
$ Weitere Informationen finden Sie unter "DROP STATEMENT-
Anweisung [ESQL]" auf Seite 439 der Dokumentation ASA SQL-
Referenzhandbuch.
v So verwenden Sie einen Cursor (ODBC, JDBC, Open Client):
1 Bereiten Sie eine Anweisung vor und führen Sie sie aus:
Führen Sie eine Anweisung mit der normalen Methode für die
Schnittstelle aus. Sie können die Anweisung vorbereiten und dann
ausführen, oder die Anweisung direkt ausführen.
2 Überprüfen Sie, ob die Anweisung eine Ergebnismenge zurückgibt.
Ein Cursor wird implizit geöffnet, wenn eine Anweisung ausgeführt
wird, die eine Ergebnismenge erstellt. Beim Öffnen eines Cursors wird
er vor die erste Zeile der Ergebnismenge gesetzt.
3 Rufen Sie die Ergebnisse ab.
Obwohl eine einfache Abruf-Operation den Cursor in die nächste Zeile
der Ergebnismenge bewegt, ermöglicht Adaptive Server Anywhere auch
kompliziertere Bewegungen in der Ergebnismenge.

Prefetch von Zeilen
Kapitel 2 SQL in Anwendungen verwenden
4 Schließen Sie den Cursor
Wenn Sie die Arbeit mit dem Cursor abgeschlossen haben, schließen Sie
ihn, damit die ihm zugewiesenen Ressourcen freigegeben werden.
5 Geben Sie die Anweisung frei.
Wenn Sie eine vorbereitete Anweisung verwendet haben, geben Sie sie
frei, um den benutzten Speicher wieder verfügbar zu machen.
In manchen Fällen kann die Interface-Bibliothek Performance-
Optimierungen im Hintergrund durchführen (z.B. Prefetch von Ergebnissen),
sodass diese Schritte in der Clientanwendung möglicherweise nicht den
Vorgängen in der Software entsprechen.
19

Mit Cursorn arbeiten
Mit Cursorn arbeiten
Cursor positionieren
20
In diesem Abschnitt wird beschrieben, wie bestimmte Cursorvorgänge
ausgeführt werden.
Wird ein Cursor geöffnet, ist er vor der ersten Zeile positioniert. Sie können
den Cursor an eine absolute Position in Verhältnis zum Anfang oder zum
Ende der Abfrageergebnisse positionieren oder ihn relativ zur aktuellen
Cursor-Position verschieben. Wie Sie im Einzelnen den Cursor verschieben
und welche Operationen möglich sind, hängt von der
Programmierschnittstelle ab.
Die Anzahl der Zeilenpositionen, die Sie mit einem Fetch-Vorgang abrufen
können, wird durch die Größe einer Ganzzahl bestimmt. Mit einem Fetch-
Vorgang können Sie Zeilen bis zu Nummer 2147483646 abrufen, wobei es
sich um die größtmögliche Ganzzahl minus 1 handelt. Wenn Sie negative
Werte verwenden (Zeilen in Bezug auf das Ende), können Sie Fetch-
Vorgänge nach unten bis zum kleinsten negativen Wert, der in einer
Ganzzahl möglich ist, plus 1 ausführen.
Sie können spezielle positionsbasierte Aktualisierungs- oder
Löschungsoperationen verwenden, um die Zeile an der aktuellen
Cursorposition zu aktualisieren oder zu löschen. Ist der Cursor vor der ersten
Zeile oder nach der letzten Zeile positioniert, wird der Fehler No current row
of cursor zurückgeben.

Cursor beim Öffnen konfigurieren
Kapitel 2 SQL in Anwendungen verwenden
Probleme mit der Cursorpositionierung
Einfügungen und manche Aktualisierungsvorgänge mit nichtempfindlichen
Cursorn können Probleme mit der Positionierung von
Cursorn verursachen. Adaptive Server Anywhere platziert eingefügte
Zeilen an unvorhersehbaren Positionen innerhalb eines Cursors, falls die
SELECT-Anweisung keine ORDER BY-Klausel hat. In einigen Fällen
erscheint die eingefügte Zeile überhaupt nicht, bis der Cursor geschlossen
und wieder geöffnet wurde.
Bei Adaptive Server Anywhere passiert dies, wenn eine Arbeitstabelle
erstellt werden musste, um den Cursor zu öffnen (unter "Arbeitstabellen in
der Abfrageverarbeitung verwenden" auf Seite 178 der Dokumentation
ASA SQL-Benutzerhandbuch finden Sie eine diesbezügliche
Beschreibung).
Die UPDATE-Anweisung kann bewirken, dass sich eine Zeile im Cursor
verschiebt. Das passiert, wenn der Cursor eine ORDER BY-Klausel hat,
die einen vorhandenen Index benutzt (es wird keine Arbeitstabelle
erstellt). Mit der Verwendung eines statisch abrollenden Cursors werden
diese Probleme vermieden, allerdings ist mehr Speicher und
Verarbeitungsaufwand erforderlich.
Sie können die folgenden Aspekte des Cursorverhaltens konfigurieren, wenn
Sie einen Cursor öffnen:
♦ Isolationsstufe Sie können die Isolationsstufen der Vorgänge für einen
Cursor explizit so setzen, dass sie von der aktuellen Isolationsstufe der
Transaktion verschieden sind. Dazu stellen Sie die
ISOLATION_LEVEL-Option ein.
$ Weitere Informationen finden Sie unter "ISOLATION_LEVEL-
Option" auf Seite 637 der Dokumentation ASA
Datenbankadministration.
♦ Offen halten Standardmäßig werden Cursor in Embedded SQL am Ende
einer Transaktion geschlossen. Wenn Sie einen Cursor mit der WITH
HOLD-Option öffnen, können Sie ihn offen halten, bis die Verbindung
beendet wird oder bis Sie ihn explizit schließen. ODBC, JDBC und
Open Client lassen Cursor beim Ende von Transaktionen standardmäßig
geöffnet.
21

Mit Cursorn arbeiten
Zeilen durch einen Cursor abrufen
Mehrere Zeilen abrufen
22
Die einfachste Art, eine Ergebnismenge aus einer Abfrage mit einem Cursor
zu verarbeiten, ist eine Schleife zum Absuchen aller Zeilen in der
Ergebnismenge, bis keine Zeilen mehr vorhanden sind.
v So führen Sie einen Schleifendurchlauf auf Zeilen einer
Ergebnismenge durch:
1 Deklarieren und öffnen Sie den Cursor (Embedded SQL), oder führen
Sie eine Anweisung aus, die eine Ergebnismenge zurückgibt (ODBC,
JDBC, Open Client).
2 Setzen Sie die Fetch-Vorgänge für die nächste Zeile fort, bis der Fehler
Zeile nicht gefunden (Row Not Found) erscheint.
3 Schließen Sie den Cursor
Die Ausführung des zweiten Schrittes hängt davon ab, welche Schnittstelle
Sie verwenden. Zum Beispiel:
♦ ODBC SQLFetch, SQLExtendedFetch oder SQLFetchScroll
verschieben den Cursor in die nächste Zeile und geben die Daten zurück.
$ Weitere Hinweise zur Verwendung eines Cursors in ODBC finden
Sie unter "Mit Ergebnismengen arbeiten" auf Seite 299.
♦ Embedded SQL Die FETCH-Anweisung führt dieselbe Operation aus.
$ Weitere Hinweise über die Verwendung von Cursorn in Embedded
SQL finden Sie unter "Cursor in Embedded SQL verwenden" auf
Seite 215.
♦ JDBC Die next-Methode des ResultSet-Objekts bewegt den Cursor
weiter und gibt die Daten zurück.
$ Weitere Hinweise zur Verwendung des ResultSet-Objekts in
JDBC finden Sie unter "Abfragen mit JDBC" auf Seite 169.
♦ Open Client Die ct_fetch-Funktion verschiebt den Cursor in die nächste
Zeile und gibt die Daten zurück.
$ Weitere Hinweise zur Verwendung eines Cursors in Open Client-
Anwendungen finden Sie unter "Cursor verwenden" auf Seite 395.
In diesem Abschnitt wird besprochen, wie Sie mehrere Zeilen mit einem
Fetch-Vorgang abrufen können.

Mehrzeilen-Fetch-
Vorgänge
Mehrzeilen-Fetch-
Vorgänge
verwenden
Fetch mit abrollendem Cursor
Kapitel 2 SQL in Anwendungen verwenden
Der mehrzeilige Abruf darf nicht mit dem Vorab-Abrufen von Zeilen
verwechselt werden, was im nächsten Abschnitt beschrieben wird.
Mehrzeilen-Abrufe werden von der Anwendung durchgeführt, während ein
Vorab-Abrufen für die Anwendung nicht erkennbar ist und eine ähnliche
Performance-Steigerung bietet.
Einige Schnittstellen bieten Methoden zum gleichzeitigen Abrufen mehrerer
Zeilen in die nächsten Felder eines Rasters. Im Allgemeinen gilt: Je weniger
getrennte Fetch-Vorgänge Sie ausführen, desto weniger einzelne
Anforderungen muss der Server bewältigen, und desto besser wird die
Performance. Eine modifizierte FETCH-Anweisung, die mehrere Zeilen
abruft, wird auch ein weiter Abruf genannt. Ein Cursor, der Mehrzeilen-
Abrufe ausführt, wird manchmal auch als Block-Cursor (Blockcursor) oder
fat cursor (Fetter Cursor) bezeichnet.
♦ In ODBC können Sie die Anzahl der Zeilen einstellen, die bei jedem
Aufruf von SQLFetchScroll oder SQLExtendedFetch zurückgegeben
werden, indem Sie das Attribut SQL_ROWSET_SIZE setzen.
♦ In Embedded SQL verwendet die FETCH-Anweisung eine ARRAY-
Klausel, um die Anzahl der Zeilen zu steuern, die durch einen Fetch-
Vorgang gleichzeitig abgerufen werden.
♦ Open Client und JDBC unterstützen mehrzeilige Fetch-Vorgänge nicht.
Sie verwenden Prefetch-Vorgänge.
ODBC und Embedded SQL bieten Methoden für den Einsatz abrollender
beziehungsweise dynamisch abrollender Cursortypen. Diese Methoden
ermöglichen das gleichzeitige Vorwärtsbewegen oder Rückwärtsbewegen
über mehrere Zeilen in einer Ergebnismenge.
Die JDBC- und Open Client-Schnittstellen unterstützen keine abrollenden
Cursor.
Prefetch-Vorgänge sind auf Vorgänge mit einem abrollenden Cursor nicht
anwendbar. Zum Beispiel werden beim Abrufen einer Zeile in
entgegengesetzter Richtung nicht mehrere vorherige Zeilen abgerufen.
23

Mit Cursorn arbeiten
Zeilen mit einen Cursor ändern
Aus welcher
Tabelle werden
Zeilen gelöscht?
24
Cursor können mehr als nur Ergebnisse aus einer Abfrage lesen. Sie können
auch Daten in der Datenbank verändern, während Sie einen Cursor
verarbeiten. Diese Vorgänge werden im Allgemeinen als positionsbasierte
oder positionierte Aktualisierungs- und Löschvorgänge oder PUT-Vorgänge
(wenn es sich um ein INSERT handelt) bezeichnet.
Nicht alle Abfrage-Ergebnismengen ermöglichen positionsbasiertes
Aktualisieren oder Löschen. Wenn Sie eine Abfrage in einer nicht
aktualisierbaren Ansicht ausführen, werden in den Basistabellen keine
Änderungen durchgeführt. Auch wenn die Abfrage einen Join enthält,
müssen Sie angeben, aus welcher Tabelle Sie löschen wollen oder welche
Spalten Sie aktualisieren wollen, wenn Sie die Vorgänge ausführen.
Einfügungen durch einen Cursor können nur durchgeführt werden, wenn
nicht eingefügte Spalten in der Tabelle NULLWERTE zulassen oder
Standardwerte haben.
ODBC, Embedded SQL und Open Client ermöglichen die Datenänderung
mit einem Cursor, JDBC 1.1 hingegen nicht. Mit dem Open Client können
Sie Zeilen löschen und aktualisieren, aber Zeilen nur in einer Ein-
Tabellenabfrage einfügen.
Wenn Sie ein positionsbasiertes Löschen durch einen Cursor versuchen, wird
die Tabelle, aus der Zeilen gelöscht werden, wie folgt festgelegt:
1 Wenn keine FROM-Klausel in der DELETE-Anweisung eingeschlossen
ist, muss der Cursor nur für eine Tabelle gesetzt sein.
2 Wenn der Cursor für eine Join-Abfrage (einschließlich zum Benutzen
einer Ansicht mit enthaltenem Join) gesetzt ist, muss die FROM-Klausel
verwendet werden. Nur die aktuelle Zeile der angegebenen Tabelle wird
gelöscht. Die anderen Tabellen des Joins sind nicht betroffen.
3 Wenn eine FROM-Klausel enthalten ist und kein Tabelleneigentümer
angegeben wurde, ist der Tabellenangabewert der erste, der zu den
Korrelationsnamen passt.
$ Weitere Hinweise finden Sie unter "FROM-Klausel" auf Seite 467
der Dokumentation ASA SQL-Referenzhandbuch.
4 Wenn ein Korrelationsname existiert, ist der Tabellenangabename mit
dem Korrelationsnamen identifiziert.
5 Wenn ein Korrelationsname nicht vorhanden ist, muss der
Tabellenangabewert eindeutig als Tabellenname im Cursor
identifizierbar sein.

Cursorvorgänge abbrechen
Kapitel 2 SQL in Anwendungen verwenden
6 Wenn eine FROM-Klausel enthalten ist und ein Tabelleneigentümer
angegeben wurde, muss der Tabellenangabewert als Tabellenname im
Cursor eindeutig identifizierbar sein.
7 Die positionsbasierte DELETE-Anweisung kann für einen Cursor
verwendet werden, der auf eine Ansicht geöffnet ist, solange die Ansicht
aktualisierbar ist.
Sie können eine Anforderung durch eine Schnittstellenfunktion abbrechen. In
Interactive SQL können Sie eine Anforderung durch Klicken auf die
Schaltfläche "SQL-Anweisung unterbrechen" in der Symbolleiste abbrechen
(oder durch den Befehl "Stop" im SQL-Menü).
Wenn Sie eine Anforderung abbrechen, die eine Cursoroperation durchführt,
ist die Position des Cursors unbestimmt. Nach dem Abbrechen der
Anforderung müssen Sie die absolute Position des Cursors ermitteln oder ihn
schließen.
25

Cursortypen auswählen
Cursortypen auswählen
Cursorverfügbarkeit
Cursoreigenschaften
26
Dieser Abschnitt beschreibt Zuordnungen zwischen Adaptive Server
Anywhere-Cursorn und den Optionen, die Ihnen die
Programmierschnittstellen bieten, die von Adaptive Server Anywhere
unterstützt werden.
$ Hinweise zu Adaptive Server Anywhere-Cursorn finden Sie unter
"Adaptive Server Anywhere-Cursor" auf Seite 30.
Nicht alle Schnittstellen bieten Unterstützung für alle Cursortypen.
♦ ODBC und OLE DB (ADO) unterstützen alle Cursortypen.
$ Weitere Hinweise finden Sie unter "Mit Ergebnismengen arbeiten"
auf Seite 299.
♦ Embedded SQL unterstützt alle Cursortypen.
♦ Für JDBC:
♦ jConnect 4.x stellt nur asensitive (nicht empfindliche) Cursor zur
Verfügung.
♦ jConnect 5.x unterstützt alle Cursortypen, bei abrollbaren Cursorn
kommt es jedoch zu erheblichen Performance-Einbußen.
♦ Die JDBC-ODBC-Brücke unterstützt alle Cursortypen.
♦ Sybase Open Client unterstützt lediglich asensitive (nicht empfindliche)
Cursor. Außerdem kommt es zu erheblichen Performance-Einbußen,
wenn aktualisierbare, nicht eindeutige Cursor benutzt werden.
Sie fordern einen Cursortyp entweder explizit oder implizit von der
Programmierschnittstelle an. Unterschiedliche Schnittstellenbibliotheken
bieten eine unterschiedliche Auswahl von Cursortypen an. JDBC und
ODBC schreiben zum Beispiel unterschiedliche Cursortypen vor.
Jeder Cursortyp wird duch eine Reihe von Eigenschaften definiert:

Kapitel 2 SQL in Anwendungen verwenden
♦ Eindeutigkeit Wenn ein Cursor als eindeutig deklariert wird, zwingt
dies die Abfrage, alle Spalten zurückzugeben, die für die eindeutige
Identifizierung der einzelnen Zeilen erforderlich sind. Oft bedeutet dies,
dass alle Spalten im Primärschlüssel zurückgegeben werden. Alle
erforderlichen, aber nicht angegebenen Spalten werden der
Ergebnismenge hinzugefügt. Der Standardcursortyp ist "Nicht
eindeutig".
♦ Aktualisierbarkeit Ein als schreibgeschützt deklarierter Corsor kann
nicht für eine positionierte Aktualisierung oder Löschung verwendet
werden. Der Standardcursortyp ist "Aktualisierbar".
♦ Abrollfähigkeit Sie können Cursor so deklarieren, dass Sie sich
unterschiedlich verhalten, wenn Sie sich durch die Ergebnismenge
bewegen. Manche Cursor können nur die aktuelle oder die nächste Zeile
abrufen. Andere können sich vorwärts und rückwärts in der
Ergebnismenge bewegen.
♦ Empfindlichkeit Änderungen an der Datenbank können durch einen
Cursor sichtbar sein, müssen es aber nicht.
Diese Eigenschaften haben möglicherweise signifikante Auswirkungen auf
Performance und Datenbankserver-Speicherzuordnung.
Adaptive Server Anywhere stellt Ihnen Cursor mit unterschiedlichen
Zusammensetzungen dieser Eigenschaften zur Verfügung. Wenn Sie einen
Corsor eines gegebenen Typs anfordern, versucht Adaptive Server
Anywhere, diese Eigenschaften so gut wie möglich zuzuordnen. Wie
Adaptive Server Anywhere-Cursor den in den Programmierschnittstellen
festgelegten Cursorn im Einzelnen entsprechen, ist das Thema der folgenden
Abschnitte.
Unter Umständen ist es nicht möglich, allen Eigenschaften zu entsprechen.
Unempfindliche Cursor in Adaptive Server Anywhere zum Beispiel müssen
schreibgeschützt sein, aus den weiter unten angeführten Gründen. Wenn Ihre
Anwendung einen aktualisierbaren unempfindlichen Cursor anfordert, wird
statt dessen ein anderer Cursortyp (Wert-empfindlich) geliefert.
Adaptive Server Anywhere-Cursor anfordern
Wenn Sie einen Cursortyp von Ihrer Clientanwendung aus anfordern, liefert
Adaptive Server Anywhere einen Cursor. Adaptive Server Anywhere-Cursor
werden nicht durch den in der Programmierschnittstelle festgelegten Typ
definiert, sondern durch die Empfindlichkeit der Ergebnismenge auf
Änderungen in den darunter liegenden Daten. Abhängig vom verlangten
Cursortyp liefert Adaptive Server Anywhere einen Cursor mit einem
Verhalten, das dem Typ entspricht.
27

Cursortypen auswählen
ODBC und OLE DB
Ausnahmen
Embedded SQL
28
Die Empfindlichkeit der Adaptive Server Anywhere-Cursorn wird
entsprechend der Cursortyp-Anfrage des Clients gesetzt.
Die nachstehende Tabelle beschreibt die Cursorempfindlichkeit, die bei
verschiedenen abrollbaren ODBC-Cursortypen eingestellt wird.
Abrollbarer ODBC-Cursortyp Adaptive Server Anywhere-Cursor
STATIC Insensitive (Unempfindlich)
KEYSET Wertempfindlich
DYNAMIC Sensitiv (Empfindlich)
MIXED Wertempfindlich
$ Hinweise zu Adaptive Server Anywhere-Cursorn und ihrem Verhalten
finden Sie unter "Adaptive Server Anywhere-Cursor" auf Seite 30. Hinweise
über das Anfordern eines Cursortyps in ODBC finden Sie unter "Cursor-
Eigenschaften wählen" auf Seite 299.
Wenn Sie einen STATIC-Cursor als aktualisierbar anfordern, wird statt
dessen ein Wert-empfindlicher Cursor geliefert und eine Warnung
ausgegeben.
Wenn ein DYNAMIC- oder MIXED-Cursor angefordert wird und die
Abfrage nicht ohne Arbeitstabellen ausgeführt werden kann, wird statt
dessen ein nicht-empfindlicher Cursor geliefert und eine Warnung
ausgegeben.
Um einen Cursor von einer Embedded SQL-Anwendung anzufordern, geben
Sie den Cursortyp in der DECLARE-Anweisung an. Die nachstehende
Tabelle beschreibt die Cursorempfindlichkeit, die als Antwort auf
unterschiedliche Anforderungen eingestellt wird.
Cursortyp Adaptive Server Anywhere-Cursor
NO SCROLL Asensitiv (Nicht empfindlich)
DYNAMIC SCROLL Asensitive (Nicht empfindlich)
SCROLL Wertempfindlich
INSENSITIVE Insensitive (Unempfindlich)
SENSITIVE Sensitive (Empfindlich)

Ausnahmen
JDBC
Open Client
Lesezeichen und Cursor
Block-Cursor
Kapitel 2 SQL in Anwendungen verwenden
Wenn Sie einen DYNAMIC SCROLL- oder NO SCROLL-Cursor als
UPDATABLE anfordern, wird ein empfindlicher oder wertempfindlicher
Cursor geliefert. Es ist nicht ausgemacht, welcher der Beiden geliefert wird.
Diese Ungewissheit entspricht der Definition von nicht-empfindlichem
Verhalten.
Wenn Sie einen INSENSITIVE-Cursor als UPDATABLE anfordern, wird
ein wertempfindlicher Cursor geliefert.
Wenn Sie einen DYNAMIC SCROLL-Cursor anfordern, die PREFETCH-
Datenbankoption auf OFF eingestellt ist und der Ausführungsplan der
Abfrage keine Arbeitstabellen verlangt, wird möglicherweise ein
empfindlicher Cursor geliefert. Wieder entspricht diese Ungewissheit der
Definition von nicht-empfindlichem Verhalten.
Es steht nur ein Typ von Cursorn für JDBC-Anwendungen zur Verfügung.
Dies ist ein nicht-empfindlicher Cursor. In JDBC können Sie eine
ExecuteQuery-Anweisung ausführen, um einen Cursor zu öffnen.
Es steht nur ein Typ von Cursorn für JDBC-Anwendungen zur Verfügung.
Das ist ein nicht-empfindlicher Cursor.
ODBC bietet Lesezeichen an bzw. Werte zum Identifizieren von Zeilen in
einem Cursor. Adaptive Server Anywhere unterstützt Lesezeichen für alle
Arten von Cursorn, mit Ausnahme von dynamischen Cursorn.
ODBC stellt einen Cursortyp namens Block-Cursor zur Verfügung. Wenn
Sie einen solchen Block-Cursor verwenden, können Sie SQLFetchScroll
oder SQLExtendedFetch benutzen, um einen Zeilenblock und nicht eine
einzelne Zeile abzurufen. Block-Cursor verhalten sich genauso wie
Embedded SQL ARRAY-Abrufe.
29

Adaptive Server Anywhere-Cursor
Adaptive Server Anywhere-Cursor
Änderungen bei
Mitgliedschaft,
Reihenfolge und
Werten
30
Sobald ein Cursor geöffnet ist, hat er eine zugeordnete Ergebnismenge. Der
Cursor bleibt eine Zeit lang geöffnet. Während dieser Zeit kann die dem
Cursor zugeordnete Ergebnismenge geändert werden, entweder durch den
Cursor selbst oder, abhängig von den Anforderungen der Isolationsstufe,
durch andere Transaktionen. Manche Cursor ermöglichen es, Änderungen an
den darunter liegenden Daten sichtbar zu machen, während bei Anderen
diese Änderungen nicht auszumachen sind. Das unterschiedliche Verhalten
von Cursorn in Bezug auf Änderungen an den darunter liegenden Daten wird
die Empfindlichkeit des Cursors genannt.
Adaptive Server Anywhere stellt Cursor mit einer Vielzahl von
Empfindlichkeitseigenschaften zur Verfügung. Dieser Abschnitt beschreibt,
was Empfindlichkeit ist, sowie die Empfindlichkeitseigenschaften von
Cursorn.
Dabei wird vorausgesetzt, dass Sie mit dem Abschnitt "Was sind Cursor?"
auf Seite 15 vertraut sind.
Änderungen an den darunter liegenden Daten können sich folgendermaßen
auf die Ergebnismenge eines Cursors auswirken:
♦ Mitgliedschaft Die Menge der Zeilen in der Ergebnismenge, die durch
ihre Primärschlüsselwerte gekennzeichnet sind.
♦ Reihenfolge Die Reihenfolge der Zeilen in der Ergebnismenge.
♦ Wert Die Werte der Zeilen in der Ergebnismenge.
Nehmen Sie zum Beispiel die folgende einfache Tabelle mit Mitarbeiterdaten
(emp_id ist die Primärschlüsselspalte):
emp_id emp_lname
1 Whitney
2 Cobb
3 Chin
Ein Cursor auf der folgenden Abfrage gibt alle Ergebnisse aus der Tabelle in
der Reihenfolge des Primärschlüssels zurück.
SELECT emp_id, emp_lname
FROM employee
ORDER BY emp_id

Sichtbare und
unsichtbare
Änderungen
Kapitel 2 SQL in Anwendungen verwenden
Die Mitgliedschaft der Ergebnismenge könnte durch das Hinzufügen einer
neuen Zeile oder das Löschen einer Zeile geändert werden. Die Werte
könnten durch eine Namensänderung in der Tabelle geändert werden. Die
Reihenfolge könnte geändert werden, indem der Primärschlüssel eines
Mitarbeiters geändert wird.
Abhängig von den Anforderungen der Isolationsstufe können Mitgliedschaft,
Reihenfolge und Werte der Ergebnismenge eines Cursors geändert werden,
nachdem der Cursor geöffnet wurde. Es hängt vom Typ des verwendeten
Cursors ab, ob sich die Ergebnismenge, wie sie von der Anwendung gesehen
wird, ändert, um diese Änderungen darzustellen.
Änderungen an den darunter liegenden Daten können durch den Cursor
sichtbar oder unsichtbar sein. Eine sichtbare Änderung ist eine, die sich in
der Ergebnismenge des Cursors wiederspiegelt. Änderungen an den darunter
liegenden Daten, die nicht in der Ergebnismenge, wie sie vom Cursor
gesehen wird, wiedergespiegelt werden, sind unsichtbar.
Überblick über die Cursor-Empfindlichkeit
Adaptive Server Anywhere-Cursor werden anhand ihrer Empfindlichkeit
gegenüber Änderungen an den darunter liegenden Daten eingeteilt. Im
Besonderen wird die Cursor-Empfindlichkeit anhand der Sichtbarkeit von
Änderungen definiert.
♦ Unempfindliche Cursor Die Ergebnismenge ist unveränderlich, wenn
der Cursor geöffnet ist. Änderungen an den darunter liegenden Daten
sind nicht sichtbar.
$ Weitere Hinweise finden Sie unter "Unempfindliche Cursor" auf
Seite 36.
♦ Empfindliche Cursor Die Ergebnismenge kann sich ändern, nachdem
der Cursor geöffnet wurde. Alle Änderungen an den darunter liegenden
Daten sind sichtbar.
$ Weitere Hinweise finden Sie unter "Empfindliche Cursor" auf
Seite 37.
♦ Nicht-empfindliche Cursor Änderungen können in der Mitgliedschaft,
der Reihenfolge oder den Werten der Ergebnismenge, wie sie durch den
Cursor gesehen wird, wiedergespiegelt werden, müssen es aber nicht.
$ Weitere Hinweise finden Sie unter "Nicht-empfindliche Cursor"
auf Seite 39.
♦ Wert-empfindliche Cursor Änderungen in der Reihenfolge oder den
Werten der darunter liegenden Daten sind sichtbar. Die Mitgliedschaft
der Ergebnismenge ist unveränderlich, wenn der Cursor geöffnet ist.
31

Adaptive Server Anywhere-Cursor
32
$ Weitere Hinweise finden Sie unter "Wert-empfindliche Cursor" auf
Seite 40.
Die unterschiedlichen Anforderungen an Cursor bewirken unterschiedliche
Beschränkungen bei der Ausführung, was sich wiederum auf die
Performance auswirkt. Weitere Hinweise finden Sie unter "Cursor-
Empfindlichkeit und Performance" auf Seite 43.
Beispiel für Cursor-Empfindlichkeit: Eine gelöschte Zeile
Dieses Beispiel verwendet eine einfache Abfrage, um zu illustrieren, wie
verschiedene Cursor auf eine Zeile in der Ergebnismenge reagieren, die
gelöscht wird.
Es gibt die folgende Abfolge von Ereignissen:
1 Eine Anwendung öffnet einen Cursor auf der folgenden Abfrage auf der
Beispieldatenbank.
SELECT emp_id, emp_lname
FROM employee
ORDER BY emp_id
emp_id emp_lname
102 Whitney
105 Cobb
160 Breault
… …
2 Die Anwendung ruft die erste Zeile durch den Cursor ab (102).
3 Die Anwendung ruft die nächste Zeile durch den Cursor ab (105).
4 Eine weitere Anwendung löscht Mitarbeiter 102 (Whitney) und schreibt
die Änderung fest.
In dieser Situation hängen die Ergebnisse der Cursor-Aktionen von der
Cursor-Empfindlichkeit ab.
♦ Unempfindliche Cursor Das DELETE wird weder in der Mitgliedschaft
noch in den Werten der Ergebnissen, wie sie durch den Cursor gesehen
werden, wiedergespiegelt:

Maßnahme Ergebnis
Vorherige Zeile
abrufen
Erste Zeile abrufen
(absoluter Abruf)
Zweite Zeile abrufen
(absoluter Abruf)
Kapitel 2 SQL in Anwendungen verwenden
Gibt die ursprüngliche Kopie der Zeile zurück
(102).
Gibt die ursprüngliche Kopie der Zeile zurück
(102).
Gibt die ungeänderte Zeile zurück (105).
♦ Empfindliche Cursor Die Mitgliedschaft der Ergebnismenge hat sich
insofern geändert, dass jetzt Zeile 105 die erste Zeile in der
Ergebnismenge ist:
Maßnahme Ergebnis
Vorherige Zeile
abrufen
Erste Zeile abrufen
(absoluter Abruf)
Zweite Zeile abrufen
(absoluter Abruf)
Gibt den Fehler Zeile nicht gefunden zurück. Es
gibt keine vorherige Zeile.
Gibt Zeile 105 zurück.
Gibt Zeile 160 zurück.
♦ Wert-empfindliche Cursor Die Mitgliedschaft der Ergebnismenge ist
unveränderlich, und daher ist Zeile 105 weiterhin die zweite Zeile in der
Ergebnismenge. Das DELETE wird in den Werten des Cursors
wiedergespiegelt und erzeugt ein tatsächliches "Loch" in der
Ergebnismenge.
Maßnahme Ergebnis
Vorherige Zeile
abrufen
Erste Zeile abrufen
(absoluter Abruf)
Zweite Zeile abrufen
(absoluter Abruf)
Gibt Keine aktuelle Cursorzeile zurück. Wo
vorher die erste Zeile war, steht jetzt im Cursor
eine Lücke.
Gibt Keine aktuelle Cursorzeile zurück. Wo
vorher die erste Zeile war, steht jetzt im Cursor
eine Lücke.
Gibt Zeile 105 zurück.
33

Adaptive Server Anywhere-Cursor
34
♦ Nicht-empfindliche Cursor Die Mitgliedschaft und Werte der
Ergebnismenge sind in Bezug auf die Änderungen unbestimmt. Die
Antwort auf einen Abruf der vorherigen Zeile, der ersten Zeile oder der
zweiten Zeile hängt von der entsprechenden Optimierungsmethode für
die Abfrage ab. Die Antwort hängt davon ab, ob die Methode die
Erstellung einer Arbeitstabelle erfordert und ob die abgerufene Zeile
vom Client vorab abgerufen wurde.
Der Vorteil von nicht-empfindlichen Cursorn liegt darin, dass für viele
Anwendungen die Empfindlichkeit unwichtig ist. Besonders wenn Sie
einen schreibgeschützten Vorwärts-Cursor verwenden, sind keine der
darunter liegenden Änderungen sichtbar. Auch wenn Sie auf einer hohen
Isolationsstufe ausführen, sind darunter liegende Änderungen nicht
zulässig.
Beispiel für Cursor-Empfindlichkeit: Eine aktualisierte Zeile
Dieses Beispiel verwendet eine einfache Abfrage, um zu illustrieren wie
verschiedene Cursortypen auf eine Zeile in der Ergebnismenge reagieren, die
aktualisiert wird und dadurch die Reihenfolge in der Ergebnismenge
verändert.
Es gibt die folgende Abfolge von Ereignissen:
1 Eine Anwendung öffnet einen Cursor auf der folgenden Abfrage auf der
Beispieldatenbank.
SELECT emp_id, emp_lname
FROM employee
emp_id emp_lname
102 Whitney
105 Cobb
160 Breault
… …
2 Die Anwendung ruft die erste Zeile durch den Cursor ab (102).
3 Die Anwendung ruft die nächste Zeile durch den Cursor ab (105).
4 Eine weitere Transaktion aktualisiert die Mitarbeiter-ID des Mitarbeiters
102 (Whitney) auf 165 und schreibt die Änderung fest.
In dieser Situation hängen die Ergebnisse der Cursor-Aktionen von der
Cursor-Empfindlichkeit ab.

Kapitel 2 SQL in Anwendungen verwenden
♦ Unempfindliche Cursor Das UPDATE wird weder in der
Mitgliedschaft noch in den Werten der Ergebnisse, wie sie durch den
Cursor gesehen werden, wiedergespiegelt:
Maßnahme Ergebnis
Vorherige Zeile
abrufen
Erste Zeile abrufen
(absoluter Abruf)
Zweite Zeile abrufen
(absoluter Abruf)
Gibt die ursprüngliche Kopie der Zeile zurück
(102).
Gibt die ursprüngliche Kopie der Zeile zurück
(102).
Gibt die ungeänderte Zeile zurück (105).
♦ Empfindliche Cursor Die Mitgliedschaft der Ergebnismenge hat sich
insofern geändert, dass jetzt Zeile 105 die erste Zeile in der
Ergebnismenge ist:
Maßnahme Ergebnis
Vorherige Zeile
abrufen
Erste Zeile abrufen
(absoluter Abruf)
Zweite Zeile abrufen
(absoluter Abruf)
Gibt den Fehler Zeile nicht gefunden zurück.
Die Mitgliedschaft der Ergebnismenge hat sich
geändert und 105 ist jetzt die erste Zeile. Der
Cursor wird auf die Position vor der ersten Zeile
verschoben.
Gibt Zeile 105 zurück.
Gibt Zeile 160 zurück.
Außerdem wird beim Abrufen durch einen empfindlichen Cursor die
Warnung SQLE_ROW_UPDATED_WARNING ausgegeben, wenn die
Zeile seit dem letzten Lesen geändert wurde. Die Warnung wird nur
einmal ausgegeben. Aufeinander folgende FETCH-Vorgänge für
dieselbe Zeile lösen keine Warnung aus.
Ähnlich gibt auch eine positionsbasierte UPDATE- oder DELETE-
Anweisung durch den Cursor auf einer Zeile, die seit dem letzten Abruf
geändert wurde, die Fehlermeldung
SQLE_ROW_UPDATED_SINCE_READ aus. Eine Anwendung muss
das Abrufen einer Zeile nochmals durchführen, damit UPDATE oder
DELETE bei einem empfindlichen Cursor funktionieren.
Eine Aktualisierung einer Spalte bewirkt die Warnung oder den Fehler,
auch wenn die Spalte vom Cursor nicht referenziert wird. Beispiel: Ein
Cursor auf einer Abfrage, der emp_lname zurückgibt, würde die
Aktualisierung melden, auch wenn nur die Spalte salary geändert
worden wäre.
35

Adaptive Server Anywhere-Cursor
Unempfindliche Cursor
Standards
36
♦ Wert-empfindliche Cursor Die Mitgliedschaft der Ergebnismenge ist
unveränderlich, und daher ist Zeile 105 weiterhin die zweite Zeile in der
Ergebnismenge. Das DELETE wird in den Werten des Cursors
wiedergespiegelt und erzeugt ein tatsächliches "Loch" in der
Ergebnismenge.
Maßnahme Ergebnis
Vorherige Zeile
abrufen
Erste Zeile abrufen
(absoluter Abruf)
Zweite Zeile abrufen
(absoluter Abruf)
Gibt den Fehler Zeile nicht gefunden zurück.
Die Mitgliedschaft der Ergebnismenge hat sich
geändert und 105 ist jetzt die erste Zeile. Der
Cursor wird über dem Loch positioniert: Er
befindet sich vor Zeile 105.
Gibt den Fehler Zeile nicht gefunden zurück.
Die Mitgliedschaft der Ergebnismenge hat sich
geändert und 105 ist jetzt die erste Zeile. Der
Cursor wird über dem Loch positioniert: Er
befindet sich vor Zeile 105.
Gibt Zeile 105 zurück.
♦ Nicht-empfindliche Cursor Die Mitgliedschaft und Werte der
Ergebnismenge sind in Bezug auf die Änderungen unbestimmt. Die
Antwort auf einen Abruf der vorherigen Zeile, der ersten Zeile oder der
zweiten Zeile hängt von der entsprechenden Optimierungsmethode für
die Abfrage ab, ob die Methode die Erstellung einer Arbeitstabelle
erfordert und ob die abgerufene Zeile vom Client vorab abgerufen
wurde.
Keine Warnungen oder Fehler in Massenvorgängen
Warnungs- und Fehlerbedingungen für Aktualisierungen kommen in
Massenvorgängen nicht vor (Option -b für Datenbankserver).
Diese Cursor haben unempfindliche Mitgliedschaft, Reihenfolge und Werte.
Keine Änderungen, die nach dem Öffnen des Cursors durchgeführt werden,
sind sichbar.
Unempfindliche Cursor werden nur für schreibgeschützte Cursortypen
verwendet.
Unempfindliche Cursor entsprechen der ISO/ANSI-Standarddefinition von
unempfindlichen Cursorn beziehungsweise den statischen ODBC-Cursorn.

Programmierschnittstellen
Beschreibung
Empfindliche Cursor
Standards
Schnittstelle Cursortyp Kommentar
ODBC, OLE DB
und ADO
Embedded SQL INSENSITIVE
oder NO
SCROLL
JDBC Nicht unterstützt
Open Client Nicht unterstützt
Kapitel 2 SQL in Anwendungen verwenden
Static Wenn ein aktualisierbarer statischer
Cursor angefordert wird, wird statt
dessen ein Wert-empfindlicher Cursor
verwendet.
Unempfindliche Cursor geben immer Zeilen zurück, die den
Auswahlkriterien der Abfrage entsprechen, und zwar in der durch eine
ORDER BY-Klausel festgelegte Reihenfolge.
Die Ergebnismenge eines unempfindlichen Cursors wird vollständig als
Arbeitstabelle materialisiert, wenn der Cursor geöffnet wird. Das hat
folgende Konsequenzen:
♦ Wenn die Ergebnismenge sehr umfangreich ist, sind die Festplatten- und
Speicheranforderungen zum Verwalten des Ergebnisses möglicherweise
von Bedeutung.
♦ Keine Zeile wird an die Anwendung zurückgegeben, bevor nicht die
gesamte Ergebnismenge als eine Arbeitstabelle zusammengestellt ist.
Bei komplexen Abfragen kann das zu einer Verzögerung führen, bevor
die erste Zeile an die Anwendung zurückgegeben wird.
♦ Nachfolgende Zeilen können direkt von der Arbeitstabelle abgerufen
werden, und werden daher rasch ausgegeben. Die Client-Bibliothek
kann mehrere Zeilen gleichzeitig vorab abrufen, was die Performance
weiter steigert.
♦ Unempfindliche Cursor sind von ROLLBACK oder ROLLBACK TO
SAVEPOINT nicht betroffen.
Diese Cursor haben empfindliche Mitgliedschaft, Reihenfolge und Werte.
Empfindliche Cursor können für schreibgeschützte oder aktualisierbare
Cursortypen verwendet werden.
Empfindliche Cursor entsprechen der ISO/ANSI-Standarddefinition von
empfindlichen Cursorn beziehungsweise den dynamischen ODBC-Cursorn.
37

Adaptive Server Anywhere-Cursor
Programmierschnittstellen
Beschreibung
38
Schnittstelle Cursortyp Kommentar
ODBC, OLE DB
und ADO
Dynamic
Embedded SQL SENSITIVE Wird auch als Antwort auf eine Anfrage
nach einem DYNAMIC SCROLL-Cursor
geliefert, wenn keine Arbeitstabelle
erforderlich ist und PREFETCH auf OFF
eingestellt ist.
Alle Änderungen sind durch den Cursor sichtbar, sowohl die Änderungen
durch den Cursor als auch die durch andere Transaktionen. Höhere
Isolationsstufen können auf Grund von Sperren manche Änderungen
verbergen, die von anderen Transaktionen durchgeführt werden.
Alle Änderungen von Mitgliedschaft, Reihenfolge und Spaltenwerten des
Cursors sind sichtbar. Beispiel: Wenn ein empfindlicher Cursor einen Join
enthält und einer der Werte von einer der darunter liegenden Tabelle
geändert wird, dann zeigen alle Ergebniszeilen, die aus dieser Basiszeile
zusammengesetzt sind, den neuen Wert. Die Mitgliedschaft und Reihenfolge
der Ergebnismenge können sich bei jedem Abruf ändern.
Empfindliche Cursor geben immer Zeilen zurück, die den Auswahlkriterien
der Abfrage entsprechen, und zwar in der durch eine ORDER BY-Klausel
festgelegte Reihenfolge. Aktualisierungen können sich auf die
Mitgliedschaft, Reihenfolge und Werte der Ergebnismenge auswirken.
Die Anforderungen von empfindlichen Cursorn bewirken bei der
Implementierung von empfindlichen Cursorn folgende Einschränkungen:
♦ Zeilen können nicht vorab abgerufen werden, weil die Änderungen an
solchen Zeilen durch den Cursor nicht sichtbar wären. Das kann sich auf
die Performance auswirken.
♦ Empfindliche Cursor müssen so implementiert werden, dass keine
Arbeitstabellen zusammengestellt werden, weil Änderungen an den in
der Arbeitstabelle gespeicherten Zeilen durch den Cursor nicht sichtbar
wären.
♦ Die Bedingung, keine Arbeitstabelle zu verwenden, schränkt die
Auswahl der Join-Methode durch den Optimierer ein und kann sich
daher auf die Performance auswirken.
♦ Bei einigen Abfragen ist es unvermeidlich, dass der Optimierer einen
Plan erstellt, der eine Arbeitstabelle enthält, und somit keinen
empfindlichen Cursor erlaubt.

Nicht-empfindliche Cursor
Standards
Programmierschnittstellen
Kapitel 2 SQL in Anwendungen verwenden
Arbeitstabellen werden üblicherweise zum Sortieren und Gruppieren
von Zwischenergebnissen verwendet. Eine Arbeitstabelle ist zum
Sortieren nicht erforderlich, wenn auf die Zeilen durch einen Index
zugegriffen werden kann. Es ist nicht immer möglich vorherzusagen,
welche Abfragen Arbeitstabellen verwenden, aber sie werden von
folgenden Abfragen verwendet:
♦ UNION-Abfragen, auch wenn UNION ALL nicht unbedingt
Arbeitstabellen verwenden.
♦ Anweisungen mit einer ORDER BY-Klausel, wenn es keinen Index
auf der ORDER BY-Spalte gibt.
♦ Jede Abfrage, die mit einem Hash-Join optimiert ist.
♦ Viele Abfragen, die DISTINCT- oder GROUP BY-Klauseln
betreffen.
In diesen Fällen gibt Adaptive Server Anywhere entweder eine
Fehlermeldung an die Anwendung zurück, oder er ändert den Cursortyp
in einen nicht-empfindlichen Cursor und gibt eine Warnmeldung aus.
$ Weitere Hinweise zur Abfragenoptimierung und Verwendung von
Arbeitstabellen finden Sie unter "Abfragen optimieren und ausführen"
auf Seite 345 der Dokumentation ASA SQL-Benutzerhandbuch.
Diese Cursor haben keine genau definierte Empfindlichkeit in ihrer
Mitgliedschaft, ihrer Reihenfolge oder ihren Werten. Die Flexibilität, die sie
in Bezug auf Empfindlichkeit haben, ermöglicht es, nicht-empfindliche
Cursor für die Performance zu optimieren.
Nicht-empfindliche Cursor werden nur für schreibgeschützte Cursortypen
verwendet.
Nicht-empfindliche Cursor entsprechen der ISO/ANSI-Standarddefinition
von nicht-empfindlichen Cursorn beziehungsweise den ODBC-Cursorn mit
unbestimmter Empfindlichkeit.
Schnittstelle Cursortyp
ODBC, OLE DB und ADO Unspecified sensitivity
Embedded SQL DYNAMIC SCROLL
39

Adaptive Server Anywhere-Cursor
Beschreibung
Wert-empfindliche Cursor
Standards
Programmierschnittstellen
40
Die Anforderung eines nicht-empfindlichen Cursors schränkt die Auswahl
der Methoden kaum ein, die Adaptive Server Anywhere verwenden kann,
um die Abfrage zu optimieren und Zeilen an die Anwendung zurückzugeben.
Aus diesen Gründen erhalten Sie mit nicht-empfindlichen Cursorn die beste
Performance. Vor allem steht es dem Optimierer frei, jede Maßnahme zur
Materialisierung von Zwischenergebnissen, wie z.B. Arbeitstabellen,
anzuwenden, und Zeilen können vom Client vorab abgerufen werden.
Adaptive Server Anywhere kann die Sichtbarkeit von Änderungen in den
darunter liegenden Basiszeilen nicht garantieren. Einige Änderung können
sichtbar sein, andere nicht. Die Mitgliedschaft und Reihenfolge können sich
mit jedem Abruf ändern. Besonders Aktualisierungen in Basiszeilen können
dazu führen, dass nur einige der aktualisierten Spalten im Ergebnis des
Cursors wiedergespiegelt werden.
Nicht-empfindliche Cursor sind keine Garantie dafür, dass Zeilen
zurückgegeben werden, die der Auswahl und Reihenfolge der Abfrage
entsprechen. Die Zeilenmitgliedschaft steht zum Zeitpunkt des Öffnens des
Cursors fest, aber nachfolgende Änderungen an den darunter liegenden
Werten werden in den Ergebnissen wiedergespiegelt.
Nicht-empfindliche Cursor geben immer Zeilen zurück, die den WHEREund
ORDER BY-Klauseln des Kunden zu dem Zeitpunkt entsprachen, an
dem die Cursor-Mitgliedschaft etabliert wurde. Wenn sich Spaltenwerte nach
dem Öffnen des Cursors ändern, werden möglicherweise Zeilen
zurückgegeben, die nicht mehr den WHERE- und ORDER BY-Klauseln
entsprechen.
Diese Cursor sind in Bezug auf ihre Mitgliedschaft unempfindlich, dafür sind
sie empfindlich, was die Reihenfolge und Werte der Ergebnismenge betrifft.
Wert-empfindliche Cursor können für schreibgeschützte oder aktualisierbare
Cursortypen verwendet werden.
Wert-empfindliche Cursor entsprechen keiner ISO/ANSI-Standarddefintion.
Sie entsprechen den Schlüsselmengen-gesteuerten ODBC-Cursorn.
Schnittstelle Cursortyp
ODBC, OLE DB und ADO Schlüsselmengen-basiert
Embedded SQL SCROLL
JDBC Schlüsselmengen-basiert
Open Client Schlüsselmengen-basiert

Beschreibung
Kapitel 2 SQL in Anwendungen verwenden
Wenn eine Anwendung eine Zeile abruft, die aus einer darunter liegenden
geänderten Basiszeile besteht, dann muss der Anwendung der aktualisierte
Wert sowie die SQL_ROW_UPDATED-Statusmeldung übermittelt werden.
Wenn die Anwendung versucht, eine Zeile abzurufen, die aus einer darunter
liegenden Basiszeile zusammengesetzt war, welche gelöscht worden ist,
muss eine SQL_ROW_DELETED-Statusmeldung an die Anwendung
übermittelt werden.
Eine Änderung am Primärschlüsselwert entfernt die Zeile aus der
Ergebnismenge (dies wird als Löschen, gefolgt von Einfügen, behandelt).
Ein Sonderfall tritt auf, wenn eine Zeile in der Ergebnismenge gelöscht wird
(durch den Cursor oder von auswärts), und eine neue Zeile mit demselben
Schlüsselwert eingefügt wird. Das führt dazu, dass die neue Zeile die alte
Zeile in der ursprünglichen Position ersetzt.
Es gibt keine Garantie, dass die Zeilen in der Ergebnismenge dem
Reihenfolgen- oder Auswahlkriterium der Abfrage entsprechen. Da die
Zeilenmitgliedschaft zum Zeitpunkt des Öffnens festgelegt wird, führen
nachfolgende Änderungen, durch die eine Zeile nicht mehr der WHEREoder
ORDER BY-Klausel entspricht, nicht dazu, dass sich die Mitgliedschaft
oder Position einer Zeile ändert.
Alle Werte sind in Bezug auf Änderungen, die durch den Cursor
durchgeführt werden,empfindlich. Die Empfindlichkeit der Mitgliedschaft
gegenüber Änderungen, die durch den Cursor ausgeführt werden, wird durch
die ODBC-Option SQL_STATIC_SENSITIVITY gesteuert. Wenn diese
Option auf ON eingestellt ist, fügen Einfügungen durch den Cursor die Zeile
dem Cursor hinzu. Ansonsten ist sie nicht in der Ergebnismenge enthalten.
Löschungen durch den Cursor entfernen die Zeile aus der Ergebnismenge,
wodurch ein Lücke vermieden wird, und geben die SQL_ROW_DELETED-
Statusmeldung zurück.
Wert-empfindliche Cursor verwenden eine Schlüsselmengen-Tabelle. Wenn
der Cursor geöffnet wird, füllt Adaptive Server Anywhere eine
Arbeitstabelle mit Kenndaten für jede Zeile an, die zur Ergebnismenge
beiträgt. Wenn Sie die Ergebnismenge durchblättern, wird die
Schlüsselmengen-Tabelle zur Identifizierung der Mitgliedschaft der
Ergebnismenge verwendet, aber die Daten werden, falls erforderlich, von
den darunter liegenden Tabellen bezogen.
Die Eigenschaft der festen Mitgliedschaft von Wert-empfindlichen Cursorn
ermöglicht es Ihrer Anwendung, sich an die Zeilenpositionen innerhalb eines
Cursors erinnern, und stellt sicher, dass diese Positionen nicht geändert
werden. Weitere Hinweise finden Sie unter "Beispiel für Cursor-
Empfindlichkeit: Eine gelöschte Zeile" auf Seite 32.
41

Adaptive Server Anywhere-Cursor
42
♦ Wenn eine Zeile seit dem Öffnen des Cursors aktualisiert
beziehungsweise möglicherweise aktualisiert wurde, gibt Adaptive
Server Anywhere die Warnung SQLE_ROW_UPDATED_WARNING
zurück, wenn die Zeile abgerufen wird. Die Warnung wird nur einmal
ausgegeben: Ein weiteres Abrufen der Zeile generiert keine
Warnmeldung.
Eine Aktualisierung einer beliebigen Spalte in der Zeile verursacht diese
Warnung sogar, wenn die aktualisierte Spalte nicht durch den Cursor
referenziert wird. Ein Cursor auf emp_lname und emp_fname würde
beispielsweise die Aktualisierung melden, selbst wenn nur die birthdate-
Spalte geändert worden wäre. Diese Warn- und Fehlerbedingungen bei
Aktualisierung treten nicht im Massenoperationsmodus (Option -b für
Datenbankserver) auf, wenn die Zeilensperre deaktiviert ist. Siehe
"Performance-Überlegungen beim Bewegen von Daten" auf Seite 470
der Dokumentation ASA SQL-Benutzerhandbuch.
$ Weitere Hinweise finden Sie unter "Zeile wurde seit dem letzten
Lesen aktualisiert" auf Seite 324 der Dokumentation ASA
Fehlermeldungen
♦ Der Versuch, eine positionsbasierte UPDATE- oder DELETE-
Anweisung auf einer Zeile auszuführen, die seit dem letzten Abruf
geändert wurde, gibt den SQLE_ROW_UPDATED_SINCE_READ-
Fehler aus und bricht die Anweisung ab. Eine Anwendung muss die
Zeile noch einmal mit FETCH ABRUFEN, bevor das UPDATE oder
DELETE zugelassen wird.
Eine Aktualisierung einer beliebigen Spalte in der Zeile verursacht
diesen Fehler. Dies ist sogar dann der Fall, wenn die aktualisierte Spalte
nicht durch den Cursor referenziert wird. Der Fehler tritt nicht im
Massenvorgangsmodus auf.
$ Weitere Hinweise finden Sie unter "Zeile seit dem letzten Lesen
geändert - Vorgang abgebrochen" auf Seite 323 der Dokumentation ASA
Fehlermeldungen.
♦ Wenn eine Zeile, entweder durch den Cursor oder durch eine andere
Transaktion, nach dem Öffnen des Cursors gelöscht wurde, entsteht im
Cursor eine Lücke. Die Mitgliedschaft des Cursors steht fest, daher ist
die Position einer Zeile reserviert, aber der DELETE-Vorgang wird im
geänderten Wert für die Zeile wiedergespiegelt. Wenn Sie die Zeile an
dieser Lücke abrufen, wird mit der Fehlermeldung Keine aktuelle
Cursorzeile (SQL state 24503) darauf hingewiesen, dass es keine
aktuelle Zeile gibt, und der Cursor wird auf der Lücke belassen. Sie
können Lücken vermeiden, indem Sie empfindliche Cursor verwenden,
da sich deren Mitgliedschaft zusammen mit den Werten verändert.

Kapitel 2 SQL in Anwendungen verwenden
$ Weitere Hinweise finden Sie unter "Keine aktuelle Cursorzeile" auf
Seite 207 der Dokumentation ASA Fehlermeldungen.
Sie können für Wert-empfindliche Cursor Zeilen nicht vorab abrufen. Diese
Einschränkung kann sich manchmal auf die Performance auswirken.
Cursor-Empfindlichkeit und Performance
Es besteht eine Wechselwirkung zwischen Performance und anderen Cursor-
Eigenschaften. Besonders wenn Sie einen Cursor aktualisierbar machen,
führt das zu Beschränkungen der Abfrageverarbeitung und -zustellung, was
die Performance vermindert. Auch können Anforderungen an die Cursor-
Empfindlichkeit die Performance einschränken.
Um zu verstehen, wie sich die Aktualisierbarkeit und Empfindlichkeit von
Cursorn auf die Performance auswirkt, ist es hilfreich zu wissen, wie die
Ergebnisse, die durch einen Cursor sichtbar sind, von der Datenbank an die
Client-Anwendung übermittelt werden.
Im Einzelnen können Ergebnisse aus Performance-Gründen an zwei
dazwischengeschalteten Standorten gespeichert werden:
♦ Arbeitstabellen Sowohl Zwischen- als auch Endergebnisse können als
Arbeitstabellen gespeichert werden. Wert-empfindliche Cursor
verwenden eine Arbeitstabelle für Primärschlüsselwerte. Abfrage-
Eigenschaften können ebenfalls dazu führen, dass der Optimierer in
seinem gewählten Ausführungsplan Arbeitstabellen verwendet.
♦ Prefetch-Vorgang Der Client kann Zeilen vorab in einen clientseitigen
Puffer abrufen, um separate Anfragen an der Datenbankserver für jede
Zeile zu vermeiden.
Client-
Anwendung
ODBC-Treiber in der
Netzwerk-Bibliothek
Vorab
abgerufene
Zeilen
Datenbank-
Server
Arbeitstabelle
Die Empfindlichkeit und Aktualisierbarkeit beschränken die Verwendung
von zwischengeschalteten Standorten.
43

Adaptive Server Anywhere-Cursor
Zeilen-Prefetch
44
Einem aktualisierbaren Cursor ist es nicht gestattet, Arbeitstabellen zu
verwenden oder mit PREFETCH Ergebnisse vorab abzurufen. Wäre dies
möglich, wäre er für verlorene Aktualisierungen anfällig. Dieses Problem
wird im folgenden Beispiel erläutert:
1 Eine Anwendung öffnet auf der Beispieldatenbank in der folgenden
Abfrage einen Cursor.
SELECT id, quantity
FROM product
id quantity
300 28
301 54
302 75
… …
2 Die Anwendung ruft die Zeile mit id = 300 durch den Cursor ab.
3 Eine weitere Transaktion aktualisiert die Zeile mit der folgenden
Anweisung:
UPDATE product
SET quantity = quantity - 10
WHERE id = 300
4 Die Anwendung aktualisiert die Zeile durch den Cursor auf einen Wert
von (quantity - 5 ).
5 Der korrekte Endwert für die Zeile sollte 13 sein. Wenn der Cursor die
Zeile vorab abgerufen hätte, würde der neue Wert für die Zeile 23 lauten
und die Aktualisierung der anderen Transaktion verloren gehen.
Ähnliche Einschränkungen sind maßgebend für die Empfindlichkeit. Weitere
Hinweise finden Sie unter den Beschreibungen der einzelnen Cursortypen.
Prefetch-Vorgänge und Mehrzeilen-Fetch-Vorgänge unterscheiden sich
voneinander. Prefetch-Vorgänge können ohne explizite Anweisungen aus der
Clientanwendung ausgeführt werden. Prefetch-Vorgänge rufen Zeilen aus
dem Server in einen Puffer auf dem Client ab, machen diese Zeilen aber für
die Clientanwendung erst verfügbar, wenn die entsprechende Zeile von der
Anwendung abgerufen wird.

Prefetch-
Funktionen aus
einer Anwendung
steuern
Kapitel 2 SQL in Anwendungen verwenden
Standardmäßig führt die Clientbibliothek von Adaptive Server Anywhere
Prefetch-Vorgänge für mehrere Zeilen aus, wenn eine Anwendung eine
einzelne Zeile abruft. Die Clientbibliothek von Adaptive Server Anywhere
speichert die zusätzlichen Zeilen in einem Puffer.
Prefetch-Vorgänge verbessern die Performance durch die Reduktion des
Client/Server-Verkehrs und erhöhen den Durchsatz, indem ohne separate
Anforderung für einzelne Zeilen oder Zeilenblöcke viele Zeilen verfügbar
gemacht werden.
$ Weitere Hinweise zur Steuerung der Prefetch-Funktionen finden Sie
unter "PREFETCH-Option" auf Seite 659 der Dokumentation ASA
Datenbankadministration.
♦ Durch die PREFETCH-Option wird gesteuert, ob Prefetch-Vorgänge
durchgeführt werden oder nicht. Sie können die PREFETCH-Option für
eine einzelne Verbindung auf ON oder OFF setzen. Standardmäßig wird
sie auf ON gesetzt.
♦ In Embedded SQL können Sie die PREFETCH-Vorgänge auf
Cursorbasis steuern, wenn Sie einen Cursor bei einem FETCH-Vorgang
öffnen, indem Sie die BLOCK-Klausel verwenden.
Die Anwendung kann eine maximale Anzahl von Zeilen festlegen, die in
einem einzelnen FETCH-Vorgang vom Server enthalten sein dürfen,
indem die BLOCK-Klausel angegeben wird. Beispiel: Wenn Sie 5
Zeilen gleichzeitig abrufen und anzeigen, können Sie BLOCK 5
verwenden. Wenn Sie BLOCK 0 festlegen, wird jeweils 1 Datensatz
abgerufen, und ein FETCH RELATIVE 0 ruft die Zeile nochmals vom
Server ab.
Obwohl Sie die PREFETCH-Vorgänge auch durch einen
Verbindungsparameter für die Anwendung ausschalten können, ist es
effektiver, BLOCK=0 zu verwenden.
$ Weitere Hinweise finden Sie unter "PREFETCH-Option" auf
Seite 659 der Dokumentation ASA Datenbankadministration.
♦ In Open Client können Sie das PREFETCH-Verhalten mit ct_cursor
und CS_CURSOR_ROWS nach der Deklaration, aber vor dem Öffnen
des Cursors steuern.
Cursor-Empfindlichkeit und Isolationsstufen
Sowohl Cursor-Empfindlichkeit als auch Isolationsstufen betreffen das
Problem der Parallelität, allerdings auf unterschiedliche Weise.
45

Adaptive Server Anywhere-Cursor
46
Indem Sie eine Isolationsstufe für eine Transaktion auswählen (häufig auf
der Verbindungsebene), legen Sie fest, wann Sperren auf Zeilen in der
Datenbank plaziert werden. Sperren verhindern, dass andere Transaktionen
auf die Werte in der Datanbank zugreifen oder sie verändern.
Indem Sie eine Cursor-Empfindlichkeit auswählen legen Sie fest, welche
Änderungen für die Anwendung, die den Cursor verwendet, sichtbar sind.
Indem Sie die Cursor-Empfindlichkeit einstellen legen Sie nicht fest, wann
Sperren auf Zeilen in der Datenbank gelegt werden, und Sie schränken auch
nicht die Änderungen ein, die an der Datenbank selbst durchgeführt werden.

Ergebnismengen beschreiben
Kapitel 2 SQL in Anwendungen verwenden
Einige Anwendungen bauen SQL-Anweisungen auf, die in der Anwendung
nicht ausgeführt werden können. Anweisungen hängen manchmal von einer
Antwort des Benutzers ab, sodass die Anwendung erst dann erfährt, welche
Daten abzurufen sind, z.B. wenn eine Berichtsanwendung dem Benutzer die
Möglichkeit gibt, die anzuzeigenden Spalten auszuwählen.
In einem solchen Fall benötigt die Anwendung eine Methode, um
Informationen über die Art der Ergebnismenge selbst sowie den Inhalt der
Ergebnismenge zu erhalten. Die Informationen über die Art der
Ergebnismenge werden als Deskriptor bezeichnet. Sie identifizieren die
Datenstruktur einschließlich Anzahl und Typ der erwarteten Spalten. Wenn
die Anwendung die Art der Ergebnismenge ermittelt hat, ist der Abruf des
Inhalts ein einfacher Vorgang.
Diese Ergebnismengen-Metadaten (Informationen über Art und Inhalt der
Daten) werden mit Hilfe von Deskriptoren bearbeitet. Das Beziehen und
Verwalten von Ergebnismengen-Metadaten wird als Beschreiben
bezeichnet.
Da Cursor im Allgemeinen Ergebnismengen produzieren, sind Deskriptoren
und Cursor eng verknüpft, obwohl manche Schnittstellen die Verwendung
von Deskriptoren vor dem Benutzer verbergen. Normalerweise gilt:
Anweisungen, die Deskriptoren benötigen, sind entweder SELECT-
Anweisungen oder gespeicherte Prozeduren, die Ergebnismengen
zurückgeben.
Ein Deskriptor wird bei einem cursorbasierten Vorgang folgendermaßen
eingesetzt:
1 Weisen Sie den Deskriptor zu. Dies kann implizit erfolgen, die explizite
Zuweisung ist aber in manchen Schnittstellen zulässig.
2 Bereiten Sie die Anweisung vor.
3 Anweisung beschreiben. Wenn es sich bei der Anweisung um eine
gespeicherte Prozedur oder um eine Anweisungsfolge handelt und die
Ergebnismenge nicht durch eine Ergebnisklausel in der
Prozedurdefinition definiert wird, sollte die Beschreibung nach dem
Öffnen des Cursors erscheinen.
4 Deklarieren Sie einen Cursor für die Anweisung und öffnen Sie ihn
(Embedded SQL), oder führen Sie die Anweisung aus.
5 Beziehen Sie den Deskriptor und ändern Sie erforderlichenfalls den
zugewiesenen Bereich . Dies erfolgt oft implizit.
6 Rufen Sie die Anweisungsergebnisse ab und und verarbeiten Sie sie.
47

Ergebnismengen beschreiben
Hinweise zur
Implementierung
48
7 Heben Sie die Zuweisung des Deskriptors auf.
8 Schließen Sie den Cursor.
9 Löschen Sie die Anweisung . Einige Schnittstellen führen dies
automatisch durch.
♦ In Embedded SQL enthält eine SQLDA-(SQL Descriptor Area) Struktur
die Deskriptor-Informationen.
$ Weitere Hinweise finden Sie unter "Der SQL-Deskriptor-Bereich
(SQLDA)" auf Seite 228.
♦ In ODBC bietet ein Deskriptor-Handle, durch SQLAllocHandle
zugewiesen, den Zugriff auf die Felder eines Deskriptors. Sie können
diese Felder mit SQLSetDescRec, SQLSetDescField,
SQLGetDescRec und SQLGetDescField verarbeiten.
Alternativ können Sie SQLDescribeCol und SQLColAttributes
verwenden, um Spalteninformationen zu beziehen.
♦ In Open Client können Sie ct_dynamic für die Vorbereitung einer
Anweisung und ct_describe zur Beschreibungder Ergebnismenge der
Anweisung verwenden. Sie können aber auch ct_command benutzen,
um eine SQL-Anweisung ohne vorherige Vorbereitung zu senden und
dann ct_results benutzen, um die zurückgegebenen Zeilen nacheinander
zu verarbeiten. Dies ist die normalerweise benutzte Vorgehensweise bei
der Open Client-Anwendungsentwicklung.
♦ In JDBC bietet die Klasse java.SQL.ResultSetMetaData
Informationen über Ergebnismengen.
♦ Sie können auch Deskriptoren verwenden, um Daten an die Engine zu
senden (z.B. mit der INSERT-Anweisung), aber dies ist eine andere Art
von Deskriptor als für die Ergebnismenge.
$ Weitere Hinweise zu Eingabe- und Ausgabeparametern für die
DESCRIBE-Anweisung finden Sie unter "DESCRIBE-Anweisung
[ESQL]" auf Seite 426 der Dokumentation ASA SQL-Referenzhandbuch.

Kapitel 2 SQL in Anwendungen verwenden
Transaktionen in Anwendungen steuern
Transaktionen sind Zusammenstellungen einzelner SQL-Anweisungen.
Entweder werden alle Anweisungen in der Transaktion ausgeführt oder
keine. In diesem Abschnitt werden einige Aspekte der Transaktionen in
Anwendungen behandelt.
$ Weitere Hinweise zu Transaktionen entnehmen Sie dem Kapitel
"Transaktionen und Isolationsstufen verwenden" auf Seite 99 der
Dokumentation ASA SQL-Benutzerhandbuch.
Automatisch oder manuell festschreiben
Datenbank-Programmierschnittstellen können entweder im manuellen
Festschreibemodus (manual commit) oder im automatischen
Festschreibemodus (autocommit) operieren.
♦ Manueller Festschreibemodus (manual commit) Operationen werden
nur festgeschrieben, wenn Ihre Anwendung eine explizite
Festschreibungsoperation durchführt oder der Datenbankserver eine
automatische Festschreibung vollzieht, wie zum Beispiel beim
Ausführen einer ALTER TABLE-Anweisung oder anderer
Datendefinitionsanweisungen. Der manuelle Festschreibungsmodus
wird manchmal auch verketteter Modus genannt.
Um in Ihren Anwendungen Transaktionen wie verschachtelte
Transaktionen und Savepoints verwenden zu können, müssen Sie im
manuellen Festschreibemodus operieren.
♦ Automatischer Festschreibemodus (autocommit) Jede Anweisung
wird wie eine separate Transaktion behandelt. Die Wirkung ist dieselbe,
wie wenn Sie eine COMMIT-Anweisung an das Ende jedes Ihrer
Befehle anhängen. Der automatische Festschreibungsmodus wird
manchmal auch unverketteter Modus genannt.
Dieser Modus kann sich auf die Performance und das Verhalten Ihrer
Anwendung auswirken. Verwenden Sie ihn nicht, wenn Ihre Anwendung
Transaktionsintegrität erfordert.
$ Hinweise über die Auswirkungen von AUTOCOMMIT auf die
Performance finden Sie unter "Autocommit-Modus ausschalten" auf
Seite 166 der Dokumentation ASA SQL-Benutzerhandbuch.
49

Transaktionen in Anwendungen steuern
AUTOCOMMIT-Verhalten steuern
50
Wie Sie das Festschreibungsverhalten Ihrer Anwendung steuern hängt von
der verwendeten Programmierschnittstelle ab. Die Implementierung von
AUTOCOMMIT kann, abhängig von der Schnittstelle, clientseitig oder
serverseitig stattfinden.
$ Weitere Hinweise finden Sie unter "Die AUTOCOMMIT-
Implementierung" auf Seite 51.
v So steuern Sie den AUTOCOMMIT-Modus (ODBC):
♦ Standardmäßig arbeitet ODBC im AUTOCOMMIT-Modus. Die Art,
wie Sie AUTOCOMMIT ausschalten, hängt davon ab, ob Sie ODBC
direkt verwenden, oder ein Anwendungsentwicklungstool einsetzen.
Wenn Sie direkt über die ODBC-Schnittstelle programmieren, stellen
Sie das SQL_ATTR_AUTOCOMMIT-Verbindungsattribut ein.
v So steuern Sie den AUTOCOMMIT-Modus (JDBC):
♦ Standardmäßig arbeitet JDBC im AUTOCOMMIT-Modus. Um
AUTOCOMMIT auszuschalten, verwenden Sie die setAutoCommit-
Methode des Verbindungsobjekts:
conn.setAutoCommit( false );
v So steuern Sie den AUTOCOMMIT-Modus (Open Client):
♦ Standardmäßig operiert eine Verbindung, die durch Open Client
hergestellt wird, im AUTOCOMMIT-Modus. Sie können dieses
Verhalten ändern, indem Sie die Datenbankoption CHAINED in Ihrer
Anwendung auf ON setzen, indem Sie eine Anweisung wie die
Folgende verwenden:
SET OPTION CHAINED=’ON’
v So steuern Sie den AUTOCOMMIT-Modus (Embedded SQL):
♦ Standardmäßig operieren Embedded SQL-Anwendungen im manuellen
Festschreibemodus. Um AUTOCOMMIT einzuschalten, stellen Sie die
CHAINED-Datenbankoption auf OFF ein, indem Sie eine Anweisung
wie die Folgende verwenden:
SET OPTION CHAINED=’OFF’

Die AUTOCOMMIT-Implementierung
Isolationsstufe steuern
Kapitel 2 SQL in Anwendungen verwenden
Der vorherige Abschnitt, "AUTOCOMMIT-Verhalten steuern" auf Seite 50,
beschreibt, wie das AUTOCOMMIT-Verhalten von den einzelnen Adaptive
Server Anywhere-Programmierschnittstellen gesteuert werden kann.
Abhängig von der verwendeten Schnittstelle und davon, wie Sie das
AUTOCOMMIT-Verhalten steuern, verhält sich der AUTOCOMMIT-
Modus leicht unterschiedlich.
Der AUTOCOMMIT-Modus kann auf zwei Arten implementiert werden:
♦ Clientseitiges AUTOCOMMIT Wenn eine Anwendung AUTOCOMMIT
verwendet, sendet die Clientbibliothek eine COMMIT-Anweisung nach
jeder ausgeführten SQL-Anweisung.
Adaptive Server Anywhere verwendet clientseitiges AUTOCOMMIT
für ODBC- und OLE DB-Anwendungen.
♦ Serverseitiges AUTOCOMMIT Wenn eine Anwendung
AUTOCOMMIT verwendet, gibt der Datenbankserver nach jeder SQL-
Anweisung ein COMMIT aus. Dieses Verhalten wird, im Fall von JDBC
implizit, durch die CHAINED-Datenbankoption gesteuert.
Adaptive Server Anywhere verwendet serverseitiges AUTOCOMMIT
für Embedded SQL-, JDBC- und Open Client-Anwendungen.
Es gibt einen Unterschied zwischen clientseitigem und serverseitigem
AUTOCOMMIT im Fall von zusammengesetzten Anweisungen wie
gespeicherten Prozeduren und Triggern. Für den Client ist eine gespeicherte
Prozedur eine einzelne Anweisung, und daher sendet AUTOCOMMIT eine
einzelne COMMIT-Anweisung, nachdem die gesamte Prozedur ausgeführt
wurde. Aus der Perspektive des Datenbankservers kann die gespeicherte
Prozedur aus vielen SQL-Anweisungen bestehen, und daher gibt ein
serverseitiges AUTOCOMMIT ein COMMIT nach jeder SQL-Anweisung
innerhalb der Prozedur aus.
Clientseitige und serverseitige Implementierungen nicht
vermischen
Sie sollten in Ihrer ODBC- oder OLE DB-Anwendung die Verwendung
der CHAINED-Option nicht mit AUTOCOMMIT kombinieren.
Sie können die Isolationsstufe einer aktuellen Verbindung mit der
Datenbankoption ISOLATION_LEVEL einstellen.
51

Transaktionen in Anwendungen steuern
Cursor und Transaktionen
ROLLBACK und
Cursor
Savepoints
Cursor und
Isolationsstufe
52
Einige Schnittstellen, wie ODBC, ermöglichen das Setzen der Isolationsstufe
für eine Verbindung beim Aufbau. Diese Isolationsstufe kann später mit der
Datenbankoption ISOLATION_LEVEL zurückgesetzt werden.
Im Allgemeinen wird ein Cursor geschlossen, wenn ein COMMIT
ausgeführt wird. Es gibt zwei Ausnahmen für dieses Verhalten.
♦ Die Datenbankoption CLOSE_ON_ENDTRANS ist auf OFF gesetzt.
♦ Ein Cursor wird mit WITH HOLD geöffnet, was der Standard bei Open
Client und JDBC ist.
Trifft einer dieser beiden Fälle zu, bleibt der Cursor bei COMMIT geöffnet.
Beim Zurücksetzen einer Transaktion wird der Cursor geschlossen, außer
wenn er mit WITH HOLD geöffnet wurde. Dem Inhalt eines Cursors können
Sie nach einem Zurücksetzen nicht vertrauen.
Der projektierte ISO SQL3-Standard legt fest, dass bei einem Zurücksetzen
alle Cursor geschlossen werden sollen. Sie können dieses Verhalten
erzwingen, indem Sie die Option
ANSI_CLOSE_CURSORS_AT_ROLLBACK auf ON setzen.
Wenn eine Transaktion bis zu einem Savepoint zurückgesetzt wird und
ANSI_CLOSE_CURSORS_AT_ROLLBACK auf ON gesetzt ist, wird jeder
nach dem SAVEPOINT geöffnete Cursor geschlossen (sogar die Cursor, die
mit WITH HOLD geöffnet wurden).
Sie können die Isolationsstufe für eine Verbindung während einer
Transaktion setzen, indem Sie die Anweisung SET OPTION verwenden, um
die Option ISOLATION_LEVEL zu ändern. Diese Änderung wirkt sich
jedoch nur auf geschlossene Cursor aus.

KAPITEL 3
Einführung in Java für Datenbanken
Über dieses
Kapitel
Inhalt
In diesem Kapitel wird erklärt, warum es sinnvoll ist, Java in einer
Datenbank zu verwenden.
Der Adaptive Server Anywhere ist eine Laufzeit-Umgebung für Java. Java
bietet eine natürliche Erweiterung für SQL und verwandelt Adaptive Server
Anywhere in eine Plattform für Unternehmensanwendungen der nächsten
Generation.
Thema Seite
Einleitung 54
Fragen und Antworten zu Java in der Datenbank 57
Ein Java-Seminar 64
Die Laufzeitumgebung für Java in der Datenbank 75
Praktische Einführung: Eine Übung mit Java in der Datenbank 84
53

Einleitung
Einleitung
Getrennt
lizenzierbare
Komponente
Der SQLJ-
Standard
54
Adaptive Server Anywhere ist eine Laufzeit-Umgebung für Java. Das
bedeutet, dass Java-Klassen im Datenbankserver ausgeführt werden können.
Durch die Integration einer Laufzeit-Umgebung für Java-Klassen in den
Datenbankserver werden neue, vielfältige Wege für die Verwaltung und
Speicherung von Daten und Logik eröffnet.
Java in der Datenbank bietet folgende Möglichkeiten:
♦ Sie können Java-Komponenten in den verschiedenen Schichten Ihrer
Anwendung verwenden (Client, mittlere Schicht oder Server) und
überall einsetzen, wo es für Sie am sinnvollsten ist. Adaptive Server
Anywhere wird damit zu einer Plattform für verteilte
Informationsverarbeitung.
♦ Java bietet mehr Möglichkeiten als gespeicherte Prozeduren für die
Integration von Logik in die Datenbank.
♦ Java-Klassen werden zu reichhaltigen, benutzerdefinierten Datentypen.
♦ Die Methoden der Java-Klassen bieten neue Funktionen für den Zugriff
aus SQL.
♦ Java kann in der Datenbank benutzt werden, ohne dass die Integrität, die
Sicherheit und die Robustheit der Datenbank verletzt werden.
Java in der Datenbank ist eine Komponente, die separat lizenziert werden
kann und vor der Installation bestellt werden muss. Die Bestellung kann mit
der betreffenden Karte im SQL Anywhere Studio-Paket oder über
http://www.sybase.com/detail?id=1015780 erfolgen.
Java in der Datenbank basiert auf den vorgeschlagenen Standards SQLJ Part
1 und SQLJ Part 2. SQLJ Part 1 liefert Spezifikationen zum Aufrufen von
statischen Java-Methoden als gespeicherte SQL-Prozeduren und
benutzerdefinierte Funktionen. SQLJ Part 2 bietet Spezifikationen für den
Einsatz von Java-Klassen als in SQL geschriebene benutzerdefinierte
Datentypen.
Hinweise zu Java in der Datenbank
Java ist eine relativ neue Programmiersprache, mit einer wachsenden, aber
immer noch limitierten Wissensbasis. Diese Dokumentation wurde für ein
breites Spektrum von Java-Entwicklern geschrieben und unterstützt daher
alle, von erfahrenen Entwicklern bis zu fachlich nicht vorgebildeten Lesern,
die die Sprache, ihre Möglichkeiten, ihre Syntax und ihre
Einsatzmöglichkeiten nicht kennen.

Java-
Dokumentation
Kapitel 3 Einführung in Java für Datenbanken
Leser, für die Java nichts Neues mehr ist, finden in diesem Kapitel wertvolle
Hinweise für den Einsatz von Java in einer Datenbank. Adaptive Server
Anywhere erweitert nicht nur die Möglichkeiten der Datenbank mit Java,
sondern auch die Möglichkeiten von Java mit der Datenbank.
In der nachstehenden Tabelle finden Sie Hinweise zur Dokumentation zum
Thema Java in der Datenbank.
Titel Verwendung
"Einführung in Java für
Datenbanken" auf Seite 53
(dieses Kapitel)
"Java in der Datenbank
benutzen" auf Seite 93
"Datenzugriff über JDBC" auf
Seite 143
"Fehlersuche in der
Datenbanklogik" auf
Seite 635 der Dokumentation
ASA SQL-Benutzerhandbuch
Adaptive Server Anywhere
Referenzhandbuch
Referenzhandbuch für die
Java API von Sun
Thinking in Java Thinking in
Java by Bruce Eckel.
Java-Dokumentation benutzen
Java-Konzepte und Anwendungsmethoden in
Adaptive Server Anywhere
Praktische Anleitung zum Einsatz von Java in
der Datenbank
Zugriff auf Daten aus Java-Klassen,
einschließlich verteilter
Informationsverarbeitung
Testen und Fehlersuche von Java-Code für den
Einsatz in der Datenbank
Das Referenzhandbuch enthält Informationen
zu den SQL-Erweiterungen, die Java in der
Datenbank unterstützen.
Online-Handbuch für Java API-Klassen, Felder
und Methoden. Nur als Windows-Hilfedatei
verfügbar.
Online-Buch, mit dem man das Programmieren
in Java lernen kann. Es wird im Adobe PDF
Format im Unterverzeichnis
Samples\ASA\Java des Adaptive Server
Anywhere-Installationsverzeichnisses
bereitgestellt.
Die folgende Tabelle ist ein Wegweiser für die Java-Dokumentationen, die
Sie je nach Ihren Interessen und Vorkenntnissen benutzen können. Die
Tabelle ist nur als Richtlinie gedacht und soll Ihre Bemühungen, mehr über
Java in der Datenbank zu lernen, unterstützen.
55

Einleitung
56
Gesuchtes Thema Textstelle
Sie benötigen eine Einführung in
objektorientiertes Programmieren
Sie benötigen eine Erklärung von
Themen wie instanziert, Feld und
Klassenmethode.
Sie sind ein Java-Entwickler, der gleich
mit der praktischen Arbeit beginnen will.
Sie wollen die Hauptmerkmale von Java
in der Datenbank kennen lernen.
Sie wollen herausfinden, wie der Zugriff
auf Daten aus Java erfolgt.
Sie wollen eine Datenbank für Java
vorbereiten.
Sie brauchen eine komplette Liste der
unterstützten Java APIs.
Sie versuchen, eine Java API-Klasse zu
verwenden und benötigen Java-
Referenzinformationen.
Sie wollen ein Beispiel für verteilte
Informationsverarbeitung sehen.
"Ein Java-Seminar" auf Seite 64
Thinking in Java von Bruce Eckel.
"Ein Java-Seminar" auf Seite 64
"Die Laufzeitumgebung für Java in
der Datenbank" auf Seite 75
"Praktische Einführung: Eine Übung
mit Java in der Datenbank" auf
Seite 84
"Fragen und Antworten zu Java in der
Datenbank" auf Seite 57
"Datenzugriff über JDBC" auf
Seite 143
"Datenbank für Java aktivieren" auf
Seite 97
"Java-Klassen-Datentypen" auf
Seite 86 der Dokumentation ASA
SQL-Referenzhandbuch
Online-Handbuch für Java API-
Klassen, Felder und Methoden (nur
als Windows-Online-Hilfe)
"Verteilte Anwendungen erstellen"
auf Seite 174

Kapitel 3 Einführung in Java für Datenbanken
Fragen und Antworten zu Java in der Datenbank
In diesem Abschnitt werden die Hauptmerkmale von Java in der Datenbank
beschrieben.
Die wichtigsten Funktionen von Java in der Datenbank
Detaillierte Erläuterungen aller nachstehenden Punkte sind in den folgenden
Abschnitten zu finden.
♦ Sie können Java auf dem Datenbankserver ausführen Eine interne
Java Virtual Machine (VM) führt den Java-Code auf dem
Datenbankserver aus.
♦ Sie können Java aus SQL aufrufen Sie können Java-Funktionen
(Methoden) aus SQL-Anweisungen ausführen. Java-Methoden bieten
eine leistungsfähigere Sprache als in SQL geschriebene gespeicherte
Prozeduren, wenn Sie Ihrer Datenbank logische Elemente hinzufügen
wollen.
♦ Sie können aus Java auf Daten zugreifen Ein interner JDBC-Treiber
ermöglicht den Zugriff auf Daten aus Java.
♦ Sie können die Fehlersuche für Java in der Datenbank vornehmen
Sie können den Sybase Java Debugger verwenden, um Ihre Java-
Klassen in der Datenbank zu testen und auf Fehler zu durchsuchen.
♦ Sie können Java-Klassen als Datentypen verwenden Jede in einer
Datenbank installierte Java-Klasse wird als Datentyp verfügbar, der für
eine Spalte in einer Tabelle oder einer Variablen verwendet werden
kann.
♦ Sie können Java-Objekte in Tabellen speichern Eine Instanz einer
Java-Klasse (ein Java-Objekt) kann als Wert in einer Tabelle gespeichert
werden. Java-Objekte können in eine Tabelle eingefügt, SELECT-
Anweisungen in den Feldern und Methoden von in Tabellen
gespeicherten Objekten ausgeführt, und Java-Objekte aus einer Tabelle
abgerufen werden.
Mit diesen Möglichkeiten wird Adaptive Server Anywhere zu einer
objekt-relationalen Datenbank, die Objekte unterstützt, gleichzeitig aber
die bestehenden relationalen Funktionen nicht beeinträchtigt.
♦ SQL wird bewahrt Der Einsatz von Java ändert das Verhalten
bestehender SQL-Anweisungen oder andere Aspekte des nicht mit Java
verbundenen Verhaltens der relationalen Datenbank nicht.
57

Fragen und Antworten zu Java in der Datenbank
Java-Instruktionen in der Datenbank speichern
58
Java ist eine objektorientierte Sprache, ihre Anweisungen (Quellcode)
werden daher in Form von Klassen geliefert. Um Java in einer Datenbank
auszuführen, schreiben Sie die Java-Instruktionen außerhalb der Datenbank
in kompilierte Klassen (Bytecode), bei denen es sich um Binärdateien mit
Java-Instruktionen handelt.
Sie installieren diese kompilierten Klassen dann in einer Datenbank. Nach
der Installation können Sie diese Klassen im Datenbankserver ausführen.
Adaptive Server Anywhere ist eine Laufzeit-Umgebung für Java-Klassen,
keine Java-Entwicklungsumgebung. Sie brauchen eine Java-
Entwicklungsumgebung, wie Sybase PowerJ oder Java Development Kit von
Sun Microsystems, um Java-Codes zu schreiben und zu kompilieren.
$ Weitere Hinweise finden Sie unter "Java-Klassen in einer Datenbank
installieren" auf Seite 103.
Java in einer Datenbank ausführen
Unterschiede zu
einer eigenständigen
VM
Adaptive Server Anywhere enthält eine Java Virtual Machine (VM), die in
der Datenbankumgebung läuft. Die Sybase Java VM interpretiert kompilierte
Java-Instruktionen und führt sie im Datenbankserver aus.
Zusätzlich zur VM wurde der SQL-Abfrageprozessor im Datenbankserver
erweitert, so dass er in der VM Aufrufe durchführen kann, um Java-
Instruktionen auszuführen. Er kann auch Abfragen von der VM verarbeiten,
um den Datenzugriff aus Java zu aktivieren.
Es gibt einen Unterschied zwischen dem Ausführen von Java-Codes mit
einer Standard-VM wie Sun Java VM java.exe und dem Ausführen von
Java-Codes in einer Datenbank. Die Sun VM wird von einer Befehlszeile aus
gestartet, während die Java VM von Adaptive Server Anywhere jederzeit
verfügbar ist, um einen Java-Vorgang auszuführen, wenn dies als Teil der
Ausführung einer SQL-Anweisung erforderlich ist.
Auf den Sybase Java-Interpreter können Sie extern nicht zugreifen. Er wird
nur benutzt, wenn die Ausführung einer SQL-Anweisung einen Java-
Vorgang erforderlich macht. Der Datenbankserver startet die VM
automatisch, wenn sie benötigt wird: Sie brauchen keine ausdrücklichen
Bedienungsmaßnahmen auszuführen, um die VM zu starten oder zu stoppen.

Vorteile von Java
Kapitel 3 Einführung in Java für Datenbanken
Java bietet eine Reihe von Merkmalen, die für den Einsatz in Datenbanken
besonders gut geeignet sind:
♦ Präzise Fehlerprüfung bei der Kompilierung
♦ Integrierte Fehlerbehandlung mit einer gut definierten Methode für die
Fehlerbehandlung
♦ Integrierte Sammlung von Abfalldaten (Speicher wird freigesetzt)
♦ Eliminierung vieler fehleranfälliger Programmiertechniken
♦ Leistungsfähige Sicherheitsfunktionen
♦ Java-Code wird interpretiert, daher werden keine Vorgänge ausgeführt,
die von der VM nicht akzeptiert werden
Plattformen, die Java in der Datenbank unterstützen
Java in der Datenbank wird auf Windows CE nicht unterstützt. Wohl aber
unter Windows-Betriebssystemen, UNIX und NetWare.
Java und SQL zusammen einsetzen
Ein Grundsatz für das Konzept von Java in der Datenbank besteht darin, dass
damit eine natürliche, offene Erweiterung für bestehende SQL-Funktionen
gegeben ist.
♦ Java-Vorgänge werden aus SQL aufgerufen Sybase hat den Bereich
der SQL-Ausdrücke erweitert, sodass Eigenschaften und Methoden von
Java-Objekten einbezogen werden können und damit der Einbau von
Java-Vorgängen in eine SQL-Anweisung möglich ist.
♦ Java-Klassen werden Domänen Sie speichern Java-Klassen mit
denselben SQL-Anweisungen wie für normale SQL-Datentypen.
Sie können viele der Klassen verwenden, die Teil der Java API sind, so wie
sie mit dem Java Development Kit von Sun Microsystems geliefert werden.
Sie können auch Klassen verwenden, die von Java-Entwicklern erstellt und
kompiliert wurden.
59

Fragen und Antworten zu Java in der Datenbank
Beschreibung der Java API
Zugriff auf Java aus SQL
60
Die Java-Programmierschnittstelle (Java Application Programmer’s
Interface, API) ist eine Gruppe von Klassen, die von Sun Microsystems
erstellt wurde. Sie bietet eine Reihe von Basisfunktionen, die von Java-
Entwicklern benutzt und erweitert werden können. Sie bilden den Kern aller
Einsatzmöglichkeiten von Java.
Die Java API bietet aus sich heraus zahlreiche Möglichkeiten und
Funktionen. Ein Großteil der Java API kann in jede Datenbank integriert
werden, die für die Arbeit mit Java-Programmcode eingerichtet wurde. Dazu
gehört die Mehrzahl der nicht-visuellen Klassen aus der Java API, die
Entwicklern, welche schon mit dem Java Development Kit (JDK) von Sun
Microsystems arbeiten, bekannt sein dürften.
$ Weitere Hinweise über unterstützte Java-APIs finden Sie unter
"Unterstützte Java-Pakete" auf Seite 87 der Dokumentation ASA SQL-
Referenzhandbuch.
Die Java API kann nicht nur in Klassen verwendet werden, sondern auch in
gespeicherten Prozeduren und SQL-Anweisungen. Sie können die Java API-
Klassen als Erweiterungen zu den verfügbaren Funktionen behandeln, die
von SQL zur Verfügung gestellt werden.
Beispiel: Die SQL-Funktion PI(*) gibt den Wert für pi zurück. Die Java API-
Klasse java.lang.Math hat ein paralleles Feld namens PI, das denselben
Wert zurückgibt. Die Klasse java.lang.Math hat aber auch ein Feld namens
E, das die Basis von natürlichen Logarithmen zurückgibt, sowie eine
Methode, die die Restoperation auf zwei Argumente gemäß dem Standard
IEEE 754 durchführt.
Andere Bestandteile der Java API bieten weitere, zusätzliche Möglichkeiten.
Beispiel: java.util.Stack generiert eine Warteschlange nach dem Last-In-
First-Out-Prinzip, die eine Liste sortiert speichern kann,
java.util.HashTable wird benutzt, um Werte Schlüsseln zuzuordnen,
java.util.StringTokenizer unterteilt eine Zeichenfolge in einzelne
Worteinheiten.
$ Weitere Hinweise finden Sie unter "Java-Objekte einfügen,
aktualisieren und löschen" auf Seite 111.

Unterstützte Java-Klassen
Kapitel 3 Einführung in Java für Datenbanken
Die Datenbank unterstützt nicht alle Java API-Klassen. Einige Klassen,
beispielsweise das Paket java.awt, das Bestandteile der Benutzerschnittstelle
für Anwendungen enthält, ist in einem Datenbankserver nicht sinnvoll.
Andere Klassen, einschließlich Teile der Klasse java.io, übernehmen
Schreibfunktionen auf der Festplatte, was in einer Datenbankserver-
Umgebung ebenfalls nicht unterstützt wird.
$ Weitere Hinweise über unterstützte und nicht unterstützte Klassen
finden Sie unter "Unterstützte Java-Pakete" auf Seite 87 der Dokumentation
ASA SQL-Referenzhandbuch und "Nicht-unterstützte Java-Pakete und
Klassen" auf Seite 88 der Dokumentation ASA SQL-Referenzhandbuch.
Eigene Java-Klassen in Datenbanken einsetzen
Sie können Ihre eigenen Java-Klassen in einer Datenbank installieren.
Beispiel: Ein Entwickler könnte die benutzerdefinierte Klasse "Mitarbeiter"
oder "Verpackung" konzipieren, in Java schreiben und mit einem Java-
Compiler kompilieren.
Von einem Benutzer erstellte Java-Klassen können Informationen über den
Gegenstand der Klasse und Rechnerlogik enthalten. Nachdem sie in einer
Datenbank installiert wurden, stellt Adaptive Server Anywhere diese Klassen
in allen Teilen und Vorgängen der Datenbank zur Verfügung und führt ihre
Funktionen (in der Form von Klassen- oder Instanzenmethoden) genauso
schnell und einfach aus wie gespeicherte Prozeduren.
Java-Klassen und gespeicherte Prozeduren unterscheiden sich
Java-Klassen unterscheiden sich von gespeicherten Prozeduren. Während
gespeicherte Prozeduren in SQL geschrieben sind, bieten Java-Klassen
eine leistungsfähigere Sprache und können aus Clientanwendungen genau
so leicht aufgerufen werden wie gespeicherte Prozeduren.
Wenn eine Java-Klasse in einer Datenbank installiert wird, steht sie als neue
Domäne zur Verfügung. Eine Java-Klasse kann in jeder Situation verwendet
werden, in der integrierte SQL-Datentypen benutzt werden können: Als
Spaltentyp in einer Tabelle oder als Variablentyp.
Beispiel: Wenn eine Klasse namens Adresse in einer Datenbank installiert
wurde, kann eine Spalte in einer Tabelle namens Adr den Typ Adresse
haben, was bedeutet, dass nur auf der Klasse Adresse basierende Objekte als
Zeilenwerte für diese Spalte gespeichert werden können.
$ Weitere Hinweise finden Sie unter "Java-Klassen in einer Datenbank
installieren" auf Seite 103.
61

Fragen und Antworten zu Java in der Datenbank
Mit Java auf Daten zugreifen
62
Die JDBC-Schnittstelle ist ein Industriestandard, der speziell für den Zugriff
auf Datenbanksysteme entwickelt wurde. Die JDBC-Klassen sollen folgende
Aufgaben ermöglichen: Verbindung mit einer Datenbank, Anforderung von
Daten mit SQL-Anweisungen und Rücklieferung von Ergebnismengen, die
in der Clientanwendung verarbeitet werden können.
Normalerweise werden die JDBC-Klassen von einer Clientanwendung
verwendet, und der Datenbank-Systemlieferant stellt einen JDBC-Treiber zur
Verfügung, mit dem JDBC-Klassen eine Verbindung herstellen können.
Sie können sich aus einer Clientanwendung mit Adaptive Server Anywhere
über JDBC verbinden, indem Sie jConnect oder eine JDBC/ODBC-Brücke
benutzen. Adaptive Server Anywhere bietet auch einen internen JDBC-
Treiber, der es in einer Datenbank installierten Java-Klassen ermöglicht,
JDBC-Klassen zu verwenden, die SQL-Anweisungen ausführen.
$ Weitere Hinweise finden Sie unter "Datenzugriff über JDBC" auf
Seite 143.
Klassen vom Client auf einen Server verschieben
Verteilte Anwendungen erstellen
Sie können Java-Klassen erstellen, die zwischen verschiedenen Ebenen einer
Unternehmensanwendung verschoben werden können. Dieselbe Java-Klasse
kann in die Clientanwendung, eine mittlere Schicht oder die Datenbank
integriert werden - also an der Stelle, an der sie am sinnvollsten eingesetzt
werden kann.
Eine Klasse, die Geschäftslogik, Daten oder eine Kombination von beiden
enthält, kann auf jede Ebene des Unternehmenssystems, auch auf den Server,
verschoben werden, so dass Sie die vorhandenen Ressourcen optimal
einsetzen können. Die Betreiber von unternehmensweiten Systemen können
daher mit einer einzigen Programmiersprache in einer mehrschichtigen
Architektur mit bisher nie gekannter Flexibilität eigene Anwendungen
entwickeln.
Sie können eine Anwendung erstellen, bei der einige Teile in der Datenbank
arbeiten, andere auf dem Client-System. Sie können Java-Objekte vom
Server an den Client übergeben und umgekehrt, genauso wie Sie SQL-Daten
wie Zeichendaten und numerische Werte übergeben können.
$ Weitere Hinweise finden Sie unter "Verteilte Anwendungen erstellen"
auf Seite 174.

Einschränkungen für Java in der Datenbank
Kapitel 3 Einführung in Java für Datenbanken
Adaptive Server Anywhere ist eine Laufzeit-Umgebung für Java-Klassen,
keine Java-Entwicklungsumgebung.
Sie können folgende Aufgaben in einer Datenbank nicht durchführen:
♦ Klasse-Quelldaten bearbeiten (*.java-Dateien).
♦ Java-Klassen-Quelldateien kompilieren (*.java-Dateien).
♦ Java APIs ausführen, die nicht unterstützt werden, wie z.B. Applets und
visuelle Klassen
♦ Java-Methoden ausführen, die die Ausführung nativer Methoden
voraussetzen. Alle Benutzerklassen, die in einer Datenbank installiert
sind, müssen 100% Java sein.
Die in Adaptive Server Anywhere benutzten Klassen müssen mit einem
Java-Entwicklungstool geschrieben und kompiliert werden. Danach werden
sie in einer Datenbank installiert, um dort getestet, auf Fehler geprüft und
vom Endbenutzer benutzt zu werden.
63

Ein Java-Seminar
Ein Java-Seminar
Erklärung von Java-Klassen
64
In diesem Abschnitt werden die wichtigsten Java-Konzepte vorgestellt.
Nachdem Sie sich diesen Abschnitt durchgelesen haben, sollten Sie in der
Lage sein, Java-Code zu prüfen, wie z.B. einfache Klassendefinitionen oder
den Aufruf einer Methode, bzw. gegebenenfalls verstehen, warum etwaige
Probleme auftreten.
Java-Beispielverzeichnis
Alle Klassen, die als Beispiele in diesem Dokument verwendet werden,
sind im Verzeichnis mit den Java-Beispielen zu finden, nämlich im
Unterverzeichnis Samples\ASA\Java zum Verzeichnis von Adaptive
Server Anywhere.
Zwei Dateien stehen für jedes Java-Klassen-Beispiel: Java-Quellcode und
kompilierte Klasse. Sie können die kompilierte Version der Beispiele von
Java-Klassen in einer Datenbank sofort und ohne Änderung installieren.
Eine Java-Klasse kombiniert Daten und Funktionen: Die Möglichkeit zur
Speicherung von Informationen und die Fähigkeit zur Durchführung von
Rechenvorgängen. Eine Klasse kann man als eine Entität, also eine abstrakte
Darstellung von Dingen sehen.
Eine "Rechnungsklasse” könnte beispielsweise so entworfen werden, dass
sie eine normale Rechnung imitiert, wie sie im täglichen Geschäftsverkehr
verwendet wird. Eine Rechnung enthält bestimmte Informationen (z.B. die
verrechneten Artikel, die Rechnungsadresse, Rechnungsdatum, Zahlbetrag
und Fälligkeit) - dasselbe gilt für die Instanz einer Rechnungsklasse. Klassen
speichern Daten in Feldern.
Eine Klasse beschreibt nicht nur Daten, sondern kann auch Berechnungen
vornehmen und logische Vorgänge durchführen. Die Rechnungsklasse
könnte beispielsweise die Steuer für eine Liste von Rechnungsposten für
jedes Rechnungsobjekt errechnen und der Zwischensumme hinzufügen, um
damit die Gesamtrechnungssumme auszuwerfen, ohne dass ein Eingriff des
Benutzers erforderlich wäre. Eine solche Klasse würde auch dafür sorgen,
dass alle benötigten Informationselemente in die Rechnung eingefügt
werden, und könnte sogar automatisch anzeigen, ob die Zahlung fällig ist
oder schon teilweise geleistet wurde. Berechnungen und andere logische
Vorgänge werden durch die Methoden einer Klasse ausgeführt.

Beispiel
Unterklassen in Java
Kapitel 3 Einführung in Java für Datenbanken
Der folgende Java-Code deklariert eine Klasse namens "Invoice". Diese
Klassendeklaration würde in einer Datei namens Invoice.java gespeichert und
dann mit einem Java-Compiler in eine Java-Klasse kompiliert.
Java-Klassen kompilieren
Beim Kompilieren des Quellcodes für eine Java-Klasse wird eine neue
Datei mit demselben Namen wie die Quelldatei erzeugt, jedoch mit einer
anderen Erweiterung. Durch das Kompilieren von Invoice.java wird dabei
eine Datei namens Invoice.class erstellt, die in einer Java-Anwendung
verwendet und durch eine Java VM ausgeführt werden kann.
Das Sun JDK Tool für das Kompilieren der Klassendeklarationen ist
javac.exe.
public class Invoice {
// Bis jetzt kann diese Klasse nichts und hat auch
keine Daten
}
Auf das Schlüsselwort class folgt der Name der Klasse. Es gibt eine
geöffnete und eine geschlossene geschweifte Klammer. Alles, was
dazwischen liegt, also z.B. Felder und Methoden, wird zu einem Teil der
Klasse.
Grundsätzlich gibt es keinen Java-Code außerhalb von Klassen. Sogar die
Java-Prozedur, die von einem Java-Interpreter automatisch ausgeführt wird,
um andere Objekte zu erstellen - die Hauptmethode (main), die oft der
Beginn Ihrer Anwendung ist - befindet sich selbst wieder innerhalb einer
Klassendeklaration.
Sie können Klassen als Unterklassen (subclasses) anderer Klassen
definieren. Eine Klasse, die als Unterklasse einer anderen Klasse fungiert,
kann die Felder und Methoden ihrer übergeordneten Klasse verwenden: Dies
wird als Vererbung bezeichnet. Sie können zusätzliche Methoden und
Felder definieren, die nur für die Unterklasse gelten, und die Bedeutung der
geerbten Felder und Methoden verändern.
Java ist eine Programmiersprache mit einer Einzelhierarchie. Das bedeutet,
dass alle Klassen, die Sie erstellen oder benutzen, von einer Klasse erben.
Das bedeutet weiterhin, dass die Klassen der niedrigsten Ebene (also in der
Hierarchie weiter oben angesiedelt) vorhanden sein müssen, bevor Klassen
der oberen Ebene benutzt werden können. Die Basisgruppe der
erforderlichen Klassen für Java-Anwendungen wird als Laufzeit-Java-
Klassen oder Java-API bezeichnet.
65

Ein Java-Seminar
Erklärung der Java-Objekte
Methoden und
Felder
Klassenkonstruktoren
66
Eine Klasse definiert, was ein Objekt tun kann, genauso wie ein
Rechnungsformular festlegt, welche Informationen die Rechnung enthalten
sollte.
Klassen enthalten keine spezifischen Informationen über Objekte. Vielmehr
erstellt oder instanziert Ihre Anwendung Objekte auf Grundlage der Klasse
(Vorlage), und die Objekte enthalten die Daten bzw. führen Berechnungen
aus. Das instanzierte Objekt ist eine Instanz der Klasse. Beispiel: Ein
Rechungsobjekt ist eine Instanz der Rechnungsklasse. Die Klasse definiert,
was das Objekt leisten kann, aber das Objekt ist die Verwirklichung der
Klasse, die erst Sinn und praktische Verwendbarkeit der Klasse ermöglicht.
Im Beispiel mit dem Rechnungsformular definiert es, was alle Rechnungen
enthalten müssen, die auf diesem Rechnungsformular aufgebaut werden. Es
gibt ein Formular und 0 bis unendlich viele Rechnungen, die aufgrund dieses
Formulars erstellt werden. Das Formular enthält die Definition, aber die
Rechnung beinhaltet dann den tatsächlichen Nutzen.
Das Rechnungsobjekt, das aus der Klasse erstellt wird, enthält die Daten,
wird gespeichert, abgerufen, bearbeitet, und so weiter.
Genauso wie ein Rechnungsformular verwendet wird, um viele Rechnungen
zu erstellen, wobei jede Rechnung in den Details von jeder anderen
Rechnung abweicht, so können aus einer Klasse viele Objekte abgeleitet
werden.
Eine Methode ist der Teil einer Klasse, der Arbeit leistet, eine Funktion, die
für die Klasse eine Berechnung durchführt oder mit anderen Objekten
interagiert. Methoden können Argumente aufnehmen und einen Wert an die
aufrufende Funktion zurückgeben. Wenn kein Rückgabewert benötigt wird,
kann eine Methode void (leer) zurückgegeben werden. Klassen können jede
beliebige Anzahl von Methoden haben.
Ein Feld ist Teil einer Klasse, das Informationen enthält. Wenn ein Objekt
des Typs JavaClass erstellt wird, enthalten die Felder in der JavaClass einen
ausschließlich für dieses Objekt bestimmten Zustand.
Sie erstellen ein Objekt, indem Sie einen Klassen-Konstruktor aufrufen. Ein
Konstruktor ist eine Methode mit den folgenden Eigenschaften:
♦ Eine Konstruktormethode hat denselben Namen wie die Klasse und
keinen deklarierten Datentyp. Beispiel: Ein einfacher Konstruktor für
die Klasse "Produkt" würde wie folgt deklariert werden:
Produkt () {

Erklärung von Feldern
Beispiele
Kapitel 3 Einführung in Java für Datenbanken
...Konstruktorcode wird hier eingegeben...
}
♦ Wenn Sie keine Konstruktormethode in Ihre Klassendefinition
aufnehmen, wird eine Standardmethode benutzt, die mit dem Java-
Basisobjekt mitgeliefert wurde.
♦ Sie können mehr als einen Konstruktor für jede Klasse mit
unterschiedlichen Argumenttypen- und Argumentzahlen liefern. Beim
Aufruf eines Konstruktors wird derjenige benutzt, der die richtige
Argumentzahl und die passenden Argumenttypen aufweist.
Es gibt zwei Kategorien von Java-Feldern:
♦ Instanzfelder Jedes Objekt hat seine eigene Gruppe von Instanzfeldern,
die bei der Erstellung des Objekts geschaffen wurden. Sie enthalten
Informationen, die speziell für diese Instanz gelten. Beispiel: Ein Feld
lineItem1Description in der Klasse "Invoice" enthält die Beschreibung
für einen Rechnungsposten einer bestimmten Rechnung. Sie können auf
Instanzfelder nur über eine Objektreferenz zugreifen.
♦ Klassenfelder Ein Klassenfeld enthält Informationen, die von einer
bestimmten Instanz unabhängig sind. Ein Klassenfeld wird erstellt, wenn
die Klasse zum ersten Mal geladen wird, und es werden keine weiteren
Instanzen geschaffen, gleichgültig wie viele Objekte erzeugt werden.
Auf Klassenfelder kann über den Klassennamen oder die Objektreferenz
zugegriffen werden.
Um ein Feld in einer Klasse zu deklarieren, legen Sie seinen Typ fest und
setzen danach seinen Namen und ein Semikolon. Um ein Klassenfeld zu
erstellen, benutzen Sie das Java-Schlüsselwort static in der Deklaration.
Felder werden im Hauptteil einer Klasse, und nicht in einer Methode
deklariert. Die Deklaration einer Variablen in einer Methode macht sie zu
einem Teil der Methode, nicht der Klasse.
Die folgende Deklaration der Klasse "Invoice" hat vier Felder, die den
Informationen entsprechen, welche auf zwei Buchungszeilen in einer
Rechnung stehen könnten.
67

Ein Java-Seminar
Erklärung von Methoden
68
public class Invoice {
}
// Felder einer Rechnung mit Rechnungsdaten
public String lineItem1Description;
public int lineItem1Cost;
public String lineItem2Description;
public int lineItem2Cost;
Es gibt zwei Kategorien von Java-Methoden:
♦ Instanzmethoden Eine totalSum-Methode in der Klasse "Invoice"
muss die Steuer ausrechnen und hinzuaddieren, damit alle Kosten
enthalten sind. Sie ist aber nur sinnvoll, wenn Sie im Zusammenhang
mit einem Invoice-Objekt aufgerufen wird, bei dem die einzelnen
Rechnungsposten zusätzliche Steuer- oder Kostenposten enthalten. Die
Berechnung kann nur für ein Objekt ausgeführt werden, da das Objekt
die beiden Rechnungszeilen enthält, nicht die Klasse.
♦ Klassenmethoden Klassenmethoden (auch als statische Methoden
bekannt) können aufgerufen werden, ohne dass erst ein Objekt erstellt
werden muss. Nur der Name der Klasse und der Methode sind
erforderlich, um eine Klassenmethode aufzurufen.
Ähnlich wie bei Instanzmethoden akzeptieren die Klassenmethoden
Argumente und Rückgabewerte. In der Regel führen Klassenmethoden
eine Art von Dienstprogramm oder Informationsfunktion aus, die mit
der Allgemeinfunktion der Klasse in Beziehung stehen.
Klassenmethoden können auf Instanzenfelder nicht zugreifen.
Um eine Methode zu deklarieren, geben Sie ihren Rückgabetyp, ihren
Namen und alle von ihr übernommenen Parameter an. Wie eine
Klassendeklaration benutzt die Methode eine geöffnete und geschlossene
geschweifte Klammer, um den Hauptteil der Methode zu definieren, in den
der Programmcode gesetzt wird.

Beispiel
Beispiel
public class Invoice {
Kapitel 3 Einführung in Java für Datenbanken
// Felder
public String lineItem1Description;
public double lineItem1Cost;
}
public String lineItem2Description;
public double lineItem2Cost;
//Eine Methode
public double totalSum() {
double runningsum;
}
runningsum = lineItem1Cost +
lineItem2Cost;
runningsum = runningsum * 1,16;
return runningsum;
Im Hauptteil der Methode totalSum wird eine Variable namens runningsum
deklariert. Sie wird zunächst verwendet, um die Zwischensumme der ersten
und der zweiten Zeile aufzunehmen. Diese Zwischensumme wird dann mit
16 Prozent (z.B. Mehrwertsteuer) multipliziert, um die Gesamtsumme zu
erhalten.
Die lokale Variable (die im Hauptteil der Methode bekannt ist), wird dann an
die aufrufende Funktion zurückgegeben. Wenn die Methode totalSum
aufgerufen wird, gibt sie die Summe der zwei Zeilen plus die Steuer auf
diese Summe zurück.
Die Methode parseInt der Klasse java.lang.Integer, die mit Adaptive
Server Anywhere mitgeliefert wird, ist ein Beispiel für eine Klassenmethode.
Wenn ihr ein Zeichenfolgenargument übergeben wird, gibt die Methode
parseInt eine Ganzzahl-Version der Zeichenfolge zurück.
Beispiel: Gegeben sei der Zeichenfolgenwert "1". Die Methode parseInt
gibt den Ganzzahlwert 1 zurück, ohne eine Instanz der Klasse
java.lang.Integer erstellen zu müssen. Das Beispiel wird im nachstehenden
Java-Codefragment veranschaulicht:
String num = "1";
int i = java.lang.Integer.parseInt( num );
Die folgende Version der Rechnungsklasse enthält nun eine Instanzmethode
und eine Klassenmethode. Die Klassenmethode namens rateOfTaxation
gibt die Steuerrate zurück, die von der Klasse benutzt wird, um die
Gesamtsumme der Rechnung zu kalkulieren.
69

Ein Java-Seminar
70
Dass die Methode rateOfTaxation zur Klassenmethode (und nicht zur
Instanzmethode oder zu einem Feld) gemacht wurde, liegt darin, dass andere
Klassen und Prozeduren den Wert benutzen können, der von dieser Methode
zurückgegeben wird, ohne erst eine Instanz der Klasse erstellen zu müssen.
Nur der Name der Klasse und der Methode sind erforderlich, um den
Steuersatz auszugeben, der von dieser Klasse verwendet wird.
Dadurch dass der Steuersatz rateOfTaxation zu einer Methode, und nicht zu
einem Feld gemacht wird, kann der Anwendungsentwickler den Steuersatz
ändern, ohne dass dies Auswirkungen auf Objekte, Anwendungen oder
Prozeduren hätte, die den Rückgabewert dieser Methode verwenden.
Zukünftige Versionen der Klasse "Invoice" können den Rückgabewert der
Klassenmethode rateOfTaxation auf einer komplizierteren Berechnung
basieren lassen, ohne dass andere Methoden beeinträchtigt werden, die den
Rückgabewert verwenden.
public class Invoice {
// Felder
public String lineItem1Description;
public double lineItem1Cost;
public String lineItem2Description;
public double lineItem2Cost;
// Eine Instanzenmethode
public double totalSum() {
double runningsum;
double taxfactor = 1 + Invoice.rateOfTaxation();
}
runningsum = lineItem1Cost + lineItem2Cost;
runningsum = runningsum * taxfactor;
return runningsum;
}
// Eine Klassenmethode
public static double rateOfTaxation() {
double rate;
rate = .16;
return rate;
}
Objektorientierte und prozedurale Sprachen
Wenn Sie mehr Erfahrung mit prozeduralen Sprachen wie C oder der
Sprache für gespeicherte Prozeduren haben als mit objektorientierten
Sprachen, finden Sie in diesem Abschnitt eine Erörterung der Ähnlichkeiten
und Unterschiede zwischen prozeduralen und objektorientierten Sprachen.

Java basiert auf
Klassen
Ein Glossar der Java-Begriffe
Pakete
Kapitel 3 Einführung in Java für Datenbanken
Die wichtigste strukturelle Einheit eines Codes in Java ist eine Klasse.
Eine Java-Klasse ist im Prinzip eine Sammlung von Prozeduren und
Variablen, die gruppiert wurden, weil sie alle zu einer bestimmten,
identifizierbaren Kategorie gehören.
Die Art und Weise, wie eine Klasse benutzt wird, unterscheidet aber die
objektorientierten Sprachen von prozeduralen Sprachen. Eine in einer
prozeduralen Sprache geschriebene Anwendung wird ausgeführt, indem sie
einmal in den Speicher geladen wird und eine genau vorgegebene
Abwicklungsfolge einhält.
In objektorientierten Sprachen wie Java wird eine Klasse wie eine Vorlage
benutzt: Eine Definition einer potenziellen Programmausführung. Mehrere
Kopien der Klasse können je nach Anforderung erstellt und dynamisch
geladen werden, wobei jede Instanz der Klasse eigene Daten, Werte und
Ablaufprozeduren enthalten kann. Jede geladene Klasse wird unabhängig
von anderen im Speicher geladenen Klassen behandelt und ausgeführt.
Eine Klasse, die zum Ausführen in den Speicher geladen wurde, wird als
instanziert bezeichnet. Eine instanzierte Klasse wird "Objekt" genannt: Dabei
handelt es sich um eine Anwendung, die von der Klasse abgeleitet wurde, die
vorbereitet wurde, um eindeutige Werte zu enthalten bzw. um zu bewirken,
dass ihre Methoden unabhängig von anderen Klasseninstanzen ausgeführt
werden.
Im folgenden Abschnitt werden einige Begriffe im Zusammenhang mit Java-
Klassen erklärt. Dies ist natürlich keine erschöpfende Behandlung der Java-
Sprache, sondern soll das Konzept der Java-Klassen in Adaptive Server
Anywhere vorstellen.
$ Weitere Hinweise über die Sprache Java finden Sie in der Online-
Dokumentation Thinking in Java von Bruce Eckel. Sie gehört zum
Lieferumfang von Adaptive Server Anywhere, und Sie finden sie in der
Datei Samples\ASA\Java\Tjava.pdf.
Ein Paket ist eine Gruppe von Klassen, die einen gemeinsamen Zweck oder
eine gemeinsame Kategorie haben. Ein Mitglied eines Pakets hat spezielle
Berechtigungen für den Zugriff auf Daten und Methoden bei anderen
Mitgliedern des Pakets, und daher gibt es den Zugriffsmodifizierer
protected.
71

Ein Java-Seminar
"Public" und
"Private"
Konstruktoren
Sammlung der
Abfalldaten
72
Ein Paket ist in Java das, was sonst unter einer Bibliothek oder Library
bekannt ist. Es handelt sich dabei um eine Sammlung von Klassen, die mit
der import-Anweisung verfügbar gemacht werden können. Die folgende
Java-Anweisung importiert die Dienstprogramm-Bibliothek aus der Java-
API:
import java.util.*
Pakete werden normalerweise in JAR-Dateien gespeichert, mit der
Erweiterung .jar oder .zip.
Ein Zugriffsmodifizierer (im Wesentlichen die Schlüsselwörter public,
private oder protected vor jeder Deklaration) bestimmt die Sichtbarkeit
eines Feldes, einer Methode oder einer Klasse für andere Java-Objekte.
♦ Mit public bezeichnete Klassen, Methoden oder Felder sind überall
sichtbar.
♦ Mit private bezeichnete Klassen, Methoden oder Felder sind nur in
Methoden sichtbar, die in dieser Klasse definiert wurden.
♦ Mit protected bezeichnete Methoden oder Felder sind für Methoden
sichtbar, die innerhalb dieser Klasse, in Unterklassen dieser Klassen
oder in anderen Klassen des selben Pakets definiert wurden.
♦ Die Standardsichtbarkeit (Paket) bedeutet, dass die Methoden oder
Felder innerhalb der Klasse oder für andere Klassen im Paket sichtbar
sind.
Ein Konstruktor ist eine spezielle Methode einer Java-Klasse, die
aufgerufen wird, wenn eine Instanz der Klasse erstellt wird.
Klassen können ihre eigenen Konstruktoren definieren, darunter mehrfache,
einander aufhebende Konstruktoren. Welcher Konstruktor verwendet wird,
hängt davon ab, welche Argumente beim Versuch der Erstellung des Objekts
verwendet wurden. Wenn der Typ, die Anzahl und die Reihenfolge der
Argumente, die für die Erstellung einer Instanz der Klasse verwendet
werden, zu einem der Konstruktoren der Klasse passen, wird dieser
Konstruktor verwendet, um das Objekt zu erstellen.
Die Abfalldatensammlung entfernt automatisch alle Objekte, für die keine
Referenzen bestehen, mit Ausnahme der Objekte, die als Werte in einer
Tabelle gespeichert sind.
In Java gibt es keine Destruktorenmethode wie in C++. Java-Klassen können
ihre eigene Abschluss-Methode ("finalize") für das Aufräumen definieren,
nachdem ein Objekt nach der Abfalldatensammlung entfernt wurde.

Schnittstellen oder
Interfaces
Fehlerbehandlung in Java
Fehlertypen in
Java
Kapitel 3 Einführung in Java für Datenbanken
Java-Klassen können nur von einer Klasse erben. Java benutzt Interfaces
(Schnittstellen) anstelle von mehrfacher Vererbung. Eine Klasse kann
mehrere Schnittstellen implementieren. Jede Schnittstelle definiert eine
Reihe von Methoden und Methodenprofilen, die von der Klasse
implementiert werden müssen, damit die Klasse kompiliert werden kann.
Eine Schnittstelle definiert, welche Methoden und statischen Felder die
Klasse deklarieren muss. Die Implementierung der Methoden und Felder, die
in einer Schnittstelle deklariert werden, erfolgt in der Klasse, die die
Schnittstelle benutzt: Die Schnittstelle definiert, was die Klasse deklarieren
muss, und es obliegt der Klasse, festzulegen, wie die Implementierung vor
sich geht.
Der Fehlerbehandlungscode ist in Java von der normalen Verarbeitung
getrennt.
Fehler generieren ein Ausnahmebedingungsobjekt, das den Fehler darstellt.
Dies wird als throwing an exception (Ausnahmefehler auslösen) bezeichnet.
Eine ausgelöste Ausnahmebedingung beendet ein Java-Programm, wenn sie
nicht in der Anwendung abgefangen und entsprechend verarbeitet wird.
Sowohl Java-API-Klassen, als auch benutzerdefinierte Klassen können einen
Ausnahmefehler auswerfen. Benutzer können ihre eigenen Ausnahmeklassen
erstellen, die ihre eigenen benutzerdefinierten Klassen auswerfen können.
Wenn im Hauptteil der Methode, in der der Ausnahmefehler auftrat, keine
Ausnahmeroutine vorgesehen ist, wird die Suche nach einer
Ausnahmeroutine über den kompletten Aufrufstack fortgesetzt. Wenn die
Spitze des Aufrufstacks erreicht ist und noch immer keine Ausnahmeroutine
gefunden wurde, wird die Standard-Ausnahmeroutine des Java-Interpreters
aufgerufen und das Programm beendet.
In Adaptive Server Anywhere gilt: Wenn eine SQL-Anweisung eine Java-
Methode aufruft, wird ein SQL-Fehler generiert.
Alle Fehler in Java werden aus zwei Arten von Fehlerklassen abgeleitet:
Ausnahme (Exception) und Fehler (Error). Normalerweise werden Fehler
vom Typ "Exception" durch Fehlerroutinen im Hauptteil der Methode
verarbeitet. Fehler vom Typ "Error" sind für interne Fehler und
Fehlerbedingungen wegen Ressourcenmangel im Java-Laufzeitsystem
vorgesehen.
Ausnahmebedingungsfehler werden ausgeworfen und abgefangen. Die
Verarbeitungsroutinen bei Ausnahmefehlern werden durch die Codeblöcke
try, catch und finally gekennzeichnet.
73

Ein Java-Seminar
74
Ein try-Block führt einen Programmcode aus, der einen Fehler generieren
kann. Ein catch-Block ist ein Codeteil, der ausgeführt wird, wenn ein Fehler
während der Ausführung eines try-Blocks generiert (ausgeworfen) wird.
Ein finally-Block definiert einen Codeblock, der unabhängig davon
ausgeführt wird, ob ein Fehler generiert und abgefangen wurde.
Typischerweise wird er für Aufräumroutinen verwendet. Er wird für Code
benutzt, der unter keinen Umständen ausgelassen werden darf.
Ausnahmebedingungsfehler werden in zwei Typen unterteilt: Laufzeitfehler
und Nicht-Laufzeitfehler.
Fehler, die vom Laufzeitsystem generiert wurden, sind als implizite
Ausnahmefehler bekannt, da sie nicht explizit als Teil jeder Klassen- oder
Methodendeklaration verarbeitet werden müssen.
Beispiel: Der Ausnahmefehler "array out of bounds" kann auftreten, wenn
ein Array benutzt wird, der Fehler muss aber nicht Teil der Deklaration der
Klasse oder Methode sein, die dieses Array benutzen.
Alle anderen Ausnahmebedingungen sind explizit. Wenn die aufgerufene
Methode einen Ausnahmefehler auswerfen kann, muss der Fehler explizit
von der Klasse abgefangen werden, die die Auswurfmethode für den Fehler
benutzt, oder diese Klasse muss explizit den Fehler selbst auswerfen, indem
die Ausnahmebedingung, die generiert werden könnte, in ihrer
Klassendeklaration identifiziert wird. Im Wesentlichen heißt das: Explizite
Ausnahmebedingungen müssen explizit behandelt werden. Eine Methode
muss alle expliziten Fehler deklarieren, die sie auswirft, oder alle expliziten
Fehler abfangen, die möglicherweise ausgeworfen werden.
Nicht-Laufzeitfehler werden zum Kompilierungszeitpunkt geprüft.
Laufzeitfehler werden normalerweise durch Programmierungsfehler
verursacht. Java erkennt viele dieser Fehler während der Kompilierung,
bevor der Code ausgeführt wird.
Für jede Java-Methode wird ein alternativer Ausführungspfad definiert,
sodass alle Java-Methoden abgeschlossen werden können, auch wenn der
normale Abschluss nicht möglich ist. Wenn der Typ des ausgeworfenen
Fehlers nicht erfasst ist, wird er an den nächsten Code-Block oder die
nächste Methode im Stack weitergereicht.

Kapitel 3 Einführung in Java für Datenbanken
Die Laufzeitumgebung für Java in der Datenbank
In diesem Abschnitt wird die Sybase-Laufzeitumgebung für Java
beschrieben, und wie sie sich von einer Standard-Java-Laufzeitumgebung
unterscheidet.
Unterstützte Versionen von Java und JDBC
Die Laufzeit-Java-Klassen
Die Sybase Java VM bietet die Auswahl zwischen den
Programmierschnittstellen JDK 1.1, JDK 1.2, und JDK 1.3. Die tatsächlich
gelieferte Version ist JDK 1.1.8. und 1.3.
Zwischen Version 1.0 des JDK und Version 1.1 wurden einige neue APIs
eingeführt. Außerdem wurden einige APIs entfernt. Die Verwendung
bestimmter APIs wird nicht länger empfohlen, und die Unterstützung dieser
APIs könnte in kommenden Versionen nicht mehr gesichert sein.
Eine Java-Klassendatei, die nicht mehr empfohlene API verwendet, generiert
beim Kompilieren eine Warnung, kann aber auf einer Java Virtual Machine
ausgeführt werden, die gemäß den Standards der Version 1.1 programmiert
wurde, wie z.B. der Sybase VM.
Der interne JDBC-Treiber unterstützt JDBC Version 2.
$ Weitere Hinweise zu den unterstützten JDK APIs finden Sie unter
"Unterstützte Java-Pakete" auf Seite 87 der Dokumentation ASA SQL-
Referenzhandbuch.
$ Hinweise zum Erstellen einer Datenbank, die Java unterstützt, finden
Sie unter "Datenbank für Java aktivieren" auf Seite 97.
Die Laufzeit-Java-Klassen sind die Klassen der niedrigen Stufe, die für eine
Datenbank verfügbar gemacht werden, wenn Sie erstellt oder für Java
aktiviert wird. Diese Klassen enthalten eine Teilmenge der Java-API. Diese
Klassen sind Teil des Sun Java Development Kit.
Die Laufzeit-Klassen bieten Funktionen, auf denen Anwendungen aufbauen
können. Die Laufzeit-Klassen sind für Klassen in der Datenbank immer
verfügbar.
75

Die Laufzeitumgebung für Java in der Datenbank
Beispiele
Benutzerdefinierte Klassen
76
Sie können die Laufzeit-Java-Klassen in Ihre eigenen benutzerdefinierten
Klassen einbeziehen: Entweder, indem sie deren Funktionen erben oder
indem Sie sie bei einer Berechnung oder einem Vorgang in einer Methode
verwenden.
Einige Java-API-Klassen, die in den Laufzeit-Java-Klassen enthalten sind:
♦ Primitive Java-Datentypen Alle "primitiven" (nativen) Datentypen in
Java haben eine entsprechende Klasse. Um Objekte dieser Typen zu
erstellen, haben die Klassen zusätzliche, oft sehr nützliche Funktionen.
Der Java-Datentyp int hat eine entsprechende Klasse in
java.lang.Integer.
♦ Das Dienstprogramm-Paket Das Paket java.util.* enthält eine Reihe
von sehr hilfreichen Klassen, deren Funktionen keine Entsprechung in
den SQL-Funktionen haben, welche in Adaptive Server Anywhere
verfügbar sind.
Zu diesen Klassen gehören:
♦ Hashtable Eine Zuordnung von Schlüsseln und Werten.
♦ StringTokenizer Diese Klasse zerlegt eine Zeichenfolge in
Einzelwörter.
♦ Vector Diese Klasse enthält ein Array von Objekten, deren Größe
sich dynamisch ändern kann.
♦ Stack Diese Klasse enthält einen Last-in-First-out-Stack von
Objekten.
♦ JDBC für SQL-Vorgänge Das Paket java.SQL.* enthält die Klassen die
von Java-Objekten benötigt werden, um Daten mit SQL-Anweisungen
aus der Datenbank zu extrahieren.
Anders als benutzerdefinierte Klassen werden die Laufzeitklassen in der
Datenbank nicht gespeichert. Sie werden vielmehr im Unterverzeichnis java
des Adaptive Server Anywhere-Installationsverzeichnisses gespeichert.
Benutzerdefinierte Klassen werden in einer Datenbank mit der Anweisung
INSTALL installiert. Nach ihrer Installation stehen sie anderen Klassen in
der Datenbank zur Verfügung. Wenn es sich um öffentliche Klassen handelt,
stehen Sie für SQL als Domänen zur Verfügung.
$ Hinweise zur Installation von Klassen finden Sie unter "Java-Klassen in
einer Datenbank installieren" auf Seite 103.

Java-Methoden und Felder identifizieren
Der Punkt in SQL
Der Punkt in Java
Aufruf von Java-
Methoden aus SQL
Kapitel 3 Einführung in Java für Datenbanken
In SQL-Anweisungen identifiziert der Punkt Spalten von Tabellen, wie zum
Beispiel in der folgenden Abfrage:
SELECT employee.emp_id
FROM employee
Der Punkt kennzeichnet auch die Eigentümerschaft in qualifizierten
Objektnamen:
SELECT emp_id
FROM DBA.employee
In Java ist der Punkt ein Operator, der die Methoden aufruft oder auf die
Felder einer Java-Klasse oder eines Java-Objekts zugreift. Er ist auch Teil
eines Bezeichners, der benutzt wird, um Klassennamen zu kennzeichnen,
wie im voll qualifizierten Klassennamen java.util.Hashtable.
Im nachstehenden Java-Codefragment ist der Punkt in der ersten Zeile ein
Bezeichner. In der zweiten Zeile des Programmcodes ist er ein Operator.
java.util.Random rnd = new java.util.Random();
int i = rnd.nextInt();
In SQL kann der Punktoperator durch eine doppelte geschlossene spitze
Klammer (>>) ersetzt werden. Der Punktoperator ist für Java passender,
kann aber bei bestehenden SQL-Namen zu Verwechslungen führen. Die
Verwendung von >> beseitigt diese Zweideutigkeit.
>> in SQL ist nicht dasselbe wie >> in Java
Die doppelte geschlossene spitze Klammer wird nur in SQL-
Anweisungen verwendet, wo sonst ein Java-Punktoperator erwartet wird.
In einer Java-Klasse ist die doppelte geschlossene spitze Klammer kein
Ersatz für den Punktoperator und hat eine vollständig andere Bedeutung
in ihrer Rolle als rechter Bitverschiebungs-Operator.
Die folgende SQL-Anweisungsfolge ist beispielsweise gültig:
CREATE VARIABLE rnd java.util.Random;
SET rnd = NEW java.util.Random();
SELECT rnd>>nextInt();
Das Ergebnis der SELECT-Anweisung ist eine zufallsgenerierte Ganzzahl.
Unter Verwendung der Variablen, die im vorhergehenden SQL-Beispiel
erstellt wurde, zeigt die folgende SQL-Anweisung die richtige Verwendung
einer Klassenmethode:
SELECT java.lang.Math>>abs( rnd>>nextInt() );
77

Die Laufzeitumgebung für Java in der Datenbank
Java berücksichtigt Groß/Kleinschreibung
Datentypen
Zeichenfolgen in Java und SQL
78
Java-Syntax funktioniert so, wie Sie es von ihr erwarten, und SQL-Syntax
wird durch das Vorhandensein von Java-Klassen nicht verändert. Dies bleibt
auch so, wenn dieselbe SQL-Anweisung sowohl Java, als auch SQL-Syntax
enthält. Dies ist eine einfache Feststellung, aber mit weit reichenden
Auswirkungen.
Java berücksichtigt die Groß/Kleinschreibung. Die Java-Klasse FindOut ist
nicht dasselbe wie die Klasse Findout. SQL berücksichtigt die Groß-/Kleinschreibung
bei Schlüsselwörtern und Bezeichnern nicht.
Die Berücksichtigung von Groß-/Kleinschreibung durch Java wird auch
beibehalten, wenn der Java-Code in eine SQL-Anweisung eingebettet ist, die
die Groß-/Kleinschreibung nicht berücksichtigt. Die Java-Teile der
Anweisung müssen die Groß/Kleinschreibung berücksichtigen, auch wenn
die Teile vor und nach der Java-Syntax ohne Berücksichtigung der
Schreibweise programmiert werden können.
Beispielsweise werden die nachstehenden SQL-Anweisungen erfolgreich
ausgeführt, da die Schreibweise der Java-Objekte, Klassen und Operatoren
respektiert wird, auch wenn im restlichen Teil der SQL-Anweisung die
Groß-/Kleinschreibung nicht einheitlich ist.
SeLeCt java.lang.Math.random();
Wenn eine Java-Klasse als Datentyp für eine Spalte verwendet wird, erfolgt
dies in Form eines benutzerdefinierten SQL-Datentyps. Trotzdem wird die
Groß/Kleinschreibung immer berücksichtigt. Diese Konvention verhindert
Zweideutigkeiten mit Java-Klassen, die sich nur durch die Groß-/Kleinschreibung
voneinander unterscheiden.
Mit Anführungszeichen werden Zeichenfolgenliterale in Java
gekennzeichnet, wie im folgenden Java-Programmfragment gezeigt wird:
String str = "Dies ist eine Zeichenfolge"
In SQL werden Zeichenfolgen hingegen mit Apostrophen gekennzeichnet,
und Anführungszeichen kennzeichnen einen Bezeichner, wie in der
folgenden SQL-Anweisung:
INSERT INTO TABLE DBA.t1
VALUES( ’Hallo’ )
In Java-Quellcode müssen Sie immer Anführungszeichen verwenden, in
SQL-Anweisungen hingegen Apostrophe.
Die folgenden SQL-Anweisungen sind beispielsweise gültig.

Ausgabe in die Befehlszeile
Kapitel 3 Einführung in Java für Datenbanken
CREATE VARIABLE str char(20);
set str = new java.lang.String( ’Brandneues Objekt’ )
Das folgende Java-Codefragment ist auch gültig, wenn es in einer Java-
Klasse verwendet wird.
String str = new java.lang.String(
"Brandneues Objekt" );
Die Ausgabe in die Standardausgabe ist eine Technik für die schnelle
Prüfung von Variablenwerten und Ausführungsergebnissen an bestimmten
Stellen im Programmcode. Bei Erkennung der Methode in der zweiten Zeile
des folgenden Java-Codefragments wird das Zeichenfolgenargument, das
von der Methode akzeptiert wird, in die Standardausgabe geschrieben.
String str = "Hallo Welt";
System.out.println( str );
In Adaptive Server Anywhere ist das Serverfenster die Standardausgabe, so
dass die Zeichenfolge dort erscheint. Die Ausführung des oben angegebenen
Java-Programmcodes in der Datenbank ist der folgenden SQL-Anweisung
gleichwertig:
MESSAGE ’Hallo Welt’
Hauptmethode (main) verwenden
Wenn eine Klasse eine main-Methode enthält, die zur folgenden Deklaration
passt, wird sie von den meisten Java-Laufzeitumgebungen, wie zum Beispiel
vom Sun Java-Interpreter, automatisch ausgeführt. Normalerweise wird diese
statische Methode nur ausgeführt, wenn sie die Klasse ist, die vom Java-
Interpreter aufgerufen wurde.
public static void main( String args[ ] ) { }
Die Hauptklasse ist eine nützliche Klasse für das Austesten der Funktionen
von Java-Objekten: Sie können immer sicher sein, dass diese Methode als
erste aufgerufen wird, wenn Sie das Sun Java Laufzeitsystem starten.
In Adaptive Server Anywhere ist das Java-Laufzeitsystem jederzeit
verfügbar. Die Funktionen der Objekte und Methoden können mit SQL-
Anweisungen unmittelbar und dynamisch getestet werden. In vielerlei
Hinsicht ist diese Methode für das Testen von Java-Klassen-Funktionen viel
flexibler.
79

Die Laufzeitumgebung für Java in der Datenbank
Bereich und Dauerhaftigkeit (Persistenz)
80
SQL-Variable sind nur so dauerhaft wie die Verbindung. Dies ist nicht
anders als bei früheren Versionen von Adaptive Server Anywhere und wird
auch nicht davon berührt, ob die Variable eine Java-Klasse oder ein nativer
SQL-Datentyp ist.
Die Dauerhaftigkeit (oder "Persistenz") von Java-Klassen entspricht der der
Tabellen in einer Datenbank: Tabellen existieren in einer Datenbank so
lange, bis sie gelöscht werden, gleichgültig ob sie Daten enthalten oder
niemals benutzt werden. Java-Klassen, die in einer Datenbank installiert
wurden, sind ähnlich: Man kann sie benutzen, bis sie explizit durch eine
REMOVE-Anweisung entfernt werden.
$ Weitere Hinweise zum Entfernen von Klassen finden Sie unter
"REMOVE-Anweisung" auf Seite 547 der Dokumentation ASA SQL-
Referenzhandbuch.
Eine Klassenmethode in einer installierten Java-Klasse kann jederzeit aus
einer SQL-Anweisung aufgerufen werden. Sie können die folgende
Anweisung überall ausführen, wo Sie SQL-Anweisungen ausführen können.
Select java.lang.Math.abs(-342)
Ein Java-Objekt ist nur in zwei Formen verfügbar: als Wert einer Variablen
oder als Wert in einer Tabelle.
Java-Escapezeichen in SQL-Anweisungen
Im Java-Programmcode können Sie Escapezeichen verwenden, um
bestimmte Sonderzeichen in Zeichenfolgen einzufügen. Ein Beispiel ist der
folgende Programmcode, der ein Zeichen für Neue Zeile und ein
Tabulatorzeichen vor einem Satz einführt, der ein Apostroph enthält.
String str = "\n\t\Eine Zeichenfolge ist\’s, die mir
fehlt";
Die Verwendung von Java-Escapezeichen ist im Adaptive Server Anywhere
nur erlaubt, wenn sie von Java-Klassen benutzt werden. Aus SQL müssen
hingegen die Regeln befolgt werden, die für Zeichenfolgen in SQL gelten:
Beispiel: Um einen Zeichenfolgenwert an ein Feld zu übergeben, das eine
SQL-Anweisung benutzt, kann folgende Anweisung benutzt werden, das
Java-Escapezeichen hingegen nicht.
set obj.str = ’\nDie Zeichenfolge ist’’s, die fehlte!’;
$ Weitere Hinweise über die Regeln für SQL-Zeichenfolgen finden Sie
unter "Zeichenfolgen" auf Seite 10 der Dokumentation ASA SQL-
Referenzhandbuch.

Schlüsselwortkonflikte
Import-Anweisungen verwenden
Die Klassen weiter
oben in der
Hierarchie müssen
ebenfalls installiert
sein.
Kapitel 3 Einführung in Java für Datenbanken
SQL-Schlüsselwörter können im Konflikt mit Namen von Java-Klassen,
einschließlich API-Klassen stehen. Dies tritt ein, wenn der Name einer
Klasse, wie z.B. der Klasse "Date", die ein Teil des Pakets java.util.* ist,
referenziert wird. SQL reserviert das Wort Date für den Einsatz als
Schlüsselwort, auch wenn es gleichzeitig der Name einer Java-Klasse ist.
Wenn solche Zweideutigkeiten auftreten, können Sie Anführungszeichen
verwenden, um anzuzeigen, dass Sie das betreffende Wort nicht mehr als für
SQL reserviertes Wort verwenden. Beispiel: Die folgende SQL-Anweisung
verursacht einen Fehler, da "Date" ein Schlüsselwort und seine Verwendung
für SQL reserviert ist.
-- Diese Anweisung ist unzulässig
CREATE VARIABLE dt java.util.Date
Die folgenden beiden Anweisungen funktionieren hingegen richtig, weil das
Wort "Date" in Anführungszeichen steht.
CREATE VARIABLE dt java.util."Date";
SET dt = NEW java.util."Date"(1997, 11, 22, 16, 11, 01)
Die Variable dt enthält jetzt das Datum: November 22, 1997, 4:11 p.m.
Es ist allgemein üblich, in einer Java-Klassen-Deklaration eine Import-
Anweisung für den Zugriff auf andere, externe Klassen einzubeziehen. Sie
können importierte Klassen mit unqualifizierten Klassennamen
referenzieren.
Beispiel: Sie können die Stack-Klasse des Pakets java.util auf zwei Arten
referenzieren:
♦ Explizit mit dem Namen java.util.Stack
♦ Oder mit dem Namen Stack, und Einschluss der folgenden Import-
Anweisung:
import java.util.*;
Eine von einer anderen Klasse explizit mit einem voll qualifizierten Namen
oder implizit mit einer Import-Anweisung referenzierte Klasse muss
ebenfalls in der Datenbank installiert sein.
81

Die Laufzeitumgebung für Java in der Datenbank
CLASSPATH-Variable verwenden
CLASSPATH
während der
Laufzeit ignoriert
CLASSPATH zur
Installation von
Klassen
82
Die Import-Anweisung funktioniert in kompilierten Klassen wie
beabsichtigt. In der Laufzeitumgebung von Adaptive Server Anywhere gibt
es allerdings keine der Import-Anweisung gleichwertige Anweisung. Alle
Klassennamen, die in SQL-Anweisungen oder in gespeicherten Prozeduren
verwendet werden, müssen voll qualifiziert sein. Beispiel: Um eine Variable
des Typs "Zeichenfolge" zu erstellen, wird diese Klasse mit dem voll
qualifizierten Namen referenziert: java.lang.String.
Die Java-Laufzeitumgebung von Sun und der Sun JDK Java Compiler
benutzen die classpath-Umgebungsvariable, um Klassen zu ermitteln, die im
Java-Programmcode angesprochen werden. Eine classpath-Variable stellt
eine Verbindung zwischen dem Java-Programmcode und dem tatsächlichen
Dateipfad oder dem URL der referenzierten Klassen her. Zum Beispiel
können mit import java.io.* alle Klassen im Paket java.io ohne voll
qualifizierten Namen referenziert werden. Nur der Klassenname ist im
folgenden Java-Code erforderlich, um Klassen aus dem Paket java.io zu
verwenden. Die Umgebungsvariable classpath auf dem System, in dem die
Java-Klassendeklaration kompiliert werden soll, muss den Standort des Java-
Verzeichnisses, also des Stammverzeichnisses des Pakets java.io, enthalten.
Die Umgebungsvariable classpath beeinträchtigt die Laufzeitumgebung von
Adaptive Server Anywhere für Java nicht während des Ausführens von Java-
Vorgängen, da die Klassen in der Datenbank, und nicht in externen Dateien
oder Archiven gespeichert sind.
Die Variable classpath kann jedoch verwendet werden, um den Standort
einer Datei während der Installation von Klassen zu ermitteln. Beispiel: Die
folgende Anweisung installiert eine benutzererstellte Java-Klasse in der
Datenbank, gibt aber nur den Namen der Datei an, nicht ihren vollen
Suchpfad plus Namen. (Beachten Sie, dass in dieser Anweisung keine Java-
Vorgänge enthalten sind.)
INSTALL JAVA NEW
FROM FILE ’Invoice.class’
Wenn die angegebene Datei in einem Verzeichnis oder in einer ZIP-Datei
liegt, die von der Umgebungsvariablen classpath definiert wurden, findet
Adaptive Server Anywhere die Datei und installiert die Klasse.

Öffentliche Felder
Kapitel 3 Einführung in Java für Datenbanken
Beim objektorientierten Programmieren ist es allgemein üblich,
Klassenfelder als "private" zu definieren und ihre Werte nur über öffentliche
Methoden verfügbar zu machen.
Viele Beispiele, die in dieser Dokumentation verwendet werden, geben
Felder als "public" an, sodass die Beispiele kompakter und leichter zu lesen
sind. Die Verwendung öffentlicher Felder in Adaptive Server Anywhere
bietet Performancevorteile gegenüber der Verwendung öffentlicher
Methoden.
Die in dieser Dokumentation allgemein eingehaltene Konvention besteht
darin, dass eine benutzererstellte Java-Klasse, die für den Einsatz in
Adaptive Server Anywhere gedacht ist, ihre Hauptwerte in ihren Feldern
auswirft. Methoden enthalten Berechnungsautomation und Logik, die mit
diesen Feldern arbeiten.
83

Praktische Einführung: Eine Übung mit Java in der Datenbank
Praktische Einführung: Eine Übung mit Java in
der Datenbank
Anforderungen
Ressourcen
84
Diese praktische Einführung soll die Grundlagen für den Aufruf von Java-
Vorgängen mit Java-Klassen und Objekten über SQL-Anweisungen
vermitteln. Es wird beschrieben, wie Java-Klassen in der Datenbank
installiert werden. Darüber hinaus wird beschrieben, wie auf die Klasse und
ihre Mitglieder und Methoden von SQL-Anweisungen aus zugegriffen wird.
In der praktischen Einführung wird die in "Ein Java-Seminar" auf Seite 64
erstellte Klasse verwendet.
Die praktische Einführung geht davon aus, dass Java in der Datenbank-
Software installiert wurde. Außerdem wird vorausgesetzt, dass Sie ein Java
Development Kit (JDK) installiert haben, einschließlich dem Java Compiler
(javac).
Quellcode und Anweisungsfolgen für dieses Beispiel finden Sie im
Verzeichnis Samples\ASA\JavaInvoice in Ihrem SQL Anywhere-
Verzeichnis.
Beispiel-Java-Klasse erstellen und kompilieren
Der erste Schritt besteht darin, den Java-Code zu schreiben und zu
kompilieren. Dies geschieht außerhalb der Datenbank.
v So wird die Klasse erstellt und kompiliert:
1 Erstellen Sie eine Datei mit dem Namen Invoice.java mit dem folgenden
Code:

public class Invoice {
}
Kapitel 3 Einführung in Java für Datenbanken
// Felder
public String lineItem1Description;
public double lineItem1Cost;
public String lineItem2Description;
public double lineItem2Cost;
// Eine Instanzmethode
public double totalSum() {
double runningsum;
double taxfactor = 1 + Invoice.rateOfTaxation();
}
runningsum = lineItem1Cost + lineItem2Cost;
runningsum = runningsum * taxfactor;
return runningsum;
// Eine Klassenmethode
public static double rateOfTaxation() {
double rate;
rate = .15;
}
return rate;
Beispiel-Java-Klasse installieren
Den Quellcode für diese Klasse finden Sie in der Datei
Samples\ASA\JavaInvoice\Invoice.java in Ihrem SQL Anywhere-
Verzeichnis.
2 Kompilieren Sie die Datei, damit die Datei Invoice.class erstellt wird.
Führen Sie von der Befehlszeile im selben Verzeichnis wie Invoice.java
den folgenden Befehl aus.
javac *.java
Die Klasse ist jetzt kompiliert und kann in der Datenbank installiert
werden.
Java-Klassen können erst verwendet werden, nachdem sie in einer
Datenbank installiert wurden. Sie können Java-Klassen aus Sybase Central
oder Interactive SQL installieren. Dieser Abschnitt enthält Anweisungen für
beide Möglichkeiten. Wählen Sie selbst.
85

Praktische Einführung: Eine Übung mit Java in der Datenbank
Hinweise
86
v So installieren Sie die Klasse in der Beispieldatenbank
(Sybase Central):
1 Starten Sie Sybase Central und stellen Sie eine Verbindung zur
Beispieldatenbank her.
2 Öffnen Sie den Ordner "Java-Objekte" und doppelklicken Sie auf "Java-
Klasse hinzufügen". Der Assistent für die Erstellung von Java-Klassen
wird angezeigt.
3 Klicken Sie auf die Schaltfläche "Durchsuchen" und wechseln Sie zur
Klasse Invoice.class im Unterverzeichnis Samples\ASA\JavaInvoice in
Ihrem Installationsverzeichnis von SQL Anywhere.
4 Klicken Sie auf "Fertig stellen", damit der Assistent geschlossen wird.
v So installieren Sie die Klasse in der Beispieldatenbank
(Interactive SQL):
1 Starten Sie Interactive SQL und stellen Sie eine Verbindung mit der
Beispieldatenbank her.
2 Geben Sie im Fensterausschnitt "SQL-Anweisungen" in Interactive SQL
den folgenden Befehl ein.
INSTALL JAVA NEW
FROM FILE
’Suchpfad\\samples\\ASA\\JavaInvoice\\Invoice.class’
wobei Suchpfad Ihr SQL Anywhere-Verzeichnis ist.
Die Klasse ist jetzt in der Beispieldatenbank installiert.
♦ Bis jetzt haben in der Datenbank keine Java-Vorgänge stattgefunden.
Die Klasse wurde in der Datenbank installiert. Sie kann nun als
Datentyp einer Variablen oder Spalte in einer Tabelle verwendet
werden.
♦ In einer Klassendatei durchgeführte Änderungen werden nicht
automatisch auch in die Kopie der Klasse in der Datenbank übertragen.
Sie müssen die Klassen neu installieren, wenn die Änderungen
wiedergegeben werden sollen.
$ Weitere Hinweise zur Installation der Klassen und zur Aktualisierung
einer installierten Klasse finden Sie unter "Java-Klassen in einer Datenbank
installieren" auf Seite 103.

SQL-Variable vom Typ "Invoice" erstellen
Kapitel 3 Einführung in Java für Datenbanken
In diesem Abschnitt wird eine SQL-Variable erstellt, die sich auf ein Java-
Objekt vom Typ Invoice bezieht.
Berücksichtigung von Groß-/Kleinschreibung
Java berücksichtigt die Groß/Kleinschreibung, sodass die Teile der
nachstehenden Beispiele, die Java-Syntax beinhalten, genauso
geschrieben werden müssen wie gezeigt. Die SQL-Syntax wird mit
Großbuchstaben geschrieben.
1 Führen Sie von Interactive SQL aus die folgende Anweisung aus und
erstellen Sie eine SQL-Variable mit dem Namen Inv vom Typ Invoice,
wobei Invoice die Java-Klasse ist, die Sie in der Datenbank installiert
haben:
CREATE VARIABLE Inv Invoice
Nach dem Erstellen einer Variablen kann ihr erst dann ein Wert
zugewiesen werden, wenn Datentyp und deklarierter Datentyp identisch
sind oder wenn der Wert eine Unterklasse des deklarierten Datentyps ist.
Im vorliegenden Fall kann die Variable Inv nur eine Referenz auf ein
Objekt des Typs Invoice oder eine Unterklasse von Invoice enthalten.
Anfangs ist die Variable Inv gleich NULL, weil kein Wert an sie
weitergeleitet wurde.
2 Führen Sie die folgende Anweisung aus, damit der aktuelle Wert der
Variablen Inv identifiziert wird.
select IfNull(Inv,
’Kein Objekt referenziert’,
'Variable ist nicht null: enthält eine
Objektreferenz')
Die Variable referenziert derzeit kein Objekt.
3 Weisen Sie Inv einen Wert zu.
Sie müssen die Klasse Invoice mit dem Schlüsselwort NEW
instanzieren.
SET Inv = NEW Invoice();
Die Variable Inv hat jetzt eine Referenz auf das Java-Objekt. Zur
Überprüfung können Sie die Anweisung aus Schritt 2 ausführen.
Die Variable Inv enthält eine Referenz auf ein Java-Objekt vom Typ
Invoice. Mit dieser Referenz können Sie auf viele Felder des Objekts
zugreifen oder eine ihrer Methoden aufrufen.
87

Praktische Einführung: Eine Übung mit Java in der Datenbank
Auf Felder und Methoden des Java-Objekts zugreifen
88
Wenn eine Variable (oder ein Spaltenwert in einer Tabelle) eine Referenz auf
ein Java-Objekt enthält, können den Feldern des Objekts Werte übergeben
werden, und ihre Methoden sind aufrufbar.
Beispiel: Eine Variable vom Typ "Invoice", die Sie im vorigen Abschnitt
erstellt haben, enthält eine Referenz auf ein Objekt Invoice und hat vier
Felder, deren Werte durch SQL-Anweisungen festgelegt werden können.
v So greifen Sie auf die Felder des Objekts "Invoice" zu:
1 Führen Sie von Interactive SQL die folgenden SQL-Anweisungen aus,
damit die Feldwerte für die Variable Inv gesetzt werden.
SET Inv.lineItem1Description = ’Gummistiefel’;
SET Inv.lineItem1Cost = ’79.99’;
SET Inv.lineItem2Description = ’Heugabel’;
SET Inv.lineItem2Cost = ’37.49’;
Jede der oben stehenden SQL-Anweisungen gibt einen Wert an ein Feld
im Java-Objekt weiter, das durch Inv referenziert wird.
2 Führen Sie SELECT-Anweisungen mit der Variablen aus. Jede
nachstehende SQL-Anweisung gibt den aktuellen Wert eines Feldes im
Java-Objekt zurück, das von Inv referenziert wird.
SELECT Inv.lineItem1Description;
SELECT Inv.lineItem1Cost;
SELECT Inv.lineItem2Description;
SELECT Inv.lineItem2Cost;
3 Verwenden Sie ein Feld der Variablen Inv in einem SQL-Ausdruck.
Führen Sie die folgende SQL-Anweisung aus und lassen Sie die obigen
SQL-Anweisungen ausführen.
SELECT * FROM PRODUCT
WHERE unit_price < Inv.lineItem2Cost;
Zusätzlich zu den öffentlichen Feldern hat die Klasse Invoice eine
Instanzmethode, die Sie aufrufen können.
v So rufen Sie die Methoden des Objekts "Invoice" auf:
♦ Führen Sie von Interactive SQL aus die folgende SQL-Anweisung aus,
die die Methode totalSum() des Objekts aufruft, das von der Variablen
Inv referenziert wird. Sie gibt die Summe der beiden Kostenfelder plus
der Steuer zurück.

Methoden aufrufen
und Felder
referenzieren
SELECT Inv.totalSum();
Kapitel 3 Einführung in Java für Datenbanken
Hinter Methodennamen stehen immer Klammern, auch wenn sie keine
Argumente annehmen. Nach Feldnamen stehen keine Klammern.
Die Methode totalSum() akzeptiert keine Argumente, sondern gibt einen
Wert zurück. Die Klammern werden verwendet, da eine Java-Operation
aufgerufen wird, obwohl die Methode keine Argumente annimmt.
Bei Java in der Datenbank ist der direkte Feldzugriff schneller als der Aufruf
von Methoden. Für den Zugriff auf ein Feld ist der Aufruf der Java VM nicht
erforderlich, während für eine Methode die VM benötigt wird, um die
Methode auszuführen.
Wie in der am Anfang dieses Kapitels beschriebenen Invoice-
Klassendefinition gezeigt, nutzt die totalSum-Instanzenmethode die
Klassenmethode rateOfTaxation.
Auf diese Klassenmethode kann direkt aus einer SQL-Anweisung
zugegriffen werden.
SELECT Invoice.rateOfTaxation();
Beachten Sie, dass der Name der Klasse verwendet wird, und nicht der Name
einer Variablen, die eine Referenz auf ein Invoice-Objekt enthält. Dies
stimmt mit der Art überein, wie Java Klassenmethoden verarbeitet, auch
wenn sie in SQL-Anweisungen verwendet werden. Eine Klassenmethode
kann aufgerufen werden, auch wenn kein auf dieser Klasse basierendes
Objekt instanziert wurde.
Klassenmethoden benötigen keine Instanz der Klasse, um richtig zu
funktionieren, können aber immer noch für ein Objekt aufgerufen werden.
Die folgende SQL-Anweisung bringt dieselben Ergebnisse wie die vorher
ausgeführte SQL-Anweisung.
SELECT Inv.rateOfTaxation();
Java-Objekte in Tabellen speichern
Wenn eine Klasse in einer Datenbank installiert wird, steht sie als neuer
Datentyp zur Verfügung. Spalten in einer Tabelle können den Typ Javaclass
haben, wobei Javaclass der Name einer installierten öffentlichen Java-Klasse
ist. Dann können Sie ein Java-Objekt erstellen und es als Wert einer Spalte in
eine Tabelle einfügen.
v So wird die Klasse "Invoice" in einer Tabelle verwendet:
1 Tabelle mit einer Spalte vom Typ Invoice erstellen.
Führen Sie von Interactive SQL die folgende SQL-Anweisung aus.
89

Praktische Einführung: Eine Übung mit Java in der Datenbank
90
CREATE TABLE T1 (
ID int,
JCol Invoice
);
Die Spalte namens JCol akzeptiert nur Objekte des Typs Invoice oder
einer ihrer Unterklassen.
2 Führen Sie mit der Variablen Inv, die eine Referenz auf ein Java-Objekt
vom Typ Invoice enthält, die folgende SQL-Anweisung aus, damit der
Tabelle T1 eine Zeile hinzugefügt wird.
INSERT INTO T1
VALUES( 1, Inv );
Sobald ein Objekt der Tabelle T1 hinzugefügt wurde, können Sie
Auswahlanweisungen benutzen, die die Felder und Methoden der
Objekte in der Tabelle einbeziehen.
3 Führen Sie die folgende SQL-Anweisung aus, die den Wert des Feldes
ineItem1Description für alle Objekte in der Tabelle T1 zurück (derzeit
sollte nur ein Objekt in der Tabelle sein).
SELECT ID, JCol.lineItem1Description
FROM T1;
Sie können ähnliche Auswahlanweisungen ausführen, die andere Felder
und Methoden des Objekts einbeziehen.
4 Eine zweite Methode, ein Java-Objekt zu erstellen und einer Tabelle
hinzuzufügen, bezieht den folgenden Ausdruck ein, der immer ein Java-
Objekt erstellt und ihm eine Referenz zurückgibt.
NEW Java-Klassenname()
5 Dieser Ausdruck kann auf verschiedene Arten benutzt werden.
Beispielsweise wird mit der folgenden SQL-Anweisung ein Java-Objekt
erstellt und in die Tabelle T1 eingefügt.
INSERT INTO T1
VALUES ( 2, NEW Invoice() );
6 Führen Sie die folgende SQL-Anweisung aus, damit geprüft wird, ob
diese beiden Objekte als Werte der Spalte JCol in der Tabelle T1
gespeichert wurden.
select id, JCol.totalSum()
FROM t1
Die Ergebnisse der Spalte JCol (zweite von der oben genannten
Anweisung zurückgegebene Zeile) sollte 0 sein, da die Felder in diesem
Objekt keine Werte haben und die Methode totalSum eine Berechnung
dieser Felder ist.

Objekt mit einer Abfrage zurückgeben
Kapitel 3 Einführung in Java für Datenbanken
Außer auf Felder und Methoden zuzugreifen, können Sie mit einer Abfrage
auch ein ganzes Objekt aus der Tabelle abrufen.
v So greifen Sie auf Invoice-Objekte zu, die in einer Tabelle
gespeichert sind:
♦ Führen Sie von Interactive SQL aus die folgenden Anweisungen aus,
erstellen Sie eine neue Variable und übergeben Sie ihr einen Wert (Sie
kann nur eine Referenz auf ein Objekt vom Typ "Invoice" enthalten).
Die an die Variable übergebene Objektreferenz wurde mit der Tabelle
T1 erstellt.
CREATE VARIABLE Inv2 Invoice;
set Inv2 = (select JCol from T1 where ID = 2);
SET Inv2.lineItem1Description = 'Süßigkeiten';
SET Inv2.lineItem2Description = 'Sicherheitsgurt';
Der Wert für das Feld lineItem1Description und lineItem2Description
wurde in der Variablen Inv2 geändert, jedoch nicht in der Tabelle, die
die Quelle für den Wert dieser Variablen war.
Dies ist konsistent mit der Art, in der SQL-Variable derzeit verarbeitet
werden: Die Variable Inv enthält eine Referenz auf ein Java-Objekt. Der
Wert in der Tabelle, die als Quelle für die Variablenreferenz diente, wird
erst geändert, wenn eine UPDATE-Anweisung ausgeführt wird.
91

Praktische Einführung: Eine Übung mit Java in der Datenbank
92

KAPITEL 4
Java in der Datenbank benutzen
Über dieses
Kapitel
Inhalt
Bevor Sie
beginnen
In diesem Kapitel wird beschrieben, wie Sie Java-Klassen und Objekte Ihrer
Datenbank hinzufügen und wie Sie diese Objekte in einer relationalen
Datenbank einsetzen.
Thema Seite
Einleitung 94
Datenbank für Java aktivieren 97
Java-Klassen in einer Datenbank installieren 103
Spalten für die Aufnahme von Java-Objekten erstellen 109
Java-Objekte einfügen, aktualisieren und löschen 111
Java-Objekte abfragen 117
Java-Felder und Objekte vergleichen 119
Besondere Funktionen von Java-Klassen in der Datenbank 123
So werden Java-Objekte gespeichert 130
Java-Datenbankdesign 133
Berechnete Spalten mit Java-Klassen verwenden 137
Speicher für Java konfigurieren 140
Vor den Beispielen in diesem Kapitel müssen Sie die Datei
Samples\ASA\Java\jdemo.sql in Ihrem SQL Anywhere-Verzeichnis
ausführen.
$ Weitere Hinweise und vollständige Anweisungen finden Sie unter
"Java-Beispiele einrichten" auf Seite 94.
93

Einleitung
Einleitung
Java-Beispiele einrichten
94
Dieses Kapitel erläutert, wie Sie Aufgaben mit Java in der Datenbank
ausführen:
♦ Datenbank für Java aktivieren Sie müssen bestimmte Maßnahmen
treffen, damit Ihre Datenbank für die Arbeit mit Java aktiviert wird.
♦ Java-Klassen installieren Sie müssen Java-Klassen in einer Datenbank
installieren, damit sie für Aufgaben auf dem Server zur Verfügung
stehen.
♦ Eigenschaften der Java-Spalten Dieser Abschnitt erläutert, wie
Spalten mit Java-Klassen-Datentypen in das relationale
Datenbankmodell passen.
♦ Datenbankdesign für Java In diesem Abschnitt werden Tipps für das
Design von Datenbanken gegeben, die Java-Klassen benutzen.
Viele Beispiele in diesem Kapitel werden mit einer Gruppe von Klassen und
Tabellen ausgeführt, die der Beispieldatenbank hinzugefügt wurden. Die
Tabellen enthalten dieselben Daten wie Tabellen desselben Namens in der
Beispieldatenbank, nur gehören sie einem Benutzer namens jdba. Sie
benutzen Java-Klassen-Datentypen anstelle von einfachen relationalen
Typen für die Daten. Das Beispiel finden Sie im Unterverzeichnis
Samples\ASA\Java Ihres SQL Anywhere-Verzeichnisses.
Beispieltabellen sind nur für die praktische Einführung gedacht
Die Beispieltabellen sollen unterschiedliche Java-Funktionen darstellen.
Sie sind keinesfalls als Muster für das Design Ihrer Datenbank zu
empfehlen. Überlegen Sie sich die konkreten Anforderungen in Ihrem
Datenbanksystem, wenn Sie ermitteln wollen, an welchen Stellen Java-
Datentypen und andere Java-Merkmale in die Datenbank eingebaut
werden sollen.
Die Java-Beispiele werden in zwei Schritten eingerichtet:
1 Aktivieren Sie die Beispieldatenbank für Java.
2 Fügen Sie die Java-Beispielklassen und –tabellen hinzu.

Kapitel 4 Java in der Datenbank benutzen
v So wird die Beispieldatenbank für Java aktiviert:
1 Starten Sie Interactive SQL und stellen Sie eine Verbindung mit der
Beispieldatenbank her.
2 Geben Sie im Fensterausschnitt "SQL-Anweisungen" in Interactive SQL
die folgende Anweisung ein.
ALTER DATABASE UPGRADE JAVA JDK ’1.3’
3 Schließen Sie Interactive SQL und die Beispieldatenbank.
Die Beispieldatenbank asademo.db muss zunächst heruntergefahren
werden, damit Sie die Java-Funktionen benutzen können.
v So fügen Sie Java-Klassen und Tabellen der Beispieldatenbank
hinzu:
1 Starten Sie Interactive SQL und stellen Sie eine Verbindung mit der
Beispieldatenbank her.
2 Geben Sie im Fensterausschnitt "SQL-Anweisungen" in Interactive SQL
die folgende Anweisung ein:
READ "Suchpfad\\Samples\\ASA\\Java\\jdemo.sql"
wobei Suchpfad Ihr SQL Anywhere-Verzeichnis ist. Damit werden die
Instruktionen in der Befehlsdatei jdemo.sql ausgeführt. Die
Instruktionen benötigen eventuell einige Zeit, bis sie abgeschlossen sind.
Sie können das Skript Samples\ASA\Java\jdemo.sql mit einem Texteditor
öffnen. Es führt folgende Programmschritte aus:
1 Es installiert die Klasse JDBCExamples.
2 Es erstellt einen Benutzer namens JDBA mit dem Kennwort SQL und
DBA-Berechtigung, und setzt den aktuellen Benutzer als JDBA ein.
3 Es installiert eine JAR-Datei namens asademo.jar. Diese Datei enthält
die Klassendefinitionen, die in den Tabellen verwendet werden.
4 Es erstellt die folgenden Tabellen unter der Benutzer-ID JDBA:
♦ product
♦ contact
♦ customer
♦ employee
♦ sales_order
♦ sales_order_items
95

Einleitung
96
Dies ist eine Teilmenge der Tabellen in der Beispieldatenbank.
5 Es fügt die Daten aus den Standardtabellen mit identischen Namen in
die Java-Tabellen ein. Dieser Verfahrensschritt benutzt INSERT- und
SELECT-Anweisungen. Dieser Schritt kann einige Zeit in Anspruch
nehmen.
6 Es erstellt einige Indizes und Fremdschlüssel, um dem Schema
Integritätsregeln hinzuzufügen.
Laufzeitumgebung für Java verwalten
Aufgaben bei der
Verwaltung von
Java
Tools zum
Verwalten von
Java
Die Laufzeitumgebung für Java besteht aus folgenden Komponenten:
♦ Sybase Java Virtual Machine Die VM läuft im Datenbankserver,
interpretiert kompilierte Java-Klassen und führt sie aus.
♦ Integrierte Java-Klassen Wenn Sie eine Datenbank erstellen, wird eine
Serie von Java-Klassen für die Datenbank verfügbar. Für Java-
Anwendungen in der Datenbank müssen diese Klassen fehlerfrei
funktionieren.
Um eine Laufzeitumgebung für Java bereitzustellen, müssen Sie folgende
Aufgaben durchführen:
♦ Datenbank für Java aktivieren Bei dieser Aufgabe müssen Sie die
Verfügbarkeit von integrierten Klassen und das Upgrade auf Standards
der Version 8 prüfen.
$ Weitere Hinweise finden Sie unter "Datenbank für Java aktivieren"
auf Seite 97.
♦ Installieren Sie andere Klassen, die die Benutzer brauchen Im
Verlauf dieser Aufgabe sorgen Sie dafür, dass andere Klassen als die
Laufzeitklassen installiert werden und auf dem letzten Stand sind.
$ Weitere Hinweise finden Sie unter "Java-Klassen in einer
Datenbank installieren" auf Seite 103.
♦ Konfiguration des Servers Sie müssen Ihren Server so konfigurieren,
dass der erforderliche Speicher für das Ausführen von Java-Aufgaben
vorhanden ist.
$ Weitere Hinweise finden Sie unter "Speicher für Java
konfigurieren" auf Seite 140.
Sie können alle diese Aufgaben aus Sybase Central oder Interactive SQL
ausführen.

Datenbank für Java aktivieren
Java-Aktivierung
der Datenbank
manchmal nicht
erforderlich
Kapitel 4 Java in der Datenbank benutzen
Die Adaptive Server Anywhere Laufzeitumgebung für Java benötigt eine
Java VM und die Java-Laufzeitklassen von Sybase. Erst nachdem Sie eine
Datenbank für Java aktiviert haben, können Sie sie mit Java-Laufzeitklassen
benutzen.
Java in der Datenbank ist eine separat lizenzierte Komponente von
SQL Anywhere Studio.
Neue Datenbanken sind standardmäßig nicht für Java aktiviert
Standardmäßig ist eine Datenbank nicht für Java aktiviert, wenn Sie sie in
Adaptive Server Anywhere neu erstellen.
Java ist eine Programmiersprache mit einer Einzelhierarchie. Das bedeutet,
dass alle Klassen, die Sie erstellen oder benutzen, von einer Klasse erben.
Das bedeutet weiterhin, dass die Klassen der niedrigsten Ebene (also in der
Hierarchie weiter oben angesiedelt) vorhanden sein müssen, bevor Klassen
der oberen Ebene benutzt werden können. Die Basisgruppe der
erforderlichen Klassen für Java-Anwendungen wird als Laufzeit-Java-
Klassen oder Java-API bezeichnet.
Durch das Bereitstellen einer Datenbank für Java werden in die
Systemtabellen zahlreiche Einträge eingefügt. Dies vergrößert die Datenbank
und erfordert rund 200 KByte mehr Speicher zum Ausführen der Datenbank,
auch wenn Sie keine Java-Funktionen verwenden.
Wenn Sie Java nicht verwenden werden und eine Umgebung mit begrenzter
Speicherkapazität haben, sollten Sie die Datenbank nicht für Java aktivieren.
Die Java-Laufzeitklassen für Sybase
Die Java-Laufzeitklassen für Sybase befinden sich auf der Festplatte, und
nicht in der Datenbank wie andere Klassen. Die folgenden Dateien enthalten
die Java-Laufzeitklassen für Sybase. Sie werden im Unterverzeichnis Java
Ihres SQL Anywhere-Verzeichnisses gespeichert.
♦ 1.1\classes.zip Diese Datei, lizenziert von Sun Microsystems, enthält
einen Teil der Java-Laufzeitklassen für JDK 1.1.8 von Sun
Microsystems.
♦ 1.3\rt.jar Diese Datei, lizenziert von Sun Microsystems, enthält einen
Teil der Java-Laufzeitklassen für JDK 1.3 von Sun Microsystems.
97

Datenbank für Java aktivieren
JAR-Dateien
Installierte Pakete
98
♦ asajdbc.zip Diese Datei enthält interne JDBC-Treiber-Klassen von
Sybase für JDK 1.1.
♦ asajrt12.zip Diese Datei enthält interne JDBC-Treiber-Klassen von
Sybase für JDK 1.2 und JDK 1.3.
Wenn Sie eine Datenbank für Java aktivieren, werden die Systemtabellen mit
einer Liste verfügbarer Klassen aus den System-JAR-Dateien aktualisiert.
Sie können dann die Klassenhierarchie aus Sybase Central durchsuchen, die
Klassen selbst aber sind in der Datenbank nicht vorhanden.
Die Datenbank speichert Laufzeit-Klassennamen unter folgenden JAR-
Dateien:
♦ ASAJRT Klassennamen aus asajdbc.zip werden hier gespeichert.
♦ ASAJDBCDRV Klassennamen aus jdbcdrv.zip werden hier gespeichert.
♦ ASASystem Klassennamen aus classes.zip werden hier gespeichert.
Diese Laufzeitklassen enthalten die folgenden Pakete:
♦ java Die hier gespeicherten Pakete sind die unterstützten Java-
Laufzeitklassen von Sun Microsystems.
$ Eine Liste der unterstützten Java-Laufzeitklassen finden Sie unter
"Unterstützte Java-Pakete" auf Seite 87 der Dokumentation ASA SQL-
Referenzhandbuch.
♦ com.sybase Die hier gespeicherten Pakete bieten serverseitige JDBC-
Unterstützung.
♦ sun Sun Microsystems bietet die hier gespeicherten Pakete an.
♦ sybase.sql Die hier gespeicherten Pakete sind Teil der serverseitigen
JDBC-Unterstützung von Sybase.
Vorsicht: Installieren Sie keine Klassen von einer anderen
Version des Sun JDK
Klassen im Sun JDK haben identische Namen wie die Java-
Laufzeitklassen für Sybase, die in jeder Datenbank installiert werden
müssen, in denen Java-Vorgänge ausgeführt werden sollen.
Sie dürfen die Datei classes.zip, die mit Adaptive Server Anywhere
mitgeliefert wird, nicht ersetzen. Wenn Sie eine andere Version dieser
Klassen verwenden, könnten sich daraus Kompatibilitätsprobleme mit der
Sybase Java Virtual Machine ergeben.
Eine Aktivierung einer Datenbank für Java dürfen Sie nur so vornehmen,
wie dies in diesem Abschnitt beschrieben wird.

Methoden zur Java-Aktivierung einer Datenbank
Datenbanken
erstellen
Upgrade einer
Datenbank
Kapitel 4 Java in der Datenbank benutzen
Sie können Datenbanken bei der Erstellung, beim Upgrade oder zu einem
späteren Zeitpunkt in einem separaten Vorgang für Java aktivieren.
Sie können eine für Java aktivierte Datenbank wie folgt erstellen:
♦ Benutzen Sie die Anweisung CREATE DATABASE.
$ Hinweise zur Syntax finden Sie unter "CREATE DATABASE-
Anweisung" auf Seite 298 der Dokumentation ASA SQL-
Referenzhandbuch.
♦ Benutzen Sie das Dienstprogramm dbinit.
$ Hinweise finden Sie unter "Datenbank mit dem
Befehlszeilenprogramm ""dbinit"" erstellen" auf Seite 516 der
Dokumentation ASA Datenbankadministration.
♦ Sybase Central
$ Hinweise finden Sie unter "Datenbank erstellen" auf Seite 31 der
Dokumentation ASA SQL-Benutzerhandbuch.
Ein Upgrade einer Datenbank auf eine für Java aktivierte Datenbank der
Version 8 können Sie wie folgt durchführen:
♦ Benutzen Sie die Anweisung ALTER DATABASE.
$ Hinweise zur Syntax finden Sie unter "ALTER DATABASE-
Anweisung" auf Seite 224 der Dokumentation ASA SQL-
Referenzhandbuch.
♦ Benutzen Sie das Upgrade-Dienstprogramm dbupgrad.exe.
$ Hinweise finden Sie unter "Upgrade einer Datenbank mit dem
Befehlszeilenprogramm ""dbupgrad""" auf Seite 583 der Dokumentation
ASA Datenbankadministration.
♦ Sybase Central.
$ Weitere Hinweise finden Sie unter "Datenbank für Java aktivieren"
auf Seite 101.
Wenn Sie Java in der Datenbank nicht installieren, bleiben alle
Datenbankvorgänge, die keine Java-Vorgänge einschließen, voll
funktionsfähig und laufen wie vorgesehen ab.
99

Datenbank für Java aktivieren
Neue Datenbanken und Java
CREATE
DATABASE-
Optionen
Dienstprogramm
für die
Initialisierung der
Datenbank
100
Die Java-Laufzeitklassen für Sybase werden bei Adaptive Server Anywhere
standardmäßig nicht jedesmal installiert, wenn Sie eine Datenbank erstellen.
Die Installation dieser separat zu lizenzierenden Komponente ist fakultativ
und wird über die Methode gesteuert, mit der Sie die Datenbank erstellen.
Die SQL-Anweisung CREATE DATABASE hat eine Option namens JAVA.
Wenn Sie die Datenbank für Java aktivieren wollen, setzen Sie diese Option
auf ON. Wenn Sie Java deaktivieren wollen, setzen Sie die Option auf OFF.
Standardmäßig ist die Option auf OFF gesetzt.
Beispielsweise erstellt die folgende Anweisung eine Datei für eine Javaaktivierte
Datenbank namens temp.db:
CREATE DATABASE ’c:\\sybase\\asa8\\temp’ JAVA ON
Die folgende Anweisung erstellt eine Datenbankdatei temp2.db, die Java
nicht unterstützt:
CREATE DATABASE ’c:\\sybase\\asa8\\temp2’
Datenbanken können mit dem Dienstprogramm dbinit.exe erstellt werden.
Das Dienstprogramm verfügt über Parameter, mit denen gesteuert wird, ob
die Java-Laufzeitklassen in der neu installierten Datenbank installiert
werden. Standardmäßig werden diese Klassen nicht installiert.
Die gleichen Optionen sind verfügbar, wenn Sie eine Datenbank mit Sybase
Central erstellen.
Upgrade von Datenbanken und Java
Dienstprogramm
für das Datenbank-
Upgrade
Für vorhandene Datenbanken, die mit früheren Versionen der Software
erstellt wurden, kann ein Upgrade durchgeführt werden, und zwar mit dem
Dienstprogramm für den Datenbank-Upgrade oder mit der Anweisung
ALTER DATABASE.
Das Upgrade für Datenbanken auf den Standard von Adaptive Server
Anywhere Version 8 erfolgt mit dem Dienstprogramm dbupgrad.exe. Der
Parameter –jr verhindert die Installation der Java-Laufzeitklassen von
Sybase.
$ Hinweise über die Bedingungen für das Einbeziehen von Java in die
Upgrade-Datenbank finden Sie unter "Upgrade einer Datenbank mit dem
Befehlszeilenprogramm ""dbupgrad""" auf Seite 583 der Dokumentation
ASA Datenbankadministration.

Datenbank für Java aktivieren
Kapitel 4 Java in der Datenbank benutzen
Wenn Sie eine Datenbank erstellt oder ein Upgrade einer Datenbank
durchgeführt, dabei aber die Option so gesetzt haben, dass die Datenbank
nicht für Java aktiviert wurde, können Sie die erforderlichen Java-Klassen
über Sybase Central oder Interactive SQL auch zu einem späteren Zeitpunkt
hinzufügen.
v Um der Datenbank die Java-Laufzeitklassen für Sybase
hinzuzufügen, gehen Sie wie folgt vor (Sybase Central):
1 Stellen Sie von Sybase Central aus als Benutzer mit DBA-Berechtigung
eine Verbindung her.
2 Rechtsklicken Sie auf die Datenbank und wählen Sie "Upgrade einer
Datenbank".
3 Klicken Sie auf der einführenden Seite des Assistenten auf "Weiter".
4 Wählen Sie die Datenbank, für die das Upgrade vorgenommen werden
soll, aus der Liste aus.
5 Sie können gegebenenfalls eine Sicherungskopie der Datenbank anlegen
lassen. Klicken Sie auf "Weiter".
6 Falls erwünscht, kann jConnect-Metadaten-Unterstützung installiert
werden. Klicken Sie auf "Weiter"
7 Wählen Sie die Option "Java-Unterstützung installieren". Sie müssen
außerdem die Version des JDK festlegen, die installiert werden soll. Die
Standardklassen sind JDK 1.3-Klassen. Für Version 7.x-Datenbanken
sind die Standardklassen JDK 1.1.8-Klassen.
8 Befolgen Sie die restlichen Anweisungen im Assistenten.
v Um die Java-Laufzeitklassen für Sybase der Datenbank
hinzuzufügen, gehen Sie wie folgt vor (Interactive SQL):
1 Verbinden Sie sich mit der Datenbank aus Interactive SQL als Benutzer
mit DBA-Berechtigung.
2 Führen Sie folgende Anweisung aus:
ALTER DATABASE UPGRADE JAVA ON
$ Weitere Hinweise finden Sie unter "ALTER DATABASE-
Anweisung" auf Seite 224 der Dokumentation ASA SQL-
Referenzhandbuch.
3 Starten Sie die Datenbank neu, damit die Java-Unterstützung wirksam
wird.
101

Datenbank für Java aktivieren
Mit Sybase Central eine Datenbank für Java aktivieren
102
Sie können Sybase Central für die Erstellung von Datenbanken über
Assistenten benutzen. Während der Erstellung oder des Upgrades einer
Datenbank fordert der Assistent Sie auf, auszuwählen, ob die Java-
Laufzeitklassen für Sybase installiert werden. Standardmäßig ist diese
Option so gesetzt, dass die Datenbank für Java aktiviert wird.
Die Erstellung oder das Upgrade einer Datenbank werden in Sybase Central
wie folgt vorgenommen:
♦ Wählen Sie "Datenbank erstellen" aus dem Ordner "Dienstprogramme".
♦ Wählen Sie "Upgrade einer Datenbank" aus dem Ordner
"Dienstprogramme", wenn Sie eine Datenbank von einer früheren
Version der Software auf eine Datenbank mit Java-Funktionen umstellen
wollen.

Kapitel 4 Java in der Datenbank benutzen
Java-Klassen in einer Datenbank installieren
Klasse erstellen
Bevor Sie eine Java-Klasse in einer Datenbank installieren, müssen Sie sie
kompilieren. Sie haben mehrere Methoden zur Auswahl, um Java-Klassen zu
installieren:
♦ Einzelne Klasse Sie können eine einzelne Klasse in einer Datenbank
aus einer kompilierten Klassendatei installieren. Klassendateien haben
normalerweise die Erweiterung .class.
♦ JAR-Datei Sie können eine Serie von Klassen auf einmal installieren,
wenn sie in einer komprimierten oder unkomprimierten JAR-Datei
zusammengefasst sind. JAR-Dateien haben normalerweise die
Erweiterung .jar oder .zip. Adaptive Server Anywhere unterstützt alle
komprimierten JAR-Dateien, die mit dem SUN-JAR-Dienstprogramm,
sowie anderen JAR-Kompressionsschemata, erstellt werden.
Dieser Abschnitt beschreibt, wie Java-Klassen installiert werden, nachdem
Sie sie kompiliert haben. Sie müssen über die DBA-Berechtigung verfügen,
um eine Klasse oder eine JAR-Datei zu installieren.
Die Details der einzelnen Schritte können zwar unterschiedlich sein, wenn
ein Java-Entwicklungstool wie Sybase PowerJ verwendet wird, grundsätzlich
sind aber für die Erstellung eigener Klassen die nachfolgend beschriebenen
Schritte erforderlich.
v So erstellen Sie eine Klasse:
1 Definieren Sie Ihre Klasse Schreiben Sie den Java-Code, der Ihre
Klasse definiert. Wenn Sie den Sun Java SDK benutzen, können Sie
einen Texteditor verwenden. Wenn Sie ein Entwicklungstool wie Sybase
PowerJ benutzen, finden Sie entsprechende Anweisungen im
Entwicklungstool.
Verwenden Sie nur unterstützte Klassen
Wenn Ihre Klasse Java-Laufzeitklassen benutzt, müssen Sie darauf
achten, dass sie sich in der Liste der unterstützten Klassen befinden.
Die Liste finden Sie unter "Unterstützte Java-Pakete" auf Seite 87 der
Dokumentation ASA SQL-Referenzhandbuch.
Benutzerklassen müssen 100% Java sein. Native Methoden sind nicht
zulässig.
103

Java-Klassen in einer Datenbank installieren
Klasse installieren
104
2 Benennen und speichern Sie Ihre Klasse Speichern Sie Ihre
Klassendeklaration (Java-Code) in einer Datei mit der Erweiterung .java.
Achten Sie darauf, dass der Name der Datei mit dem Namen der Klasse
übereinstimmt, und dass die Groß-/Kleinschreibung beider Namen
identisch ist.
Beispiel: Eine Klasse namens "Dienstprogramm" muss in einer Datei
namens Dienstprogramm.java gespeichert werden.
3 Kompilieren Sie Ihre Klasse Mit diesem Schritt wird die
Klassendeklaration mit dem Java-Code in eine neue, eigene Datei
verwandelt, die Byte-Code enthält. Der Name der neuen Datei ist gleich
lautend mit dem Namen der Java-Codedatei, hat aber die Erweiterung
.class. Eine kompilierte Java-Klasse kann in einer Java-
Laufzeitumgebung unabhängig von der Plattform ausgeführt werden, auf
der sie kompiliert wurde. Auch das Betriebssystem der Java-
Laufzeitumgebung spielt keine Rolle.
Der Sun JDK enthält den Java-Compiler Javac.exe.
Nur für Java aktivierte Datenbanken
Jede kompilierte Java-Klassendatei kann in einer Datenbank
installiert werden. Java-Vorgänge, die eine installierte Klasse
verwenden, können nur ausgeführt werden, wenn die Datenbank für
Java aktiviert wurde. Siehe unter "Datenbank für Java aktivieren" auf
Seite 97.
Um Ihre Java-Klasse innerhalb der Datenbank verfügbar zu machen, können
Sie eine Klasse aus Sybase Central einrichten oder mit der Anweisung
INSTALL aus Interactive SQL oder einer anderen Anwendung installieren.
Sie müssen den Suchpfad und den Dateinamen der Klasse kennen, die Sie
installieren wollen.
Sie brauchen die DBA-Berechtigung, um eine Klasse zu installieren.
v So installieren Sie eine Klasse (Sybase Central):
1 Stellen Sie mit DBA-Berechtigung eine Verbindung mit einer
Datenbank her.
2 Öffnen Sie den Ordner "Java-Objekte" für die Datenbank.
3 Doppelklicken Sie auf "Java-Klasse hinzufügen".
4 Befolgen Sie die Anweisungen im Assistenten.

JAR-Datei installieren
Kapitel 4 Java in der Datenbank benutzen
v So installieren Sie eine Klasse (Interactive SQL):
1 Stellen Sie mit DBA-Berechtigung eine Verbindung mit einer
Datenbank her.
2 Führen Sie folgende Anweisung aus:
INSTALL JAVA NEW
FROM FILE ’Suchpfad\\Klassenname.class’
Dabei gilt: Suchpfad ist das Verzeichnis, in dem die Klassendatei
gehalten wird, und Klassenname.class ist der Name der Klassendatei.
Der doppelte Rückstrich sorgt dafür, dass der Rückstrich nicht als
Escapezeichen behandelt wird.
Beispiel: Um eine Klasse zu installieren, die in einer Datei namens
Dienstprogramm.class im Verzeichnis c:\Quelle gehalten wird, geben Sie
folgende Anweisung ein:
INSTALL JAVA NEW
FROM FILE ’c:\\Quelle\\Dienstprogramm.class’
Wenn Sie einen relativen Suchpfad verwenden, muss er zum aktuellen
Arbeitsverzeichnis des Datenbankservers relativ sein.
$ Weitere Hinweise finden Sie unter "INSTALL-Anweisung" auf
Seite 504 der Dokumentation ASA SQL-Referenzhandbuch und unter
"Java-Objekte, Klassen und JAR-Dateien löschen" auf Seite 116.
Es ist sinnvoll und allgemein üblich, Gruppen von miteinander verwandten
Klassen in Paketen zu sammeln und diese Pakete in einer JAR-Datei
zusammenzufassen. Informationen über JAR-Dateien und Pakete finden Sie
im Online-Buch Thinking in Java oder anderer Literatur zum Thema Java-
Programmierung.
Eine JAR-Datei wird auf dieselbe Weise installiert wie eine Klassendatei.
Eine JAR-Datei kann die Erweiterung JAR oder ZIP haben. Jede JAR-Datei
muss einen Namen in der Datenbank haben. Normalerweise benutzen Sie
denselben Namen wie die JAR-Datei, ohne die Erweiterung. Beispiel: Wenn
Sie eine JAR-Datei namens meinejar.zip installieren, sollten Sie ihr im
Allgemeinen den JAR-Namen meinejar geben.
$ Weitere Hinweise finden Sie unter "INSTALL-Anweisung" auf
Seite 504 der Dokumentation ASA SQL-Referenzhandbuch und "Java-
Objekte, Klassen und JAR-Dateien löschen" auf Seite 116.
105

Java-Klassen in einer Datenbank installieren
106
v So installieren Sie eine JAR-Datei (Sybase Central):
1 Stellen Sie mit DBA-Berechtigung eine Verbindung mit einer
Datenbank her.
2 Öffnen Sie den Ordner "Java-Objekte" für die Datenbank.
3 Doppelklicken Sie auf "JAR-Datei hinzufügen".
4 Befolgen Sie die Anweisungen im Assistenten.
v So installieren Sie eine JAR-Datei (Interactive SQL):
1 Stellen Sie mit DBA-Berechtigung eine Verbindung mit einer
Datenbank her.
2 Geben Sie folgende Anweisung ein:
INSTALL JAVA NEW
JAR ’jarname’
FROM FILE ’Suchpfad\\JarName.jar’
Klassen und JAR-Dateien aktualisieren
Bestehende Java-
Objekte und
aktualisierte
Klassen
Gültigkeit
aktualisierter
Klassen
Sie können Klassen und JAR-Dateien mit Sybase Central oder durch die
Eingabe einer INSTALL-Anweisung in Interactive SQL bzw. einer anderen
Clientanwendung installieren.
Um eine Klasse oder eine JAR-Datei zu installieren, müssen Sie DBA-
Berechtigung haben und über eine neuere Version der kompilierten Klasse
oder JAR-Datei in einer Datei auf der Festplatte verfügen.
Es kann sein, dass Instanzen einer Java-Klasse in Form von Java-Objekten in
Ihrer Datenbank oder als Werte in einer Spalte gespeichert sind, die die
Klasse als Datentyp verwendet.
Trotz der Aktualisierung der Klasse bleiben diese alten Werte weiterhin
verfügbar, auch wenn die Felder und Methoden, die in den Tabellen
gespeichert werden, mit der neuen Klassendefinition inkompatibel sind.
Alle neu eingefügten Zeilen müssen allerdings mit der neuen Definition
kompatibel sein.
Die neue Definition wird nur von Verbindungen benutzt, die nach der
Installation der Klasse eingerichtet wurden, oder die die Klasse zum ersten
Mal nach der Installation der Klasse verwenden. Wenn die Virtual Machine
die Klassendefinition lädt, bleibt diese im Speicher, bis die Verbindung
geschlossen wird.

In serialisierter
Form gespeicherte
Objekte
Kapitel 4 Java in der Datenbank benutzen
Wenn Sie eine Java-Klasse oder auf einer Klasse basierende Objekte in der
aktuellen Verbindung benutzt haben, müssen Sie die Verbindung trennen
und wieder aufnehmen, damit die neue Klassendefinition wirksam wird.
$ Um zu verstehen, wie aktualisierte Klassen wirksam werden, müssen
Sie mehr über die Arbeitsweise der Virtual Machine wissen. Hinweise dazu
finden Sie unter "Speicher für Java konfigurieren" auf Seite 140.
Java-Objekte können die aktualisierte Klassendefinition verwenden, weil sie
in serialisierter Form gespeichert werden. Das benutzte
Serialisierungsformat ist speziell für die Datenbank entworfen und entspricht
nicht dem Serialisierungsformat von Sun Microsystems. Die interne Sybase
VM führt alle Serialisierungen und Deserialisierungen durch, sodass dadurch
keine Kompatibilitätsprobleme entstehen.
v So aktualisieren Sie eine Klasse oder JAR-Datei (Sybase Central):
1 Stellen Sie mit DBA-Berechtigung eine Verbindung mit einer
Datenbank her.
2 Öffnen Sie den Ordner "Java-Objekte".
3 Suchen Sie die Klasse oder JAR-Datei, die Sie aktualisieren wollen.
4 Rechtsklicken Sie auf die Klasse oder JAR-Datei und wählen Sie
"Aktualisieren" aus dem Einblendmenü.
5 In dem nun eingeblendeten Dialogfeld geben Sie den Namen und den
Standort der Klasse oder JAR-Datei ein, die Sie aktualisieren wollen. Sie
können mit "Durchsuchen" danach suchen.
Tipp
Sie können eine Java-Klasse oder JAR-Datei auch aktualisieren, indem
Sie im Register "Allgemein" ihres Eigenschaftsfensters auf "Jetzt
aktualisieren" klicken.
v So aktualisieren Sie eine Klasse oder JAR-Datei (Interactive SQL):
1 Stellen Sie mit DBA-Berechtigung eine Verbindung mit einer
Datenbank her.
2 Führen Sie folgende Anweisung aus:
INSTALL JAVA UPDATE
[ JAR ’jarname’ ]
FROM FILE ’Dateiname’
Wenn Sie eine JAR-Datei aktualisieren, müssen Sie den Namen
eingeben, unter dem die JAR in der Datenbank bekannt ist.
107

Java-Klassen in einer Datenbank installieren
108
$ Weitere Hinweise finden Sie unter "INSTALL-Anweisung" auf
Seite 504 der Dokumentation ASA SQL-Referenzhandbuch.

Kapitel 4 Java in der Datenbank benutzen
Spalten für die Aufnahme von Java-Objekten
erstellen
Dieser Abschnitt erläutert, wie Spalten mit Datentypen der Java-Klassen in
die standardmäßige SQL-Struktur passen.
Spalten mit Java-Datentypen erstellen
Berücksichtigung
von Groß-/Kleinschreibung
Sie können jede installierte Java-Klasse als Datentyp benutzen. Sie müssen
einen voll qualifizierten Namen für den Datentyp verwenden.
Beispiel: Die folgende Anweisung CREATE TABLE enthält Spalten der
Java-Datentypen asademo.Name und asademo.ContactInfo. Hier sind
Name und ContactInfo Klassen im Paket asademo.
CREATE TABLE jdba.customer
(
id integer NOT NULL,
company_name CHAR(35) NOT NULL,
JName asademo.Name NOT NULL,
JContactInfo asademo.ContactInfo NOT NULL,
PRIMARY KEY (id)
)
Anders als bei SQL-Datentypen berücksichtigen Java-Datentypen die Groß-
/Kleinschreibung. Sie müssen die Datentypen immer in der richtigen
Schreibweise eingeben.
Standardwerte und NULLWERTE in Java-Spalten verwenden
Sie können Standardwerte für Java-Spalten verwenden, und Java-Spalten
können NULLWERTE enthalten.
Java-Spalten und Standardwerte Spalten können als Standardwert jede
Funktion mit dem richtigen Datentyp oder einen beliebigen voreingestellten
Standardwert enthalten. Sie können jede Funktion mit dem richtigen
Datentyp (d.h. derselben Klasse wie die Spalte) als Standardwert für Java-
Spalten verwenden.
Java-Spalten und NULLWERTE Java-Spalten können NULLWERTE
zulassen. Wenn für eine nullwertfähige Spalte mit einem Java-Datentyp kein
Standardwert gesetzt ist, enthält die Spalte NULL.
109

Spalten für die Aufnahme von Java-Objekten erstellen
110
Wenn ein Java-Wert nicht gesetzt ist, hat er den Java-NULLWERT. Dieser
Java-NULLWERT ist dem SQL-NULLWERT zugeordnet, und Sie können
daher die Suchbedingungen IS NULL und IS NOT NULL für diese Werte
verwenden. Beispiel: Wenn die Beschreibung des Java-Objekts "product" in
einer Spalte namens JProd nicht gesetzt wurde, können Sie alle Produkte mit
Nicht-Nullwerten für die Beschreibung wie folgt abrufen:
SELECT *
FROM product
WHERE JProd>>description IS NULL

Kapitel 4 Java in der Datenbank benutzen
Java-Objekte einfügen, aktualisieren und
löschen
Java-Beispiel-
Tabellen erstellen
Eine Beispielklasse
In diesem Abschnitt wird beschrieben, wie Standard-SQL-Anweisungen für
die Datenverarbeitung auf Java-Spalten angewendet werden.
In diesem Abschnitt werden die einzelnen Punkte mit konkreten Beispielen
illustriert, die auf der Tabelle Product der Beispieldatenbank und einer
Klasse namens Product basieren. Als Erstes sollten Sie sich die Datei
Samples\ASA\Java\asademo\Product.java in Ihrem SQL Anywhere-
Verzeichnis ansehen.
Die Beispiele in diesem Abschnitt setzen voraus, dass Sie die Java-Tabellen
der Beispieldatenbank hinzugefügt haben und als Benutzer jDBA mit dem
Kennwort SQL verbunden sind.
$ Weitere Hinweise finden Sie unter "Java-Beispiele einrichten" auf
Seite 94.
In diesem Abschnitt wird eine Klasse beschrieben, die in Beispielen aller
folgenden Abschnitte verwendet wird.
Die Klassendefinition Product im Verzeichnis
Samples\ASA\Java\asademo\Product.java in Ihrem SQL Anywhere-
Verzeichnis wird teilweise im Folgenden dargestellt (zum besseren
Verständnis werden die Kommentarzeilen, die in der Originaldatei in
Englisch sind, hier in deutscher Übersetzung wiedergegeben):
package asademo;
public class Product implements java.io.Serializable {
// "public"-Felder
public String name ;
public String description ;
public String size ;
public String color;
public int quantity ;
public java.math.BigDecimal unit_price ;
// Standard-Konstruktor
Product () {
unit_price = new java.math.BigDecimal( 10.00 );
name = "Unknown";
size = "One size fits all";
111

Java-Objekte einfügen, aktualisieren und löschen
Hinweise
Java-Objekte einfügen
112
}
// Konstruktor mit allen verfügbaren Argumenten
Product ( String inColor,
String inDescription,
String inName,
int inQuantity,
String inSize,
java.math.BigDecimal inUnit_price
) {
color = inColor;
description = inDescription;
name = inName;
quantity = inQuantity;
size = inSize;
unit_price=inUnit_price;
}
public String toString() {
return size + " " + name + ": " +
unit_price.toString();
}
♦ Die Klasse Product hat einige öffentliche Felder, die einigen Spalten
der Tabelle DBA.Product entsprechen, die in dieser Klasse gesammelt
werden sollen.
♦ Die Methode toString wird der Einfachheit halber bereitgestellt. Wenn
Sie einen Objektnamen in eine Auswahlliste einbeziehen, wird die
Methode toString ausgeführt, und ihre Rückgabezeichenfolgen werden
angezeigt.
♦ Einige Methoden sind vorgesehen, um die Felder zu setzen und
abzurufen. Es ist beim objektorientierten Programmieren auch allgemein
üblich, solche Methoden zu verwenden, und nicht die Felder direkt zu
adressieren. Für die praktische Einführung wurden die Felder zur
einfacheren Durchführung als "öffentliche" Felder zugänglich gemacht.
Wenn Sie eine Zeile in eine Tabelle EINFÜGEN, die eine Java-Spalte hat,
müssen Sie ein Java-Objekt in die Java-Spalte einfügen.
Sie können ein Java-Objekt auf zwei Arten einfügen: aus SQL oder mit
JDBC aus anderen Java-Klassen, die in der Datenbank ausgeführt werden.

Java-Objekte aus SQL einfügen
Objekt mit einem
Konstruktor
einfügen
Objekt aus einer
SQL-Variablen
einfügen
Kapitel 4 Java in der Datenbank benutzen
Sie können ein Java-Objekt mit einem Konstruktor einfügen oder SQL-
Variable verwenden, um ein Java-Objekt aufzubauen, bevor Sie es einfügen.
Wenn Sie einen Wert in eine Spalte einfügen, die einen Java-Klassen-
Datentyp hat, fügen Sie ein Java-Objekt ein. Um ein Objekt mit den richtigen
Eigenschaften einzufügen, muss das neue Objekt die richtigen Werte für
öffentliche Felder haben, und Methoden, die private Felder setzen, müssen
aufgerufen werden.
v So fügen Sie ein Java-Objekt ein:
♦ INSERT: Verwenden Sie die INSERT-Anweisung, um eine neue
Instanz der Klasse "Product" in die Tabelle product einzufügen:
INSERT
INTO product ( ID, JProd )
VALUES ( 702, NEW asademo.Product() )
Sie können dieses Beispiel in der Beispieldatenbank als Benutzer jdba
ausführen, nachdem Sie das Skript jdemo.sql ausgeführt haben.
Das Schlüsselwort NEW ruft den Standard-Konstruktor für die Klasse
Product im Paket asademo auf.
Sie können die Werte der Felder des Objekts in einer SQL-Variablen der
richtigen Klasse auch individuell setzen, und nicht durch den Konstruktor.
v So fügen Sie ein Java-Objekt mit SQL-Variablen ein:
1 Erstellen Sie eine SQL-Variable der Java-Klassentypen:
CREATE VARIABLE ProductVar asademo.Product
2 Weisen Sie der Variablen ein neues Objekt zu, indem Sie den
Klassenkonstruktor verwenden:
SET ProductVar = NEW asademo.Product()
3 Weisen Sie den Feldern des Objekts Werte zu, wo solche erforderlich
sind:
SET ProductVar>>color = ’Black’;
SET ProductVar>>description = ’Steel tipped boots’;
SET ProductVar>>name = ’Work boots’;
SET ProductVar>>quantity = 40;
SET ProductVar>>size = ’Extra Large’;
SET ProductVar>>unit_price = 79.99;
4 Fügen Sie die Variable in die Tabelle ein:
INSERT
INTO Product ( id, JProd )
113

Java-Objekte einfügen, aktualisieren und löschen
Objekt aus Java einfügen
Java-Objekt aktualisieren
Gesamtes Objekt
aktualisieren
114
VALUES ( 800, ProductVar )
5 Prüfen Sie, ob der Wert eingefügt wurde:
SELECT *
FROM product
WHERE id=800
6 Machen Sie die Änderungen rückgängig, die Sie in dieser Übung
vorgenommen haben:
ROLLBACK
Die Verwendung von SQL-Variablen ist typisch für gespeicherte Prozeduren
und andere Verwendungsmöglichkeiten von SQL zum Einbau von
programmierter Logik in die Datenbank. Java ist die leistungsfähigere
Sprache für solche Aufgaben. Sie können die serverseitigen Java-Klassen
gemeinsam mit JDBC verwenden, um Objekte in Tabellen einzufügen.
Sie können ein Objekt mit einer vorbereiteten Anweisung von JDBC
einfügen.
Eine vorbereitete Anweisung benutzt Platzhalter für Variable. Sie können
dann die Methode setObject des Objekts PreparedStatement benutzen.
Sie können vorbereitete Anweisungen verwenden, um Objekte von
clientseitiger oder serverseitiger JDBC einzufügen.
$ Weitere Hinweise über die Verwendung von vorbereiteten
Anweisungen für Objekte finden Sie unter "Objekte einfügen und abrufen"
auf Seite 172.
Java-Spaltenwerte können mit einer der folgenden Methoden aktualisiert
werden:
♦ Gesamtes Objekt aktualisieren
♦ Einige der Felder im Objekt aktualisieren
Für die Aktualisierung des Objekts gehen Sie fast genauso vor wie für das
Einfügen:
♦ Aus SQL können Sie einen Konstruktor verwenden, um das Objekt auf
ein neues Objekt zu aktualisieren, wenn der Konstruktor es erstellt. Sie
können dann einzelne Felder aktualisieren, wenn Sie dies benötigen.

Felder des Objekts
aktualisieren
set-Methoden
verwenden
Kapitel 4 Java in der Datenbank benutzen
♦ Aus SQL können Sie eine SQL-Variable verwenden, um das benötigte
Objekt aufzunehmen, und dann die Zeile aktualisieren, damit die
Variable darin eingefügt wird.
♦ Aus JDBC können Sie eine vorbereitete Anweisung und die Methode
PreparedStatement.setObject verwenden.
Einzelne Felder eines Objekts haben Datentypen, die SQL-Datentypen
entsprechen. Dabei verwenden Sie die Zuordnung von SQL- zu Java-
Datentypen laut der Beschreibung unter "Umwandlung von JAVA- in SQL-
Datentypen" auf Seite 95 der Dokumentation ASA SQL-Referenzhandbuch.
Sie können einzelne Felder mit einer Standard-UPDATE-Anweisung
aktualisieren:
UPDATE Product
SET JProd.unit_price = 16.00
WHERE ID = 302
In der ersten Version von Java in der Datenbank musste eine spezielle
Funktion (EVALUATE) verwendet werden, um Aktualisierungen
vorzunehmen. Dies ist nicht mehr erforderlich.
Damit ein Java-Feld aktualisiert werden kann, muss der Java-Typ des Feldes
einem SQL-Typ zugeordnet sein: Der Ausdruck auf der rechten Seite der
SET-Klausel muss mit diesem Typ übereinstimmen. Sie müssen eventuell
die CAST-Funktion verwenden, um die Datentypen entsprechend
einzuordnen.
$ Hinweise zur Datentypzuordnung zwischen Java und SQL finden Sie
unter "Umwandlung von JAVA- in SQL-Datentypen" auf Seite 95 der
Dokumentation ASA SQL-Referenzhandbuch.
Bei der Java-Programmmierung ist es allgemein üblich, Felder nicht direkt
anzusprechen, sondern Methoden zu benutzen, um die Werte zu holen und zu
setzen. Außerdem ist es allgemein üblich, dass diese Methoden void
zurückgeben. Sie können in SQL set-Methoden verwenden, um eine Spalte
zu aktualisieren:
UPDATE jdba.Product
SET JProd.setName( ’Tank Top’)
WHERE id=302
Der Einsatz von Methoden anstelle der direkten Ansprache des Feldes ist
langsamer, da die Java VM laufen muss.
$ Weitere Hinweise finden Sie unter "Rückgabewert von Methoden, die
"void" zurückgeben" auf Seite 125.
115

Java-Objekte einfügen, aktualisieren und löschen
Java-Objekte, Klassen und JAR-Dateien löschen
116
Das Löschen von Zeilen mit Java-Objekten unterscheidet sich nicht vom
Löschen anderer Zeilen. Die WHERE-Klausel in der DELETE-Anweisung
kann Java-Objekte oder Java-Felder und Methoden enthalten.
$ Weitere Hinweise finden Sie unter "DELETE-Anweisung" auf
Seite 422 der Dokumentation ASA SQL-Referenzhandbuch.
Mit Sybase Central können Sie auch eine ganze Java-Klasse oder JAR-Datei
löschen.
v So löchen Sie eine Java-Klasse oder JAR-Datei (Sybase Central):
1 Öffnen Sie den Ordner "Java-Objekte".
2 Suchen Sie die Klasse oder JAR-Datei, die Sie löschen wollen.
3 Rechtsklicken Sie auf die Klasse oder JAR-Datei und wählen Sie
"Löschen" aus dem Einblendmenü.
$ Siehe auch:
♦ "Klasse installieren" auf Seite 104
♦ "JAR-Datei installieren" auf Seite 105

Java-Objekte abfragen
Gesamtes Objekt
abfragen
Felder des Objekts
abrufen
Kapitel 4 Java in der Datenbank benutzen
Java-Spaltenwerte können mit einer der folgenden Methoden abgefragt
werden:
♦ Gesamtes Objekt abfragen
♦ Einige der Felder im Objekt abfragen
Aus SQL können Sie eine Variable des geeigneten Typs erstellen und den
Wert aus dem Objekt in diese Variable auswählen. Vor allem aber werden
Sie das ganze Objekt in einer Java-Anwendung brauchen.
Sie können ein Objekt in eine serverseitige Java-Klasse abrufen, indem Sie
die Methode getObject des ResultSet einer Abfrage verwenden. Sie können
auch ein Objekt in eine clientseitige Java-Anwendung abrufen.
$ Wie Objekte mit JDBC abgerufen werden, finden Sie unter "Abfragen
mit JDBC" auf Seite 169.
Einzelne Felder eines Objekts haben Datentypen, die SQL-Datentypen
entsprechen. Dabei verwenden Sie die Zuordnung von SQL- zu Java-
Datentypen laut der Beschreibung unter "Umwandlung von JAVA- in SQL-
Datentypen" auf Seite 95 der Dokumentation ASA SQL-Referenzhandbuch.
♦ Sie können einzelne Felder abrufen, indem Sie sie in die Auswahlliste
einer Abfrage einschließen, wie dies im folgenden einfachen Beispiel
beschrieben wird.
SELECT JProd>>unit_price
FROM product
WHERE ID = 400
♦ Wenn Sie Methoden verwenden, um die Werte Ihrer Felder zu setzen
und abzurufen, wie es beim objektorientierten Programmieren allgemein
üblich ist, können Sie eine Methode getField in Ihre Abfrage
einbeziehen.
SELECT JProd>>getName()
FROM Product
WHERE ID = 401
$ Informationen über die Verwendung von Objekten in der WHERE-
Klausel und andere Hinweise zum Vergleich von Objekten finden Sie unter
"Java-Felder und Objekte vergleichen" auf Seite 119.
117

Java-Objekte abfragen
Die Ergebnisse der
Anweisung
SELECT
Spaltenname
118
Performance-Tipp
Das direkte Abrufen eines Feldes ist schneller als der Aufruf einer
Methode, die das Feld abruft, da für den Aufruf der Methode die Java VM
gestartet werden muss.
Sie können den Spaltennamen in einer Abfrage-Auswahlliste auflisten, wie
in der folgenden Abfrage:
SELECT JProd
FROM jdba.product
Die Abfrage gibt die Sun-Serialisierung des Objekts an die Clientanwendung
zurück.
Wenn Sie in Interactive SQL eine Abfrage ausführen, die ein Objekt abruft,
wird der Rückgabewert der toString-Methode des Objekts angezeigt. Für die
Klasse "Product" listet die Methode toString in einer Zeichenfolge die
Größe, den Namen und den Stückpreis des Objekts auf. Die Ergebnisse der
Abfrage lauten wie folgt:
JProd
Small Tee Shirt: 9.00
Medium Tee Shirt: 14.00
One size fits all Tee Shirt: 14.00
One size fits all Baseball Cap: 9.00
One size fits all Baseball Cap: 10.00
One size fits all Visor: 7.00
One size fits all Visor: 7.00
Large Sweatshirt: 24.00
Large Sweatshirt: 24.00
Medium Shorts: 15.00

Java-Felder und Objekte vergleichen
Art des Vergleichs
von Java-Objekten
Kapitel 4 Java in der Datenbank benutzen
Öffentliche Java-Klassen sind Domänen, die viel umfangreichere Funktionen
bieten als herkömmliche SQL-Domänen. In diesem Zusammenhang ergibt
sich die Frage, wie sich Java-Spalten in einer relationalen Datenbank im
Vergleich zu traditionellen SQL-Datentypen verhalten.
Die Frage des Vergleichs von Objekten hat Auswirkungen insbesondere in
folgenden Bereichen:
♦ Abfragen mit einer ORDER BY Klausel, einer GROUP BY Klausel,
einem DISTINCT Schlüsselwort oder mit einer Aggregatfunktion
♦ Anweisungen, die Gleichheits- oder Ungleichheits-
Vergleichsbedingungen verwenden
♦ Indizes und eindeutige Spalten
♦ Primär- und Fremdschlüsselspalten
Sortieren von Zeilen in einer Abfrage oder in einem Index setzt voraus, dass
die Werte in jeder Zeile miteinander verglichen werden. Wenn Sie eine Java-
Spalte haben, können Sie Vergleiche in der folgenden Weise ausführen:
♦ Vergleich über ein öffentliches Feld Sie können über ein öffentliches
Feld genauso einen Vergleich vornehmen wie über eine normale Zeile.
Beispielsweise könnten Sie folgende Abfrage ausführen:
SELECT name, JProd.unit_price
FROM Product
ORDER BY JProd.unit_price
Diese Art des Vergleichs kann in Abfragen verwendet werden, ist aber
für Indizes und Schlüsselspalten nicht anwendbar.
♦ Vergleich mit einer "compareTo"-Methode Java-Objekte, die eine
compareTo-Methode implementiert haben, können verglichen werden.
Die Klasse "Product", auf der die Spalte JProd basiert, hat eine
compareTo-Methode, die Objekte auf Grundlage des Feldes unit_price
miteinander vergleicht. Damit wird folgende Abfrage ermöglicht:
SELECT name, JProd.unit_price
FROM Product
ORDER BY JProd
Der benötigte Vergleich für die ORDER BY Klausel erfolgt automatisch
basierend auf der Methode compareTo.
119

Java-Felder und Objekte vergleichen
Java-Objekte vergleichen
Anforderungen der
"compareTo"-
Methode
Beispiel
120
Um zwei Objekte desselben Typs zu vergleichen, müssen Sie eine
compareTo-Methode implementieren:
♦ Damit Spalten mit Java-Datentypen als Primärschlüssel, Indizes oder
eindeutige Spalten verwendet werden können, muss die Spaltenklasse
eine compareTo-Methode implementieren.
♦ Um die Klauseln ORDER BY, GROUP BY oder DISTINCT in einer
Abfrage verwenden zu können, müssen die Werte der Spalte verglichen
werden. Die Spaltenklasse muss eine compareTo-Methode haben,
damit alle diese Klauseln gültig sind.
♦ Funktionen, die Vergleiche verwenden, wie MAX und MIN, können nur
mit einer Java-Klasse benutzt werden, die eine compareTo-Methode
hat.
Die compareTo-Methode muss folgende Eigenschaften haben:
♦ Bereich Die Methode muss extern sichtbar und daher eine öffentliche
Methode sein.
♦ Argumente Die Methode übernimmt ein einzelnes Argument, das ein
Objekt des aktuellen Typs ist. Das aktuelle Objekt wird mit dem
gelieferten Objekt verglichen. Beispiel: Product.compareTo hat
folgendes Argument:
compareTo( Produkt AnderesProdukt )
Die Methode vergleicht das Objekt AnderesProdukt vom Typ
"Produkt" mit dem aktuellen Objekt.
♦ Rückgabewerte Die Methode "compareTo" muss einen int-Datentyp
mit folgenden Bedeutungen zurückgeben:
♦ Negative Ganzzahl Das aktuelle Objekt ist geringer als das
gelieferte Objekt. Es wird empfohlen, dass Sie für diesen Fall -1
zurückgeben, um die Kompatibilität mit "compareTo"-Methoden in
Basis-Java-Klassen zu gewährleisten.
♦ Ziffer Null Das aktuelle Objekt hat denselben Wert wie das
gelieferte Objekt.
♦ Positive Ganzzahl Das aktuelle Objekt ist größer als das gelieferte
Objekt. Es wird empfohlen, dass Sie für diesen Fall 1 zurückgeben,
um die Kompatibilität mit "compareTo"-Methoden in Basis-Java-
Klassen zu gewährleisten.
Die Klasse Product, die mit den Beispielklassen in der Beispieldatenbank
installiert wird, hat eine compareTo-Methode der folgenden Art:

Methoden
"toString" und
"compareTo"
kompatibel
machen
Kapitel 4 Java in der Datenbank benutzen
public int compareTo( Product anotherProduct ) {
// Erst auf Basis des Preises vergleichen
// und dann auf Basis von toString()
int lVal = unit_price.intValue();
int rVal = anotherProduct.unit_price.intValue();
if ( lVal > rVal ) {
return 1;
}
else if (lVal < rVal ) {
return -1;
}
else {
return toString().compareTo(
anotherProduct.toString() );{
}
}
}
Diese Methode vergleicht den Einheitspreis jedes Objekts. Wenn die
Einheitspreise identisch sind, werden die Namen verglichen (mit Java-
Zeichenfolgenvergleichen, nicht mit Datenbank-Zeichenfolgenvergleichen).
Nur wenn der Einheitspreis und der Name gleich sind, werden die beiden
Objekte beim Vergleich als identisch angesehen.
Wenn Sie eine Java-Spalte in die Auswahlliste einbeziehen und in Interactive
SQL ausführen, wird der Wert der Methode toString zurückgegeben. Wenn
Sie Spalten vergleichen, wird die Methode compareTo verwendet. Wenn die
Methoden toString und compareTo nicht konsistent implementiert sind,
kann es zu unvorhergesehenen Ergebnissen kommen, wie DISTINCT-
Abfragen, die augenscheinlich Duplikat-Zeilen zurückgeben.
Als Beispiel nehmen wir an, dass die Klasse "Product" in der
Beispieldatenbank eine Methode toString hat, die den Produktnamen
zurückgibt, und eine Methode compareTo, die auf dem Preis basiert. Die
folgende, in Interactive SQL eingegebene Abfrage würde in diesem Fall
Doppelwerte ausgeben:
SELECT DISTINCT JProd
FROM product
JProd
Tee Shirt
Tee Shirt
Baseball Cap
Visor
Sweatshirt
Shorts
121

Java-Felder und Objekte vergleichen
122
Hier wird der angezeigte Rückgabewert durch toString festgelegt. Das
DISTINCT-Schlüsselwort eliminiert Duplikate, wie von compareTo
festgelegt. Da hier eine Implementierung der Methoden vorliegt, die die
Beziehungen untereinander nicht berücksichtigt, sieht es so aus, als würden
Duplikatzeilen zurückgegeben.

Kapitel 4 Java in der Datenbank benutzen
Besondere Funktionen von Java-Klassen in der
Datenbank
Unterstützte Klassen
Hauptmethode (main) verwenden
In diesem Abschnitt werden besondere Funktionen von Java-Klassen
beschrieben, die in einer Datenbank eingesetzt werden.
Sie können nicht alle Klassen aus dem JDK verwenden. Die Java-
Laufzeitklassen, die für den Einsatz in einem Datenbankserver verfügbar
sind, gehören zu einer Teilmenge der Java-API.
$ Weitere Hinweise über unterstützte Pakete finden Sie unter
"Unterstützte Java-Pakete" auf Seite 87 der Dokumentation ASA SQL-
Referenzhandbuch.
Sie starten Java-Anwendungen (außerhalb der Datenbank), indem Sie die
Java VM mit einer Klasse ausführen, die eine main-Methode hat.
Zum Beispiel hat die Klasse JDBCExamples in der Datei
Samples\ASA\Java\JDBCExamples.java in Ihrem SQL Anywhere-
Verzeichnis eine Hauptmethode (main). Wenn Sie die Klasse von der
Befehlszeile aus mit einem Befehl wie dem folgenden ausführen, wird die
Hauptmethode (main) ausgeführt:
java JDBCExamples
$ Hinweise über das Ausführen der Klasse JDBCExamples finden Sie
unter "JDBC-Verbindungen herstellen" auf Seite 157.
v So wird die Hauptmethode (main) einer Klasse von SQL aus
aufgerufen:
1 Deklarieren Sie die Methode mit einem Array von Zeichenfolgen als
Argument.
public static void main( java.lang.String[] args ){
...
}
2 Rufen Sie die Methode main mit der CALL-Anweisung auf.
123

Besondere Funktionen von Java-Klassen in der Datenbank
Beispiel
124
Jedes Mitglied des Arrays von Zeichenfolgen muss den Datentyp CHAR
oder VARCHAR haben oder muss ein Literal sein.
Die folgende Klasse enthält eine main-Methode, die die Argumente in
umgekehrter Reihenfolge ausgibt:
public class ReverseWrite {
public static void main( String[] args ){
int i:
for( i = args.length; i > 0 ; i-- ){
System.out.print( args[ i-1 ] );
}
}
}
Sie können diese Methode aus SQL wie folgt ausführen:
call ReverseWrite.main( ’ one’, ’ two’, ’three’ )
Das Datenbankserver-Fenster zeigt die Ausgabe:
three two one
Threads in Java-Anwendungen verwenden
Serialisierung von
JDBC-Aufrufen
Sie können mehrere Threads in einer Java-Anwendung benutzen, indem Sie
Funktionen des Pakets java.lang.Thread einsetzen. Jeder Java-Thread ist ein
Engine-Thread und wird aus der Menge der zulässigen Threads gemäß der
Option -gn des Datenbankservers bezogen.
Sie können Threads in Java-Anwendungen synchronisieren, vorläufig
aussetzen, wieder aufnehmen, unterbrechen oder stoppen.
$ Hinweise zu Datenbankserver-Threads finden Sie unter "–gn-
Serveroption" auf Seite 158 der Dokumentation ASA
Datenbankadministration.
Fehler "Prozedur nicht gefunden"
Alle Aufrufe zum serverseitigen JDBC-Treiber sind serialisiert, sodass nur
ein Thread jeweils JDBC ausführt.
Wenn Sie eine falsche Anzahl von Argumenten für den Aufruf einer Java-
Methode eingeben oder einen falschen Datentyp verwenden, antwortet der
Server mit der Fehlermeldung Prozedur nicht gefunden. Prüfen Sie in diesem
Fall Anzahl und Typ der Argumente.

Kapitel 4 Java in der Datenbank benutzen
$ Eine Liste der Datentypkonvertierungen zwischen SQL und Java finden
Sie unter "Umwandlung von JAVA- in SQL-Datentypen" auf Seite 95 der
Dokumentation ASA SQL-Referenzhandbuch.
Rückgabewert von Methoden, die "void" zurückgeben
Sie können Java-Methoden in SQL-Anweisungen überall dort verwenden,
wo Sie einen Ausdruck benutzen können. Sie müssen dafür Sorge tragen,
dass der Rückgabe-Datentyp der Java-Methode zum entsprechenden SQL-
Datentyp passt.
$ Weitere Hinweise über Zuordnungen von Java- und SQL-Datentypen
finden Sie unter "Umwandlung von JAVA- in SQL-Datentypen" auf Seite 95
der Dokumentation ASA SQL-Referenzhandbuch.
Wenn eine Methode jedoch eine leere Menge zurückgibt, wird der Wert this
an SQL zurückgegeben, d.h. das Objekt selbst. Die Funktion betrifft nur
Aufrufe, die von SQL aus ausgeführt werden, nicht von Java aus.
Diese Funktion ist besonders gut in UPDATE-Anweisungen einsetzbar, in
denen set-Methoden in der Regel "void" zurückgeben. Sie können die
folgende UPDATE-Anweisung in der Beispieldatenbank benutzen:
update jdba.product
set JProd = JProd.setName(’Tank Top’)
where id=302
Die Methode setName gibt "void" und daher implizit das Objekt "Product"
an SQL zurück.
Ergebnismengen aus Java-Methoden zurückgeben
Dieser Abschnitt beschreibt, wie Ergebnismengen aus Java-Methoden
verfügbar gemacht werden. Sie müssen eine Java-Methode schreiben, die
eine Ergebnismenge an die aufrufende Umgebung zurückgibt, und diese
Methode in eine in SQL geschriebene gespeicherte Prozedur einbauen, die
als EXTERNAL NAME of LANGUAGE JAVA deklariert sein muss.
v So werden Ergebnismengen aus einer Java-Methode
zurückgegeben:
1 Achten Sie darauf, dass die Java-Methode als öffentlich und statisch in
einer öffentlichen Klasse deklariert wird.
2 Für jede Ergebnismenge, die die Methode zurückgeben soll, muss die
Methode einen Parameter vom Typ java.sql.ResultSet[] haben. Diese
Ergebnismengen-Parameter müssen am Ende der Parameterliste stehen.
125

Besondere Funktionen von Java-Klassen in der Datenbank
Beispiel
126
3 In der Methode erstellen Sie erst eine Instanz von java.sql.ResultSet
und ordnen sie dann einem der ResultSet[]-Parameter zu.
4 Erstellen Sie eine in SQL geschriebene gespeicherte Prozedur des Typs
EXTERNAL NAME LANGUAGE JAVA. Dieser Prozedurtyp ist ein
Mantel für eine Java-Methode. Sie können einen Cursor für die
Ergebnismenge der SQL-Prozedur auf dieselbe Weise verwenden wie
jede andere Prozedur, die Ergebnismengen zurückgibt.
$ Hinweise zur Syntax für gespeicherte Prozeduren, die als Mantel
für Java-Methoden verwendet werden, finden Sie unter "CREATE
PROCEDURE-Anweisung" auf Seite 331 der Dokumentation ASA SQL-
Referenzhandbuch.
Die folgende Beispielklasse hat eine einzige Methode, die eine Abfrage
ausführt und die Ergebnismenge an die aufrufende Umgebung zurückgibt.
import java.sql.*;
public class MyResultSet {
public static void return_rset( ResultSet[] rset1 )
throws SQLException {
Connection conn = DriverManager.getConnection(
"jdbc:default:connection" );
Statement stmt = conn.createStatement();
ResultSet rset =
stmt.executeQuery (
"SELECT CAST( JName.lastName " +
"AS CHAR( 50 ) )" +
"FROM jdba.contact " );
rset1[0] = rset;
}
}
Die Ergebnismenge wird in SQL mit der Anweisung CREATE
PROCEDURE exponiert, womit die Anzahl der von der Prozedur
zurückgegebenen Ergebnismengen und die Signatur der Java-Methode
angezeigt werden.
Eine Anweisung vom Typ CREATE PROCEDURE, die eine Ergebnismenge
anzeigt, könnte wie folgt definiert werden:
CREATE PROCEDURE result_set()
DYNAMIC RESULT SETS 1
EXTERNAL NAME
’MyResultSet.return_rset ([Ljava/sql/ResultSet;)V’
LANGUAGE JAVA
Ein Cursor kann für diese Prozedur genauso wie für andere ASA-Prozeduren
geöffnet werden, die Ergebnismengen zurückgeben.

Kapitel 4 Java in der Datenbank benutzen
Die Zeichenfolge (Ljava/sql/ResultSet;)V ist eine Java-Methodensignatur,
also eine kompakte Zeichendarstellung der Anzahl und der Typen der
Parameter und Rückgabewerte.
$ Weitere Hinweise zu Java-Methodensignaturen finden Sie unter
"CREATE PROCEDURE-Anweisung" auf Seite 331 der Dokumentation
ASA SQL-Referenzhandbuch.
Rückgabe von Werten aus Java über gespeicherte Prozeduren
Sie können gespeicherte Prozeduren, die mit EXTERNAL NAME
LANGUAGE JAVA erstellt wurden, als Mantel für Java-Methoden
verwenden. In diesem Abschnitt wird beschrieben, wie Sie Ihre Java-
Methode so schreiben, dass OUT- oder INOUT-Parameter in der
gespeicherten Prozedur benutzt werden können.
Java hat keine explizite Unterstützung für INOUT- oder OUT-Parameter.
Anstelle dessen können Sie ein Array des Parameters verwenden. Beispiel:
Um einen Ganzzahl-OUT-Parameter zu benutzen, erstellen Sie ein Array von
genau einer Ganzzahl:
public class TestClass {
public static boolean testOut( int[] param ){
param[0] = 123;
return true;
}
}
Die folgende Prozedur benutzt die testOut-Methode:
CREATE PROCEDURE sp_testOut ( OUT p INTEGER )
EXTERNAL NAME ’TestClass/testOut ([I)Z’
LANGUAGE JAVA
Die Zeichenfolge ([I)Z ist eine Java-Methodensignatur, die anzeigt, dass die
Methode einen einzelnen Parameter hat, der ein Array von Ganzzahlen
darstellt und einen Boolschen Wert zurückgibt. Sie müssen die Methoden so
definieren, damit der Methodenparameter, den Sie als OUT- oder INOUT-
Parameter verwenden wollen, ein Array eines Java-Datentyps ist, der dem
SQL-Datentyp des OUT- oder INOUT-Parameters entspricht.
$ Hinweise zur Syntax, einschließlich der Methodensignatur, finden Sie
unter "CREATE PROCEDURE-Anweisung" auf Seite 331 der
Dokumentation ASA SQL-Referenzhandbuch.
$ Weitere Hinweise finden Sie unter "Umwandlung von JAVA- in SQL-
Datentypen" auf Seite 95 der Dokumentation ASA SQL-Referenzhandbuch.
127

Besondere Funktionen von Java-Klassen in der Datenbank
Sicherheits-Management für Java
Der Standard-
Sicherheits-
Manager
Java-Datei-I/O-
Vorgänge mit dem
standardmäßigen
Sicherheits-
Manager steuern
128
Java bietet Sicherheits-Manager, die Sie zur Steuerung des Benutzerzugriffs
auf vertrauliche Funktionen Ihrer Anwendungen, wie etwa Dateizugriff und
Netzwerkzugriff, einsetzen können. Adaptive Server Anywhere bietet die
folgende Unterstützung für Java-Sicherheitsmanager in der Datenbank:
♦ Adaptive Server Anywhere liefert einen standardmäßigen Sicherheits-
Manager.
♦ Sie können Ihren eigenen Sicherheitsmanager stellen.
$ Hinweise dazu finden Sie unter "Eigenen Sicherheits-Manager
implementieren" auf Seite 129.
Der standardmäßige Sicherheits-Manager ist die Klasse
com.sybase.asa.jrt.SAGenericSecurityManager. Er führt die folgenden
Aufgaben durch:
1 Er prüft den Wert der Datenbankoption JAVA_INPUT_OUTPUT.
2 Er prüft, ob der Datenbankserver mit der Datenbankserveroption -sc im
C2-Sicherheitsmodus gestartet wurde.
3 Falls die Verbindungseigenschaft auf OFF steht, wird damit der Zugriff
auf Java-Datei-I/O-Funktionen deaktiviert.
4 Wenn der Datenbankserver im C2-Sicherheitsmodus läuft, wird der
Zugriff auf java.net-Pakete verwehrt.
5 Wenn der Sicherheits-Manager einen Benutzer am Zugriff auf eine
Funktion hindert, wird eine java.lang.SecurityException
zurückgegeben.
$ Weitere Hinweise finden Sie unter "JAVA_INPUT_OUTPUT-Option"
auf Seite 642 der Dokumentation ASA Datenbankadministration, und "–sc-
Serveroption" auf Seite 167 der Dokumentation ASA
Datenbankadministration.
Die Java-Datei-I/O-Vorgänge werden über die Datenbankoption
JAVA_INPUT_OUTPUT gesteuert. Standardmäßig wird diese Option auf
OFF gesetzt, sodass Datei-I/O-Vorgänge nicht zulässig sind.
v So wird der Dateizugriff mit dem standardmäßigen Sicherheits-
Manager zugelassen:
♦ Setzen Sie die Option JAVA_INPUT_OUTPUT auf ON:
SET OPTION JAVA_INPUT_OUTPUT=’ON’

Eigenen Sicherheits-Manager implementieren
Beispiel
Kapitel 4 Java in der Datenbank benutzen
Ein eigener Sicherheits-Manager wird mit mehreren Schritten implementiert.
v So wird Ihr eigener Sicherheits-Manager verfügbar gemacht:
1 Implementieren Sie eine Klasse, die java.lang.SecurityManager
erweitert.
Die Klasse SecurityManager umfasst eine Reihe von Methoden, die
prüfen, ob ein bestimmter Vorgang zulässig ist. Falls die Aktion zulässig
ist, kehrt die Methode stillschweigend zurück. Falls die Methode einen
Wert zurückgibt, wird eine SecurityException ausgegeben.
Sie müssen Methoden aufheben, die Aktionen mit stillschweigend
zurückkehrenden Methoden steuern. Sie können dies durch
Implementieren einer Methode public void erreichen.
2 Ordnen Sie Ihrem Sicherheits-Manager die betreffenden Benutzer zu.
Verwenden Sie die gespeicherten Systemprozeduren
add_user_security_manager, update_user_security_manager und
delete_user_security_manager, um einem Benutzer Sicherheits-
Manager zuzuordnen. Wenn Sie z.B. die Klasse
MeinSicherheitsManager einem Benutzer als Sicherheits-Manager
zuordnen wollen, würden Sie den folgenden Befehl ausführen.
call dbo.add_user_security_manager(
Benutzername, ’MeinSicherheitsManager’, NULL )
Mit der folgenden Klasse können Sie das Lesen aus Dateien zulassen, jedoch
das Schreiben untersagen:
public class MeinSicherheitsManager extends
SecurityManager
{ public void checkRead(FileDescriptor) {}
public void checkRead(String) {}
public void checkRead(String, Object) {}
}
Die Methoden SecurityManager.checkWrite werden nicht aufgehoben und
verhindern Schreibvorgänge in den Dateien. Die Methoden checkRead
kehren stillschweigend zurück und lassen die Aktion zu.
129

So werden Java-Objekte gespeichert
So werden Java-Objekte gespeichert
Hinweise
130
Java-Werte werden in serialisierter Form gespeichert. Das bedeutet, dass
jede Zeile folgende Informationen enthält:
♦ Einen Versionsbezeichner
♦ Einen Bezeichner für die Klasse (oder Unterklasse), die gespeichert wird
♦ Die Werte von nicht-statischen, nicht-zeitweiligen Feldern in der Klasse
♦ Andere Overhead-Informationen
Die Klassendefinition wird nicht für jede Zeile gespeichert. Anstelle dessen
enthält der Bezeichner eine Referenz auf die Klassendefinition, die nur
einmal gehalten wird.
Sie können Java-Objekte verwenden, ohne im Detail zu wissen, wie diese
Elemente zusammenwirken, aber die Art der Speicherung dieser Objekte hat
einige Auswirkungen auf die Verarbeitungsleistung. Daher werden diese
Informationen hier etwas genauer ausgeführt.
♦ Plattenspeicher Der Overhead pro Zeile ist 10 bis 15 Byte. Falls die
Klasse nur über eine Variable verfügt, kann der erforderliche Overhead
dem für die Variable ähneln. Falls die Klasse viele Variablen umfasst,
kann der Overhead vernachlässigt werden.
♦ Performance Wenn Sie einen Java-Wert einfügen oder aktualisieren,
muss die Java VM ihn serialisieren. Jedes Mal, wenn ein Java-Wert in
einer Abfrage abgerufen wird, muss er von der VM deserialisiert
werden. Dies kann bedeutende Performanceeinbußen verursachen.
Sie können die Performanceeinbußen für Abfragen vermeiden, indem
Sie berechnete Spalten verwenden.
♦ Indizieren Indizes auf Java-Spalten sind nicht sehr selektiv und bieten
nicht die Performancevorteile wie Indizes auf einfachen SQL-
Datentypen.
♦ Serialisierung Wenn eine Klasse eine readObject- oder writeObject-
Methode hat, wird diese beim Serialisieren oder Deserialisieren der
Instanz aufgerufen. Der Einsatz einer readObject- oder writeObject-
Methode kann sich auf die Performance auswirken, weil die Java VM
aufgerufen wird.

Java-Objekte und Klassenversionen
Zugriff auf Zeilen,
wenn eine Klasse
aktualisiert wird
Unzugängliche
Objekte
Kapitel 4 Java in der Datenbank benutzen
Java-Objekte, die in der Datenbank gespeichert werden, sind beständig - d.h.
sie bestehen, auch wenn kein Programmcode läuft. Das bedeutet, dass Sie
folgende Aktionen ausführen können:
1 Installieren Sie eine Klasse.
2 Tabelle mit dieser Klasse als Datentyp für eine Spalte erstellen
3 Zeilen in die Tabelle einfügen
4 Neue Version der Klasse installieren
Funktionsweise der bestehenden Zeilen mit der neuen Version der Klasse
Adaptive Server Anywhere sieht eine Form der Evidenzhaltung von
Klassenversionen vor, die es ermöglicht, dass die neue Klasse mit den alten
Zeilen arbeiten kann. Die Regeln für den Zugriff auf diese älteren Werte
lauten wie folgt:
♦ Wenn ein serialisierbares Feld in der alten Version der Klasse vorhanden
ist, aber in der neuen Version fehlt oder nicht serialisierbar ist, wird das
Feld ignoriert.
♦ Wenn ein serialisierbares Feld in der neuen Version der Klasse
vorhanden ist, aber in der alten Version fehlt oder nicht serialisierbar
war, wird das Feld auf einen Standardwert initialisiert. Der Standardwert
ist 0 für native Typen, "false" für Boolesche Werte, und "NULL" für
Objektreferenzen.
♦ Wenn eine Überklasse der alten Version vorhanden war, die nicht eine
Überklasse der neuen Version ist, werden die Daten für diese Überklasse
ignoriert.
♦ Wenn eine Überklasse der neuen Version vorhanden ist, die nicht eine
Überklasse der alten Version war, werden die Daten für diese
Überklasse auf Standardwerte initialisiert.
♦ Wenn ein serialisierbares Feld zwischen der älteren Version und der
neueren Version den Typ ändert, wird das Feld auf Standardwerte
initialisiert. Typenkonvertierungen werden nicht unterstützt - dies ist
kompatibel mit der Sun Microsystems-Serialisierung.
Ein serialisiertes Objekt ist nicht zugänglich, wenn die Klasse des Objekts
oder eine ihrer Überklassen zu irgendeinem Zeitpunkt aus der Datenbank
entfernt wurde. Dieses Verhalten ist kompatibel mit der Sun Microsystems-
Serialisierung.
131

So werden Java-Objekte gespeichert
Objekte zwischen
Datenbanken
verschieben
Wann die neue
Klasse benutzt
wird
132
Diese Änderungen machen die Verschiebung von Objekten zwischen
Datenbanken möglich, auch wenn die Versionen der Klassen voneinander
abweichen. Die Verschiebung über Datenbanken kann wie nachstehend
beschrieben erfolgen:
♦ Objekte werden in eine entfernte Datenbank verlegt.
♦ Eine Tabelle mit Objekten wird entladen und dann in eine andere
Datenbank eingelesen.
♦ Eine Logdatei mit Objekten wird übersetzt und in einer anderen
Datenbank angewendet.
Die Klassendefinition für jede Klasse wird durch die VM jeder Verbindung
geladen, wenn die Klasse zum ersten Mal benutzt wird.
Wenn Sie eine Klasse installieren, wird die VM auf Ihrer Verbindung
implizit gestartet. Daher haben Sie sofort Zugang zu der neuen Klasse.
Für andere Verbindungen als diejenige, die die INSTALL-Anweisung
ausführt, wird die neue Klasse das nächste Mal geladen, wenn die VM auf
die Klasse zugreift. Wenn die Klasse von einer VM bereits geladen ist, sieht
diese Verbindung die neue Klasse erst, wenn die VM für diese Verbindung
neu gestartet wird (zum Beispiel mit STOP JAVA und START JAVA).

Java-Datenbankdesign
Kapitel 4 Java in der Datenbank benutzen
Für das Design Ihrer relationalen Datenbanken gibt es einen umfangreichen
theoretischen und praktischen Erfahrungsschatz. Sie können Beschreibungen
zum Design von Entitätsbeziehungen und andere Ansätze nicht nur in
einleitender Form (siehe "Planung Ihrer Datenbank" auf Seite 3 der
Dokumentation ASA SQL-Benutzerhandbuch), sondern auch in der Literatur
für fortgeschrittene Anwender finden.
Eine derartige Vielfalt ist für die Theorie und Praxis von objekt-relationalen
Datenbanken nicht vorhanden, und dies gilt umso mehr für Java-relationale
Datenbanken. Im Folgenden finden Sie einige Vorschläge für den Einsatz
von Java zur Erweiterung des praktischen Einsatzes relationaler
Datenbanken.
Entitäten und Attribute in relationalen und objektorientierten Daten
Beim Design relationaler Datenbanken beschreibt jede Tabelle eine Entität.
Beispiel: In der Beispieldatenbank gibt es Tabellen mit dem Namen
Employee, Customer, Sales_order und Department. Die Attribute dieser
Entitäten werden zu den Spalten der Tabelle: Adressen der Mitarbeiter,
Kundennummern, Bestellnummern, und so weiter. Jede Zeile in der Tabelle
kann als getrennte Instanz der Entität bezeichnet werden - ein bestimmter
Mitarbeiter, eine Bestellung eine Abteilung.
Beim objektorientierten Programmieren beschreibt jede Klasse eine Entität,
und die Methoden und Felder dieser Klasse beschreiben die Attribute der
Entität. Jede Instanz der Klasse (jedes Objekt) enthält eine eigene Instanz
der Entität.
Es scheint daher unnatürlich, dass relationale Spalten auf Java-Klassen
basieren. Eine natürlichere Entsprechung liegt zwischen Tabellen und
Klassen vor.
Entitäten und Attribute in der realen Welt
Die Unterscheidung zwischen Entität und Attribut scheint klar, aber bei
näherem Hinsehen zeigt sich, dass sie in der Praxis nicht ganz so eindeutig
ausfällt.
♦ Eine Adresse kann als Attribut eines Kunden gesehen werden, ist aber
auch eine Entität, die als eigene Attribute die Straße, Stadt etc. hat.
♦ Ein Preis kann als Attribut eines Produkts gesehen werden, ist aber auch
eine Entität mit den Attributen "Summe" und "Währung".
133

Java-Datenbankdesign
134
Der Sinn der objektrelationalen Datenbank ist genau in diesem Faktum zu
suchen, nämlich dass es zwei Möglichkeiten gibt, Entitäten auszudrücken.
Sie können einige Entitäten als Tabellen, und andere Entitäten als Klassen in
einer Tabelle ausdrücken. Im nächsten Abschnitt wird ein Beispiel erläutert.
Einschränkungen der relationalen Datenbanken
Stellen Sie sich ein Versicherungsunternehmen vor, das Überblick über seine
Kunden behalten will. Ein Kunde kann als Entität angesehen werden, sodass
es sinnvoll ist, eine einzelne Tabelle zu entwerfen, in der alle Kunden der
Gesellschaft enthalten sind.
Nun werden aber von Versicherungsgesellschaften verschiedene Arten von
Kunden betreut. Es gibt die Policeninhaber, die Begünstigten und Personen,
die die Prämien zu bezahlen haben. Für alle diese Kundentypen benötigt die
Versicherungsgesellschaft verschiedene Informationen. Für den
Begünstigten braucht sie eigentlich nicht viel mehr als die Adresse. Für den
Policeninhaber sind Informationen über den Gesundheitszustand
erforderlich. Für den Prämienzahler braucht man zusätzliche
Finanzinformationen für die steuerlichen Aspekte.
Ist es besser, diese unterschiedlichen Kundentypen als unterschiedliche
Entitäten zu behandeln, oder als Attribut des Kunden? Bei beiden Ansätzen
gibt es Einschränkungen:
♦ Wenn für jeden Kundentyp eine eigene Tabelle eingerichtet wird, kann
das Datenbankdesign sehr unübersichtlich werden, und beim Abfragen
von Informationen zu allen Kunden müssen mehrere Tabellen
durchsucht werden.
♦ Und wenn eine einzelne Kundentabelle verwendet wird, ist es nicht
einfach, sicherzustellen, dass für jeden Kunden die richtigen
Informationen eingegeben werden. Das Einrichten von Spalten, die für
einige Kunden nullwertfähig sind, für andere aber nicht, ermöglicht die
richtige Dateneingabe, erzwingt sie aber nicht. Es gibt in relationalen
Datenbanken keine einfache Methode, das Standardverhalten an ein
Attribut der neuen Dateneingabe zu binden.
Mit Klassen bestimmte Einschränkungen relationaler Datenbanken
überwinden
Sie können eine einzelne Kundentabelle verwenden, wobei für einige
Informationen Java-Klassenspalten benutzt werden, um die Begrenzungen
relationaler Datenbanken zu überwinden.

Kapitel 4 Java in der Datenbank benutzen
Beispiel: Nehmen wir an, Sie brauchen für die Policeninhaber andere
Kontaktinformationen als für die Begünstigten. Sie können dieses Problem
lösen, indem Sie eine Spalte definieren, die auf der Klasse
Kontaktinformation basiert. Dann definieren Sie Klassen mit den Namen
PolicenhalterKontaktdaten und BegünstigterKontaktdaten, die
Unterklassen der Klasse Kontaktdaten sind. Indem Sie neue Kunden nach
ihrem Typ eingeben, können Sie sicherstellen, dass die richtigen
Informationen eingegeben werden.
Abstraktionsebenen für relationale Daten
Daten in einer relationalen Datenbank können nach Zweck kategorisiert
werden. Welche Daten gehören in eine Java-Klasse, und welche sollten
besser in einer einfachen Datentyp-Spalte eingegeben werden?
♦ Spalten für die referenzielle Integrität Primärschlüsselspalten und
Fremdschlüsselspalten haben gemeinsame Identifizierungsnummern.
Diese Identifizierungsnummern können als referenzielle Daten
bezeichnet werden. Ihr Hauptzweck ist die Definition der Struktur der
Datenbank und die Definition der Beziehungen zwischen Tabellen.
Referenzielle Daten gehören im Allgemeinen nicht in Java-Klassen.
Obwohl Sie aus einer Java-Klassenspalte eine Primärschlüsselspalte
machen können, sind Ganzzahlen und andere einfache Datentypen für
diesen Zweck besser geeignet.
♦ Indizierte Daten Spalten, die im Allgemeinen indiziert werden, werden
ebenfalls nicht in Java-Klassen angelegt. Allerdings ist die Trennlinie
zwischen Daten, die indiziert werden sollen, und solchen, bei denen dies
nicht erforderlich ist, eher unscharf.
Bei berechneten Spalten können Sie selektiv ein Java-Feld oder eine
Java-Methode (bzw. auch einen anderen Ausdruck) indizieren. Wenn
Sie eine Java-Klassenspalte definieren und dann feststellen, dass es
sinnvoll wäre, sie auf ein Feld oder eine Methode dieser Spalte zu
indizieren, können Sie berechnete Spalten verwenden, um aus diesem
Feld oder dieser Methode eine eigene Spalte zu erstellen.
$ Weitere Hinweise finden Sie unter "Berechnete Spalten mit Java-
Klassen verwenden" auf Seite 137.
♦ Beschreibende Daten In jeder Zeile gibt es im Allgemeinen auch
beschreibende Daten. Solche Daten werden für die referenzielle
Integrität nicht verwendet, meist nicht indiziert, aber häufig in Abfragen
verwendet. Bei einer Mitarbeitertabelle können dies Daten wie
Einstellungsdatum, Adresse, Vergünstigungen, Gehalt usw. sein. Für
diese Daten kann es häufig von Vorteil sein, wenn sie in weniger
Spalten vom Typ Javaklasse kombiniert werden.
135

Java-Datenbankdesign
136
Java-Klassen sind für die Abstraktion auf einer Ebene zwischen der der
einzelnen relationalen Spalte und der relationalen Tabelle nützlich.

Berechnete Spalten mit Java-Klassen
verwenden
Einsatzbereich
berechneter
Spalten
Berechnete Spalten festlegen
Tabellen mit
berechneten
Spalten erstellen
Kapitel 4 Java in der Datenbank benutzen
Berechnete Spalten sind ein Merkmal, das entwickelt wurde, um das Design
von Java-Datenbanken einfacher zu gestalten, damit Java-Funktionen in
bestehenden Datenbanken besser genutzt werden können, und um die
Performance von Java-Datentypen zu verbessern.
Eine berechnete Spalte ist eine Spalte, deren Werte aus anderen Spalten
ausgewertet werden. Sie können in berechneten Spalten kein INSERT und
kein UPDATE durchführen. Eine UPDATE-Anweisung, die versucht, den
Wert einer berechneten Spalte zu ändern, löst aber Trigger aus, die mit der
Spalte verbunden sind.
Es gibt zwei Haupteinsatzgebiete für berechnete Spalten mit Java-Klassen:
♦ Java-Spalte aufgliedern Wenn Sie eine Spalte mit einem Java-Klassen-
Datentyp erstellen, können Sie mit berechneten Spalten eines der Felder
einer Klasse indizieren. Sie können eine berechnete Spalte hinzufügen,
die den Wert des Feldes enthält, und daher einen Index auf dieses Feld
erstellen.
♦ Java-Spalte einer relationalen Tabelle hinzufügen Wenn Sie einige
der Funktionen von Java-Klassen nutzen, aber in die bestehende
Datenbank so wenig wie möglich eingreifen wollen, können Sie Java-
Spalten als berechnete Spalten hinzufügen, die ihre Werte aus anderen
Spalten in der Tabelle beziehen.
Berechnete Spalten werden in den Anweisungen CREATE TABLE oder
ALTER TABLE deklariert.
Die folgende CREATE TABLE-Anweisung wird benutzt, um die Tabelle
product in den Java-Beispieltabellen zu erstellen:
CREATE TABLE product
(
id INTEGER NOT NULL,
JProd asademo.Product NOT NULL,
name CHAR(15) COMPUTE ( JProd>>name ),
PRIMARY KEY ("id")
)
137

Berechnete Spalten mit Java-Klassen verwenden
Berechnete
Spalten zu
Tabellen
hinzufügen
Ausdruck für
berechnete
Spalten ändern
138
Die folgende Anweisung ändert die Tabelle product, indem eine weitere
berechnete Spalte hinzugefügt wird:
ALTER TABLE product
ADD inventory_Value INTEGER
COMPUTE ( JProd.quantity * JProd.unit_price )
Sie können mit der Anweisung ALTER TABLE den Ausdruck ändern, der in
einer berechneten Spalte verwendet wird. Die folgende Anweisung ändert
den Ausdruck, auf der eine berechnete Spalte basiert:
ALTER TABLE Tabellenname
ALTER Spaltenname SET COMPUTE ( Ausdruck )
Die Spalte wird neu berechnet, wenn diese Anweisung ausgeführt wird.
Wenn der neue Ausdruck ungültig ist, schlägt die ALTER TABLE-
Anweisung fehl.
Die folgende Anweisung macht aus einer berechneten Spalte wieder eine
normale Spalte.
ALTER TABLE Tabellenname
ALTER Spaltenname DROP COMPUTE
Wenn Sie diese Anweisung ausführen, werden die Werte in der Spalte nicht
verändert.
Berechnete Spalten einfügen und aktualisieren
Berechnete Spalten haben Auswirkungen auf die Gültigkeit von INSERT
und UPDATE. Die Tabelle jdba.product in den Java-Beispieltabellen hat
eine berechnete Spalte (name), die wir zur Erläuterung dieses Problemfeldes
heranziehen. Die Tabellendefinition lautet wie folgt:
CREATE TABLE "jdba"."product"
(
"id" INTEGER NOT NULL,
"JProd" asademo.Product NOT NULL,
"name" CHAR(15) COMPUTE( JProd.name ),
PRIMARY KEY ("id")
)
♦ Keine direkten Einfügungen oder Aktualisierungen Sie können in
eine berechnete Spalte keinen Wert direkt einfügen. Die folgende
Anweisung schlägt mit der Fehlermeldung Duplikat beim Einfügen in
eine Spalte fehl.
-- Falsche Anweisung
INSERT INTO PRODUCT (id, name)
VALUES( 3006, ’bad insert statement’ )

Kapitel 4 Java in der Datenbank benutzen
Eine UPDATE-Anweisung kann eine berechnete Spalte nicht direkt
aktualisieren.
♦ Auflisten von Spaltennamen Sie müssen in INSERT-Anweisungen für
Tabellen mit berechneten Spalten immer die Spaltennamen angeben. Die
folgende Anweisung schlägt mit der Fehlermeldung Falsche Anzahl von
Werten für INSERT fehl:
-- Falsche Anweisung
INSERT INTO PRODUCT
VALUES( 3007,new asademo.Product() )
Anstelle dessen müssen Sie die Spalten wie folgt auflisten:
INSERT INTO PRODUCT( id, JProd )
VALUES( 3007,new asademo.Product() )
♦ Trigger Sie können Trigger für eine berechnete Spalte definieren, damit
ein INSERT oder UPDATE in diesen Spalten den Trigger auslöst.
Zeitpunkt der Neuberechnung von Spalten
Die berechneten Spalten werden unter folgenden Bedingungen neu
berechnet:
♦ Eine Spalte wird gelöscht, hinzugefügt oder umbenannt.
♦ Die Spalte wird umbenannt.
♦ Der Datentyp oder die COMPUTE-Klausel einer Spalte wird geändert.
♦ Eine Zeile wird eingefügt.
♦ Eine Zeile wird aktualisiert.
Berechnete Spalten werden nicht neu berechnet, wenn sie abgefragt werden.
Wenn Sie einen Ausdruck verwenden, der zeitabhängig ist oder in anderer
Weise vom Status der Datenbank abhängt, bringt die berechnete Spalte
möglicherweise nicht das gewünschte Ergebnis.
139

Speicher für Java konfigurieren
Speicher für Java konfigurieren
Datenbank und
Verbindung
Speicherbelegung
140
In diesem Abschnitt wird beschrieben, welche Speichererfordernisse für Java
in der Datenbank bestehen, und wie Sie Ihren Server so einrichten, dass diese
Anforderungen erfüllt werden.
Die Java VM benötigt viel Cachespeicher.
$ Hinweise zur Optimierung des Caches finden Sie unter "Performance
durch den Einsatz eines Cachespeichers steigern" auf Seite 170 der
Dokumentation ASA SQL-Benutzerhandbuch.
Die Java VM benutzt Speicher sowohl pro Datenbank, als auch pro
Verbindung.
♦ Der erforderliche Speicher für die Datenbank ist nicht auslagerbar: Die
Seiten können nicht auf die Festplatte ausgelagert werden. Sie müssen in
den Servercache passen. Dieser Typ des Speichers ist nicht für den
Server vorgesehen, sondern für jede Datenbank. Wenn Sie die
Cacheerfordernisse berechnen wollen, müssen Sie die Erfordernisse für
jede Datenbank zusammenzählen, die auf dem Server laufen soll.
♦ Der erforderliche Speicher pro Verbindung ist auslagerbar, aber nur als
Einheit. Der erforderliche Speicher für eine Verbindung ist entweder
komplett im Cache oder komplett in einer temporären Datei.
Java in der Datenbank benötigt Speicher für verschiedene Zwecke:
♦ Wenn Java auf einem laufenden Server zum ersten Mal benutzt wird,
holt das System die VM in den Speicher. Die VM braucht dort ca. 1,5
MByte Platz. Dieser Speicherbedarf wird in den erforderlichen Speicher
für die Datenbank eingerechnet. Eine zusätzliche VM wird für jede
Datenbank geladen, die Java benutzt.
♦ Für jede Verbindung, die Java benutzt, wird eine neue Instanz der VM
für diese Verbindung geladen. Die neue Instanz benötigt ca. 200 KByte
pro Verbindung.
♦ Jede in einer Java-Anwendung benutzte Klassendefinition wird in den
Speicher geladen. Sie wird im Datenbankspeicher untergebracht:
Getrennte Kopien sind für die einzelnen Verbindungen nicht
erforderlich.
♦ Jede Verbindung benötigt eine arbeitende Gruppe von Java-Variablen
und Anwendungs-Stack-Speicherplatz für Methodenargumente etc.).

Verwaltung des
Speichers
VM starten und
stoppen
Kapitel 4 Java in der Datenbank benutzen
Sie können die Speicherbelegung wie folgt steuern:
♦ Gesamtcachegröße setzen Sie müssen die Größe des Caches so
setzen, dass alle Erfordernisse des nicht auslagerbaren Speichers erfüllt
werden.
Die Cachegröße wird mit der Befehlszeilenoption -c beim Serverstart
gesetzt.
In vielen Fällen reicht eine Cachegröße von 8 MByte aus.
♦ Speicher für den Namensbereich setzen Der Java-Namensbereich ist
die Maximalgröße der Datenbankspeichererfordernisse in Bytes.
Sie können diesen Wert mit der Option JAVA_NAMESPACE_SIZE
setzen. Diese Option ist global und kann nur von einem Benutzer mit
DBA-Berechtigung gesetzt werden.
♦ Heap-Größe setzen Diese Option JAVA_HEAP_SIZE setzt die
Maximalgröße des pro Verbindung erforderlichen Speichers in Byte.
Diese Option kann für einzelne Verbindungen gesetzt werden, betrifft
aber den für andere Benutzer verfügbaren Speicher und darf daher nur
von einem Benutzer mit DBA-Berechtigung verwendet werden.
Sie können nicht nur Speicherparameter für Java setzen, sondern auch die
VM entladen, wenn Java nicht benutzt wird, indem Sie die Anweisung STOP
JAVA aufrufen. Nur ein Benutzer mit DBA-Berechtigung kann diese
Anweisung ausführen. Die Syntax ist einfach:
STOP JAVA
Die VM wird geladen, wenn ein Java-Vorgang ausgeführt wird. Wenn Sie
die VM explizit laden wollen, damit sie für Java-Vorgänge bereit steht,
können Sie folgende Anweisung ausführen:
START JAVA
141

Speicher für Java konfigurieren
142

KAPITEL 5
Datenzugriff über JDBC
Über dieses
Kapitel
Inhalt
In diesem Kapitel wird beschrieben, wie JDBC für den Zugriff auf Daten
eingesetzt werden kann.
JDBC kann sowohl aus Clientanwendungen als auch innerhalb einer
Datenbank eingesetzt werden. Java-Klassen, die JDBC verwenden, bieten
eine leistungsstärkere Alternative zu gespeicherten Prozeduren in SQL für
die Einbeziehung von Programmierlogik in die Datenbank.
Thema Seite
Überblick über JDBC 144
jConnect-JDBC-Treiber verwenden 150
JDBC-ODBC-Brücke verwenden 155
JDBC-Verbindungen herstellen 157
JDBC für den Zugriff auf Daten verwenden 165
Verteilte Anwendungen erstellen 174
143

Überblick über JDBC
Überblick über JDBC
JDBC und
Adaptive Server
Anywhere
JDBC-Ressourcen
144
JDBC bietet eine SQL-Schnittstelle für Java-Anwendungen: Wenn Sie auf
relationale Daten von Java zugreifen wollen, tun Sie dies über JDBC-
Aufrufe.
Dieses Kapitel ist keine detailgenaue Anleitung für die JDBC-
Datenbankschnittstelle, sondern liefert einige einfache Beispiele zur
Einführung von JDBC und zur Illustration, wie sie beim Client und in der
Datenbank eingesetzt werden kann.
$ Die Beispiele veranschaulichen die unterschiedlichen Funktionen beim
Einsatz von JDBC in Adaptive Server Anywhere. Weitere Hinweise zum
Programmieren von JDBC finden Sie in jedem beliebigen JDBC-
Programmierhandbuch.
Sie können JDBC auf folgende Weise mit Adaptive Server Anywhere
verwenden:
♦ JDBC auf dem Client Java-Clientanwendungen können JDBC-Aufrufe
in Adaptive Server Anywhere ausführen. Die Verbindung erfolgt über
einen JDBC-Treiber. SQL Anywhere Studio enthält zwei JDBC-Treiber:
den jConnect-Treiber für Anwendungen in reinem Java sowie eine
JDBC-ODBC-Brücke.
In diesem Kapitel bezieht sich der Ausdruck Clientanwendung sowohl
auf Anwendungen, die auf dem Rechner des Benutzers laufen, als auch
auf Mittelschicht-Anwendungsserver.
♦ JDBC in der Datenbank In einer Datenbank installierte Java-Klassen
können JDBC-Aufrufe ausführen, um mit Hilfe eines internen JDBC-
Treibers auf Daten in der Datenbank zuzugreifen und diese zu ändern.
♦ Erforderliche Software Sie benötigen TCP/IP für den Sybase jConnect-
Treiber.
Der Sybase jConnect Treiber kann abhängig von Ihrer Installation von
Adaptive Server Anywhere bereits verfügbar sein.
$ Weitere Hinweise den jConnect-Treiber und seinen Standort finden Sie
unter "Die Dateien des jConnect-Treibers" auf Seite 150.
♦ Beispiel-Quellcode Quellcode für die Beispiele in diesem Kapitel
finden Sie in der Datei Samples\ASA\Java\JDBCExamples.java in Ihrem
SQL Anywhere-Verzeichnis.
$ Hinweise zur Installation von Java-Beispielen, einschließlich der
Klasse JDBCExamples, finden Sie unter "Java-Beispiele einrichten"
auf Seite 94.

JDBC-Treiber wählen
JDBC-Programmstruktur
Kapitel 5 Datenzugriff über JDBC
Für Adaptive Server Anywhere werden zwei JDBC-Treiber bereitgestellt:
♦ jConnect Dieser Treiber ist eine 100% reine Java-Implementierung
des Treiber. Er kommuniziert mit Adaptive Server Anywhere über das
TDS-Client/Server-Protokoll.
♦ JDBC-ODBC-Brücke Dieser Treiber kommuniziert mit Adaptive
Server Anywhere über das Command Sequence-Client/Server-Protokoll.
Sein Verhalten ist mit ODBC-, Embedded SQL- und OLE DB-
Anwendungen konsistent.
Bei der Auswahl des geeigneten Treibers sollten die folgenden Faktoren
beachtet werden:
♦ Features Beide Treiber sind JDK 2-kompatibel. Die JDBC-ODBC-
Brücke bietet vollständig abrollbare Cursor, die in jConnect nicht
verfügbar sind.
♦ "Pure Java" Der jConnect-Treiber ist eine reine Java-Lösung. Die
JDBC-ODBC-Brücke benötigt den Adaptive Server Anywhere ODBC-
Treiber und ist keine reine Java-Lösung.
♦ Performance Die JDBC-ODBC-Brücke bietet bessere Performance
für die meisten Einsatzbereiche als der jConnect-Treiber.
♦ Kompatibilität Das vom jConnect-Treiber verwendete TDS-Protokoll
wird mit Adaptive Server Enterprise gemeinsam genutzt. Einige Aspekte
des Verhaltens dieses Treibers werden durch das Protokoll bestimmt und
sind so konfiguriert, dass die Kompatibilität mit Adaptive Server
Enterprise gewährleistet bleibt.
Beide Treiber sind für Windows 95/98/Me und Windows NT/2000/XP sowie
die unterstützten UNIX- und Linux-Betriebssystemen verfügbar. Sie sind
nicht für NetWare oder Windows CE erhältlich.
In JDBC-Anwendungen sind folgende Abläufe typisch:
1 Verbindungsobjekt erstellen Mit dem Aufruf der getConnection-
Klassenmethode der Klasse DriverManager wird ein Connection-
Objekt erstellt, das eine Verbindung mit einer Datenbank einrichtet.
2 Statement-Objekt erstellen Das Objekt Connection erstellt ein
Statement-Objekt.
145

Überblick über JDBC
146
3 SQL-Anweisung übergeben Eine SQL-Anweisung, die in der
Datenbankumgebung ausgeführt werden soll, wird an das Statement-
Objekt übergeben. Wenn die Anweisung eine Abfrage ist, wird durch
diese Aktion ein ResultSet-Objekt zurückgegeben.
Das ResultSet-Objekt enthält die von der SQL-Anweisung
zurückgegebenen Daten, gibt jedoch jeweils nur eine Zeile aus (ähnlich
wie die Arbeitsweise des Cursors).
4 Schleife über die Zeilen der Ergebnismenge Die next-Methode des
Objekts ResultSet führt zwei Aktionen aus:
♦ Die aktuelle Zeile (die Zeile in der über das Objekt ResultSet
ausgegebenen Ergebnismenge), wird eine Zeile weitergeschoben.
♦ Ein Boolescher Wert wird zurückgegeben (TRUE/FALSE), der
angibt, ob eine Zeile vorhanden ist, zu der weitergeschoben werden
kann.
5 Für jede Zeile Werte abrufen Für jede Zeile im ResultSet-Objekt
werden Werte entweder mit dem Namen oder der Position der Spalte
abgerufen. Sie können die Methode getDate verwenden, um den Wert
einer Spalte in der aktuellen Zeile zu beziehen.
Java-Objekte können JDBC-Objekte verwenden, um mit einer Datenbank zu
interagieren und Daten für die eigene Verwendung abzurufen, und zwar für
die eigene Verarbeitung oder für den Einsatz in anderen Abfragen.
JDBC-Funktionen in der Datenbank
Die Version von JDBC, die Sie von Java in der Datenbank benutzen können,
wird von der JDK-Version bestimmt, die für die Datenbank eingerichtet
wurde.
♦ Wenn Ihre Datenbank mit JDK 1.2 oder JDK 1.3 initialisiert wurde,
können Sie die JDBC 2.0 API verwenden.
$ Hinweise zum Upgrade der Datenbanken auf JDK 1.2 oder JDK
1.3 finden Sie unter "ALTER DATABASE-Anweisung" auf Seite 224
der Dokumentation ASA SQL-Referenzhandbuch oder "Upgrade einer
Datenbank mit dem Befehlszeilenprogramm ""dbupgrad""" auf
Seite 583 der Dokumentation ASA Datenbankadministration.
♦ Falls Ihre Datenbank mit JDK 1.1 initialisiert wurde, können Sie die
Funktionen von JDBC 1.2 verwenden. Der interne JDBC-Treiber für
JDK 1.1 (asajdbc) stellt einige Funktionen von JDBC 2.0 von
serverseitigen Java-Anwendungen zur Verfügung, bietet aber keine volle
JDBC 2.0-Unterstützung.

Kapitel 5 Datenzugriff über JDBC
$ Weitere Hinweise finden Sie unter "JDBC 2.0-Funktionen von
JDK 1.1-Datenbanken aus benutzen" auf Seite 147.
JDBC 2.0-Funktionen von JDK 1.1-Datenbanken aus benutzen
Einschränkungen
von JDBC 2.0
In diesem Abschnitt wird beschrieben, wie JDBC 2.0-Funktionen von
Datenbanken aus benutzt werden, die mit JDK 1.1 initialisiert wurden. In
vielen Fällen ist es besser, Ihre Version von Java in der Datenbank auf 1.3
umzustellen.
Bei Datenbanken, die mit JDK 1.1 initialisiert wurden, enthält das Paket
sybase.sql.ASA Funktionen, die Teil von JDBC 2.0 sind. Um diese JDBC
2.0-Funktionen verwenden zu können, müssen Sie Ihre JDBC-Objekte in die
entsprechenden Klassen im Paket sybase.sql.ASA und nicht im Paket
java.sql einbauen. Klassen, die als java.sql deklariert sind, bleiben auf die
JDBC 1.2-Funktionen beschränkt.
Die Klassen in sybase.sql.ASA sind:
JDBC-Klasse Interne Sybase-Treiberklasse
java.sql.Connection sybase.sql.ASA.SAConnection
java.sql.Statement sybase.sql.ASA.SAStatement
java.sql.PreparedStatement sybase.sql.ASA.SAPreparedStatement
java.sql.CallableStatement sybase.sql.ASA.SACallableStatement
java.sql.ResultSetMetaData sybase.sql.ASA.SAResultSetMetaData
java.sql.ResultSet sybase.sql.SAResultSet
java.sql.DatabaseMetaData sybase.sql.SADatabaseMetaData
Die folgende Funktion bietet ein ResultSetMetaData-Objekt für eine
vorbereitete Anweisung ohne das ResultSet oder das Ausführen der
Anweisung nötig sind. Diese Funktion ist nicht Teil des Standards JDBC 1.2.
ResultSetMetaData
sybase.sql.ASA.SAPreparedStatement.describe()
Der folgende Code ruft die vorherige Zeile in einer Ergebnismenge ab, eine
Funktion, die in JDBC 1.2 nicht unterstützt wird:
import java.sql.*;
import sybase.sql.asa.*;
ResultSet rs;
// hier mehr Code
( ( sybase.sql.asa.SAResultSet)rs ).previous();
Die folgenden Klassen sind Teil der Kernschnittstelle von JDBC 2.0, stehen
aber im Paket sybase.sql.ASA nicht zur Verfügung:
147

Überblick über JDBC
148
♦ java.sql.Blob
♦ java.sql.Clob
♦ java.sql.Ref
♦ java.sql.Struct
♦ java.sql.Array
♦ java.sql.Map
Die folgenden Kernfunktionen von JDBC 2.0 sind im Paket sybase.sql.ASA
nicht verfügbar:
Klasse in
sybase.sql.ASA
Fehlende Funktionen
SAConnection java.util.Map getTypeMap()
void setTypeMap( java.util.Map map )
SAPreparedStatement void setRef( int pidx, java.sql.Ref r )
void setBlob( int pidx, java.sql.Blob b )
void setClob( int pidx, java.sql.Clob c )
void setArray( int pidx, java.sql.Array a )
SACallableStatement Object getObject( pidx, java.util.Map map )
java.sql.Ref getRef( int pidx )
java.sql.Blob getBlob( int pidx )
java.sql.Clob getClob( int pidx )
java.sql.Array getArray( int pidx )
SAResultSet Object getObject( int cidx, java.util.Map map )
java.sql.Ref getRef( int cidx )
java.sql.Blob getBlob( int cidx )
java.sql.Clob getClob( int cidx )
java.sql.Array getArray( int cidx )
Object getObject( String cName, java.util.Map map )
java.sql.Ref getRef( String cName )
java.sql.Blob getBlob( String cName )
java.sql.Clob getClob( String cName )
java.sql.Array getArray( String cName )

Kapitel 5 Datenzugriff über JDBC
Unterschiede zwischen client- und serverseitigen JDBC-
Verbindungen
Der Unterschied zwischen dem JDBC-Treiber auf dem Client bzw. auf dem
Datenbankserver liegt darin, dass eine Verbindung mit der
Datenbankumgebung hergestellt wird.
♦ Clientseitig Beim clientseitigen JDBC-Treiber erfordert die Herstellung
einer Verbindung den Sybase jConnect JDBC- Treiber oder der JDBC-
ODBC-Brücke von Adaptive Server Anywhere. Die Übergabe von
Argumenten an DriverManager.getConnection richtet die Verbindung
ein. Die Datenbankumgebung ist von der Perspektive der
Clientanwendung aus eine externe Anwendung.
♦ Serverseitig Wenn JDBC innerhalb des Datenbankservers eingesetzt
wird, ist bereits eine Verbindung vorhanden. Der Wert
jdbc:default:connection wird an DriverManager.getConnection
übergeben, damit die JDBC-Anwendung die Möglichkeit erhält,
innerhalb der aktuellen Benutzerverbindung zu arbeiten. Dies ist ein
schneller, effizienter und sicherer Vorgang, weil die Clientanwendung
die Sicherheitsprüfung der Datenbank zur Herstellung der Verbindung
bereits bestanden hat. Benutzer-ID und Kennwort wurden angegeben
und brauchen nicht noch einmal angegeben zu werden. Der interne
JDBC-Treiber kann nur mit der Datenbank der aktuellen Verbindung
eine Verbindung herstellen.
JDBC-Klassen können so geschrieben werden, dass sie auf der Client- und
auf der Serverseite ausgeführt werden, indem Sie eine einzige bedingte
Anweisung für die Angabe des URL verwenden. Eine externe Verbindung
erfordert den Rechnernamen und die Portnummer, während die interne
Verbindung jdbc:default:connection benötigt.
149

jConnect-JDBC-Treiber verwenden
jConnect-JDBC-Treiber verwenden
150
Wenn Sie JDBC von einer Clientanwendung oder einem Applet aus
verwenden wollen, brauchen Sie den jConnect JDBC-Treiber, um eine
Verbindung mit Datenbanken von Adaptive Server Anywhere herstellen zu
können.
jConnect gehört zum Lieferumfang von SQL Anywhere Studio. Wenn Sie
Adaptive Server Anywhere als Teil eines anderen Paketes erhalten haben,
besteht die Möglichkeit, dass jConnect nicht enthalten ist. Sie brauchen
jConnect, um JDBC von Clientanwendungen aus einsetzen zu können. Sie
können JDBC in der Datenbank ohne jConnect verwenden.
Die Dateien des jConnect-Treibers
CLASSPATH für
jConnect einrichten
Der jConnect JDBC-Treiber ist in einer Reihe von Verzeichnissen unter
Sybase\Shared installiert. Es werden zwei Versionen von jConnect
bereitgestellt:
♦ jConnect 4.5 Diese Version von jConnect ist für die Entwicklung von
JDK 1.1-Anwendungen vorgesehen. jConnect 4.5 ist im Verzeichnis
Sybase\Shared\jConnect-4_5 installiert.
jConnect 4.5 wird als Gruppe von Klassen geliefert.
♦ jConnect 5.5 Diese Version von jConnect ist für die Entwicklung von
JDK 1.2-Anwendungen vorgesehen. jConnect 5.5 ist im Verzeichnis
Sybase\Shared\jConnect-5_5 installiert.
jConnect 5.5 wird als jar-Datei mit dem Namen jconn2.jar geliefert.
Beispiele in diesem Kapitel verwenden jConnect 5.5. Benutzer von jConnect
4.5 müssen die entsprechenden Anpassungen vornehmen.
Damit Ihre Anwendung "jConnect" verwenden kann, müssen die jConnect-
Klassen beim Kompilieren und Ausführen in die Umgebungsvariable
CLASSPATH einbezogen sein, sodass der Java-Compiler und die Java-
Machine die notwendigen Dateien ausfindig machen können.
Der folgende Befehl fügt den jConnect 5.5-Treiber in eine vorhandene
CLASSPATH-Umgebungsvariable ein, wobei Suchpfad Ihr Sybase\Shared–
Verzeichnis ist.
set classpath=%classpath%;Suchpfad\jConnect-5_5\classes\jconn2.jar
Mit dem folgenden Befehl wird der jConnect 4.5-Treiber einer vorhandenen
CLASSPATH-Umgebungsvariablen hinzugefügt:
set classpath=%classpath%;Suchpfad\jConnect-4_5\classes

jConnect-Klassen
importieren
Kapitel 5 Datenzugriff über JDBC
Die Klassen in jConnect befinden sich alle im Paket com.sybase.
Wenn Sie jConnect 5.5 verwenden, muss Ihre Anwendung auf Klassen in
com.sybase.jdbc2.jdbc zugreifen. Sie müssen diese Klassen am Anfang
einer jeden Quelldatei importieren:
import com.sybase.jdbc2.jdbc.*
Wenn Sie jConnect 4.5 verwenden, befinden sich die Klassen in
com.sybase.jdbc. Sie müssen diese Klassen am Anfang einer jeden
Quelldatei importieren:
import com.sybase. jdbc.*
jConnect-Systemobjekte in einer Datenbank installieren
Wenn Sie mit jConnect auf Systemtabellendaten zugreifen wollen
(Datenbank-Metadaten), müssen Sie die jConnect-Systemobjekte Ihrer
Datenbank hinzufügen.
Die jConnect-Systemobjekte werden standardmäßig jeder neuen Datenbank
hinzugefügt. Sie können die jConnect-Objekte der Datenbank beim Erstellen,
beim Upgrade oder zu einem späteren Zeitpunkt hinzufügen.
Sie können die jConnect-Systemobjekte über Sybase Central oder über
Interactive SQL installieren.
v So fügen Sie jConnect-Systemobjekte einer Datenbank hinzu
(Sybase Central):
1 Stellen Sie von Sybase Central aus als Benutzer mit DBA-Berechtigung
eine Verbindung her.
2 Im linken Fensterausschnitt von Sybase Central rechtsklicken Sie auf
das Datenbanksymbol und wählen "jConnect Metadatenunterstützung
neu installieren" aus dem Einblendmenü.
v So fügen Sie jConnect-Systemobjekte einer Datenbank hinzu
(Interactive SQL):
♦ Stellen Sie über Interactive SQL als Benutzer mit DBA-Berechtigung
eine Verbindung her und geben Sie im Ausschnitt für die Eingabe der
SQL-Anweisungen folgenden Befehl ein:
read Suchpfad\scripts\jcatalog.sql
wobei Suchpfad Ihr SQL Anywhere-Verzeichnis ist.
151

jConnect-JDBC-Treiber verwenden
jConnect-Treiber laden
152
Tipp
Sie können die jConnect-Systemobjekte einer Datenbank auch über die
Befehlszeile hinzufügen: Die Eingabe bei der Eingabeaufforderung lautet
wie folgt:
dbisql -c "uid=Benutzer;pwd=Kennwort"
Suchpfad\scripts\jcatalog.sql
Dabei gilt: Benutzer und Kennwort gehören zu einem Benutzer mit DBA-
Berechtigung, und Suchpfad ist Ihr SQL Anywhere-Verzeichnis.
Bevor Sie jConnect in Ihrer Anwendung benutzen können, müssen Sie die
Treiber laden, indem Sie folgende Anweisung eingeben.
Class.forName("com.sybase.jdbc2.jdbc.SybDriver").newInstance();
Einem Server einen URL liefern
Mit der Methode newInstance werden Probleme in einigen Browsern
vermieden.
Um per jConnect eine Verbindung mit einer Datenbank herzustellen, müssen
Sie einen "Uniform Resource Locator" (URL) für die Datenbank angeben.
Ein Beispiel finden Sie im Abschnitt "Von einer JDBC-Clientanwendung aus
mit jConnect eine Verbindung herstellen" auf Seite 157 Die Anweisung
lautet wie folgt:
StringBuffer temp = new StringBuffer();
// jConnect-Treiber verwenden ...
temp.append("jdbc:sybase:Tds:");
// zur Verbindung mit angegebenem Rechnernamen...
temp.append(_coninfo);
// auf der Standard-Portnummer des ASA...
temp.append(":2638");
// und baue Verbindung auf.
System.out.println(temp.toString());
conn = DriverManager.getConnection(temp.toString() ,
_props );
Der URL wird folgendermaßen zusammengesetzt:
jdbc:sybase:Tds:Rechnername:Portnummer
Die einzelnen Komponenten sind:

Kapitel 5 Datenzugriff über JDBC
♦ jdbc:sybase:Tds Der Sybase jConnect JDBC Treiber unter
Verwendung des TDS-Anwendungsprotokolls
♦ Rechnername Die IP-Adresse oder der Name des Rechners, auf dem
der Server läuft. Wenn Sie eine Verbindung auf demselben Rechner
herstellen, können Sie localhost benutzen, also den aktuellen Rechner.
♦ Portnummer Die Portnummer, an der der Datenbankserver auf
Verbindungsanforderungen wartet. Die Adaptive Server Anywhere
zugewiesene Portnummer ist 2638. Sie sollten diese Nummer
verwenden, es sei denn, es gibt besondere Gründe, dies nicht zu tun.
Die Verbindungszeichenfolge darf nicht länger als 252 Zeichen sein.
Datenbank auf einem Server angeben
Jeder Adaptive Server Anywhere-Server kann mehrere Datenbanken
gleichzeitig laden. Der oben angegebene URL legt einen Server fest, nicht
aber eine Datenbank. Der Verbindungsversuch wird mit der
Standarddatenbank auf dem Server vorgenommen.
Sie können eine bestimmte Datenbank angeben, indem Sie die URL-Angabe
wie folgt erweitern:
Mit dem Parameter
ServiceName
Mit dem Parameter
RemotePWD
jdbc:sybase:Tds:Rechnername:Portnummer?ServiceName=DBN
Das Fragezeichen, gefolgt von einer Reihe von Zuordnungen, ist ein
Standardverfahren, um einem URL Argumente zu liefern. Die Groß- und
Kleinschreibung von servicename wird nicht berücksichtigt, und vor bzw.
nach dem =-Zeichen darf es keine Leerstellen geben. Der Parameter DBN ist
der Datenbankname.
Eine allgemeinere Methode ist die Eingabe zusätzlicher
Verbindungsparameter wie Datenbankname oder Datenbankdatei mit dem
Feld RemotePWD: Setzen Sie RemotePWD als Eigenschaftsfeld mit der
Methode setRemotePassword().
Nachstehend wird ein Beispielcode für die Verwendung dieses Feldes
gezeigt.
sybDrvr = (SybDriver)Class.forName(
"com.sybase.jdbc2.jdbc.SybDriver" ).newInstance();
props = new Properties();
props.put( "User", "DBA" );
props.put( "Password", "SQL" );
sybDrvr.setRemotePassword(
null, "dbf=asademo.db", props );
Connection con = DriverManager.getConnection(
"jdbc:sybase:Tds:localhost", props );
153

jConnect-JDBC-Treiber verwenden
154
Mit dem Parameter für die Datenbankdatei DBF können Sie mit jConnect
eine Datenbank auf einem Server starten. Standardmäßig wird die Datenbank
mit autostop=YES gestartet. Wenn Sie DBF oder DBN mit utility_db
eingeben, wird die Dienstprogramm-Datenbank automatisch gestartet.
$ Weitere Hinweise zur Dienstprogramm-Datenbank finden Sie unter
"Die Dienstprogrammdatenbank verwenden" auf Seite 249 der
Dokumentation ASA Datenbankadministration.
Für jConnect-Verbindungen eingestellte Datenbankoptionen
Wenn sich eine Anwendung mit dem jConnect-Treiber mit der Datenbank
verbindet, werden zwei gespeicherte Prozeduren aufgerufen:
1 sp_tsql_environment stellt einige Datenbankoptionen für die
Kompatibilität mit Adaptive Server Enterprise ein.
2 Anschließend wird die Prozedur spt_mda aufgerufen, die einige andere
Optionen einstellt. Insbesondere legt die Prozedur spt_mda die
Einstellung der Option QUOTED_IDENTIFIER fest. Zum Ändern des
Standardverhaltens sollten Sie die Prozedur spt_mda ändern.

JDBC-ODBC-Brücke verwenden
Erforderliche
Dateien
Verbindung
herstellen
Kapitel 5 Datenzugriff über JDBC
Die JDBC-ODBC-Brücke bietet einen JDBC-Treiber, der eine bessere
Performance sowie einige zusätzliche Funktionen im Vergleich zum
jConnect JDBC-Treiber ausweist; die JDBC-ODBC-Brücke ist jedoch im
Gegensatz zum jConnect-Treiber keine reine Java-Lösung.
$ Hinweise zur Auswahl des JDBC-Treibers finden Sie unter "JDBC-
Treiber wählen" auf Seite 145.
Die Java-Komponente der JDBC-ODBC-Brücke ist in der Datei jodbc.jar
enthalten, die Sie im Unterverzeichnis Java der SQL Anywhere-Installation
finden. Unter Windows ist die systemeigene Komponente in der Datei
dbjodbc8.dll im Unterverzeichnis win32 der SQL Anywhere-Installation zu
finden; für UNIX und Linux befindet sich die systemeigene Komponente in
dbjodbc8.so. Die Komponente muss im Systempfad enthalten sein. Wenn
Anwendungen mit diesem Treiber eingeführt werden, müssen auch die
ODBC-Treiberdateien installiert werden.
Der folgende Code veranschaulicht, wie eine Verbindung mit der JDBC-
ODBC-Brücke hergestellt wird:
String driver, url;
Connection conn;
driver="ianywhere.ml.jdbcodbc.IDriver";
url = "jdbc:odbc:dsn=ASA 8.0 Sample";
Class.forName( driver );
conn = DriverManager.getConnection( url );
Dieser Code weist folgende Besonderheiten auf:
♦ Da die Klassen mit Class.forName geladen werden, muss das Paket,
das die JDBC-ODBC-Brücke enthält, nicht mit import-Anweisungen
importiert werden.
♦ jodbc.jar muss im Classpath enthalten sein, wenn Sie die Anwendung
ausführen.
♦ Der URL enthält jdbc:odbc:, gefolgt von einer standardmäßigen
ODBC-Verbindungszeichenfolge. Die Verbindungszeichenfolge ist in
der Regel eine ODBC-Datenquelle; Sie können jedoch auch explizit
durch Strichpunkte getrennte, einzelne Verbindungszeichenfolgen
zusätzlich zu oder an Stelle der Datenquelle verwenden. Weitere
Hinweise zu den Optionen, die Sie in einer Verbindungszeichenfolge
verwenden können, finden Sie unter "Verbindungsparameter" auf
Seite 78 der Dokumentation ASA Datenbankadministration.
155

JDBC-ODBC-Brücke verwenden
Zeichensätze
156
Falls Sie keine Datenquelle verwenden, sollen Sie den ODBC-Treiber
angeben, indem Sie die Treiberoption zur Verbindungszeichenfolge
hinzufügen:
url = "jdbc:odbc:";
url += "driver=Adaptive Server Anywhere 8.0;...";
Unter UNIX verwendet die JDBC-ODBC-Brücke keine ODBC-Unicode-
Bindungen oder -Aufrufe und nimmt keine Zeichensatzkonvertierungen vor.
Das Senden von Nicht-ASCII-Daten über die Brücke führt zur Beschädigung
der Daten.
Unter Windows verwendet die JDBC-ODBC-Brücke ODBC-Unicode-
Bindungen und -Aufrufe, um Zeichensatzkonvertierungen vorzunehmen.

JDBC-Verbindungen herstellen
Kapitel 5 Datenzugriff über JDBC
In diesem Abschnitt werden Klassen vorgestellt, die von einer Java-
Anwendung aus eine JDBC-Datenbankverbindung herstellen. In den
Beispielen in diesem Abschnit werden jConnect (clientseitig) oder Java in
der Datenbank (serverseitig) verwendet. Hinweise zur Herstellung von
Verbindungen mit der JDBC-ODBC-Brücken finden Sie unter
"JDBC-ODBC-Brücke verwenden" auf Seite 155.
Von einer JDBC-Clientanwendung aus mit jConnect eine
Verbindung herstellen
Wenn Sie von einer JDBC-Anwendung auf Datenbank-Systemtabellen
zugreifen wollen (Datenbank-Metadaten), müssen Sie eine Reihe von
jConnect-Systemobjekten in Ihre Datenbank einfügen. Die internen JDBC-
Treiberklassen und jConnect nutzen gemeinsam gespeicherte Prozeduren für
die Unterstützung der Datenbank-Metadaten. Diese Prozeduren werden in
allen Datenbanken standardmäßig installiert. Der Parameter dbinit -i
verhindert die Installation.
$ Weitere Hinweise zum Hinzufügen von jConnect-Systemobjekten in
eine Datenbank finden Sie unter "jConnect-JDBC-Treiber verwenden" auf
Seite 150.
Die folgende, vollständige Java-Anwendung ist eine
Befehlszeilenanwendung, die eine Verbindung mit einer laufenden
Datenbank herstellt, eine Reihe von Daten auf der Befehlszeile ausgibt und
beendet wird.
Der erste Schritt einer beliebigen JDBC-Anwendung ist die Herstellung der
Verbindung mit der Datenbank, wenn sie mit dieser arbeiten will.
$ Dieses Beispiel veranschaulicht eine externe Verbindung, bei der es
sich um eine reguläre Client/Server-Verbindung handelt. Hinweise zum
Erstellen einer internen Verbindung von Java-Klassen, die im
Datenbankserver laufen, finden Sie unter "Verbindung von einer
serverseitigen JDBC-Klasse herstellen" auf Seite 161.
157

JDBC-Verbindungen herstellen
Beispielcode für eine externe Verbindung
158
Es folgt ein Beispiel-Quellcode für die Methoden, die zum Herstellen einer
Verbindung eingesetzt werden. Der Quellcode befindet sich in den Methoden
main und ASAConnect in der Datei JDBCExamples.java im Verzeichnis
Samples\ASA\Java in Ihrem SQL Anywhere-Verzeichnis. (Die Kommentare
werden zum besseren Verständnis hier in deutscher Übersetzung
wiedergegeben.)
import java.sql.*; // JDBC
import com.sybase.jdbc2.jdbc.*; // Sybase jConnect
import java.util.Properties; // Eigenschaften
import sybase.sql.*; // Sybase Dienstprogramme
import asademo.*; // Beispielklassen
classes
public class JDBCExamples{
private static Connection conn;
public static void main( String args[] ){
// Verbindung herstellen
conn = null;
String machineName = ( args.length == 1 ? args[0] :
"localhost" );
ASAConnect( "DBA", "SQL", machineName );
if( conn!=null ) {
System.out.println( "Connection successful" );
}else{
System.out.println( "Connection failed" );
}
}
try{
getObjectColumn();
getObjectColumnCastClass();
insertObject();
}
catch( Exception e ){
System.out.println( "Error: " + e.getMessage() );
e.printStackTrace();
}

Kapitel 5 Datenzugriff über JDBC
private static void ASAConnect( String userID,
String password,
String machineName ) {
// Mit einem Adaptive Server Anywhere verbinden
String coninfo = new String( machineName );
Properties props = new Properties();
props.put( "user", userID );
props.put( "password", password );
props.put("DYNAMIC_PREPARE", "true");
// jConnect laden
try {
Class.forName( "com.sybase.jdbc2.jdbc.SybDriver"
).newInstance();
String dbURL = "jdbc:sybase:Tds:" + machineName +
":2638/?JCONNECT_VERSION=5";
System.out.println( dbURL );
conn = DriverManager.getConnection( dbURL , props
);
}
catch ( Exception e ) {
System.out.println( "Error: " + e.getMessage() );
e.printStackTrace();
}
}
So funktioniert das Beispiel für eine externe Verbindung
Pakete importieren
Das Beispiel für eine externe Verbindung ist eine Java-
Befehlszeilenanwendung.
Die Anwendung benötigt mehrere Bibliotheken. Deren Import erfolgt in den
ersten Zeilen von JDBCExamples.java:
♦ Das Paket java.sql enthält die JDBC-Klassen von Sun Microsystems,
die für alle JDBC-Anwendungen erforderlich sind. Sie finden sie in der
Datei classes.zip im Java-Unterverzeichnis.
♦ Der aus com.sybase.jdbc2.jdbc importierte Sybase jConnect JDBC-
Treiber ist für alle Anwendungen erforderlich, die Verbindungen über
jConnect herstellen.
♦ Die Anwendung benutzt eine Eigenschaftsliste (property list). Die
Klasse java.util.Properties ist erforderlich, um mit Eigenschaftslisten
arbeiten zu können. Sie finden sie in der Datei classes.zip im Java-
Unterverzeichnis.
♦ Das Paket asademo enthält Klassen, die in einigen Beispielen verwendet
werden. Sie finden es in der Datei Samples\ASA\Java\asademo.jar.
159

JDBC-Verbindungen herstellen
Die Methode
"main"
Die Methode
"ASAConnect"
160
Jede Java-Anwendung erfordert eine Klasse mit einer Methode mit dem
Namen main, die beim Programmstart aufgerufen wird. In diesem einfachen
Beispiel ist JDBCExamples.main die einzige Methode in der Anwendung.
Die Methode JDBCExamples.main führt folgende Aufgaben aus:
1 Sie verarbeitet das Befehlszeilenargument und benutzt dabei den
Rechnernamen, wenn ein solcher übergeben wurde. Standardmäßig ist
der Name des Rechners localhost, der sich für den Personal
Datenbankserver eignet.
2 Sie ruft die Methode "ASAConnect" auf, damit eine Verbindung
hergestellt wird.
3 Sie führt mehrere Methoden aus, die Daten in die Befehlszeile abrollen.
Die Methode JDBCExamples.ASAConnect führt folgende Aufgaben aus:
1 Sie stellt über Sybase jConnect eine Verbindung mit der laufenden
Standarddatenbank her.
♦ Class.forName lädt jConnect. Mit der Methode newInstance
werden Probleme in einigen Browsern vermieden.
♦ Die StringBuffer-Anweisungen bauen aus der Literal-Zeichenfolge
und dem in der Befehlszeile angegebenen Rechnernamen eine
Verbindungszeichenfolge auf.
♦ DriverManager.getConnection stellt mit der
Verbindungszeichenfolge eine Verbindung her.
2 Sie gibt die Kontrolle an die aufrufende Methode zurück.
Beispiel für eine externe Verbindung
In diesem Abschnitt wird beschrieben, wie das Beispiel für eine externe
Verbindung ausgeführt wird.
v So wird die Beispielanwendung für eine externe Verbindung erstellt
und ausgeführt:
1 Öffnen Sie eine Befehlszeile.
2 Wechseln Sie in Ihr SQL Anywhere-Verzeichnis.
3 Wechseln Sie in das Unterverzeichnis Samples\ASA\Java.
4 Die Datenbank muss auf einem Datenbankserver geladen sein, der mit
TCP/IP läuft. Einen solchen Server können Sie auf Ihrem lokalen
Rechner starten, indem Sie folgenden Befehl ausführen (vom
Unterverzeichnis Samples\ASA\Java aus):

start dbeng8 ..\..\..\asademo
Kapitel 5 Datenzugriff über JDBC
5 Führen Sie das Beispiel aus, indem Sie an der Eingabeaufforderung
folgenden Befehl eingeben:
java JDBCExamples
Wenn Sie dies mit einem Server ausprobieren wollen, der auf einem
anderen Rechner läuft, müssen Sie den Namen dieses Rechners
eingeben. Der Standard ist localhost, wobei es sich um ein Alias für den
Namen des aktuellen Rechners handelt.
6 Eine Liste von Personen und Produkten muss an der
Eingabeaufforderung angezeigt werden.
Wenn der Verbindungsversuch fehlschlägt, erscheint stattdessen eine
Fehlermeldung. Prüfen Sie, ob Sie alle erforderlichen Schritte ausgeführt
haben. Prüfen Sie, ob Ihr CLASSPATH richtig eingestellt wurde. Ein
falscher CLASSPATH führt dazu, dass eine Klasse nicht gefunden
werden kann.
$ Weitere Hinweise zur Verwendung von jConnect finden Sie unter
"jConnect-JDBC-Treiber verwenden" auf Seite 150 sowie in der Online-
Dokumentation für jConnect.
Verbindung von einer serverseitigen JDBC-Klasse herstellen
SQL-Anweisungen werden in JDBC mit Hilfe der Methode
createStatement des Connection-Objekts aufgebaut. Auch Klassen, die
innerhalb des Servers laufen, müssen eine Verbindung herstellen, damit ein
Connection-Objekt erstellt wird.
Eine Verbindung von einer serverseitigen JDBC-Klasse herzustellen ist
einfacher, als eine externe Verbindung einzurichten. Da die serverseitige
Klasse von einem bereits verbundenen Benutzer ausgeführt wird, verwendet
die Klasse einfach die vorhandene Verbindung.
Beispielcode für eine serverseitige Verbindung
Nachstehend wird der Quellcode für das Beispiel gezeigt. Den Quellcode
finden Sie in der Methode InternalConnect in
Samples\ASA\Java\JDBCExamples.java in Ihrem SQL Anywhere-
Verzeichnis:
public static void InternalConnect() {
try {
conn =
DriverManager.getConnection("jdbc:default:connection");
System.out.println("Hello World");
161

JDBC-Verbindungen herstellen
162
}
}
}
catch ( Exception e ) {
System.out.println("Error: " + e.getMessage());
e.printStackTrace();
}
So funktioniert das Beispiel für eine serverseitige Verbindung
In diesem einfachen Beispiel ist InternalConnect() die einzige Methode in
der Anwendung.
Die Anwendung erfordert nur eine der Bibliotheken (JDBC), die in der
ersten Zeile der Klasse JDBCExamples.java importiert werden. Die anderen
werden für externe Verbindungen benötigt. Das Paket java.sql enthält die
JDBC-Klassen.
Die InternalConnect()-Methode führt folgende Aufgaben aus:
1 Sie stellt über die aktuelle Verbindung eine Verbindung mit der
laufenden Standarddatenbank her:
♦ DriverManager.getConnection stellt eine Verbindung unter
Verwendung der Verbindungszeichenfolge
jdbc:default:connection her.
2 Sie gibt an der aktuellen Standardausgabe, d.h. im Serverfenster, Hello
World aus. System.out.println führt die Ausgabe aus.
3 Wenn bei dem Verbindungsversuch ein Fehler auftritt, erscheint eine
Fehlermeldung im Serverfenster, die Auskunft über die Stelle gibt, an
der der Fehler aufgetreten ist.
Die Anweisungen try und catch bieten den Rahmen für die
Fehlerbehandlung.
4 Beendet die Klasse
So wird das Beispiel für eine serverseitige Verbindung ausgeführt.
In diesem Abschnitt wird beschrieben, wie das Beispiel für eine serverseitige
Verbindung ausgeführt wird.

Kapitel 5 Datenzugriff über JDBC
v So wird die Beispielanwendung für eine interne Verbindung erstellt
und ausgeführt:
1 Falls Sie es noch nicht getan haben, kompilieren Sie die Datei
JDBCExamples.java. Wenn Sie das JDK verwenden, können Sie im
Verzeichnis Samples\ASA\Java von einer Befehlszeile aus
folgendermaßen vorgehen:
javac JDBCExamples.java
2 Starten Sie einen Datenbankserver mit der Beispieldatenbank. Einen
solchen Server können Sie auf Ihrem lokalen Rechner starten, indem Sie
folgenden Befehl ausführen (vom Unterverzeichnis Samples\ASA\Java
aus):
start dbeng8 ..\..\..\asademo
In diesem Fall ist das TCP/IP-Netzwerkprotokoll nicht erforderlich, da
jConnect nicht verwendet wird.
3 Installieren Sie die Klasse in der Beispieldatenbank. Wenn die
Verbindung mit der Beispieldatenbank hergestellt ist, können Sie von
Interactive SQL aus folgenden Befehl verwenden:
INSTALL JAVA NEW
FROM FILE
’Suchpfad\Samples\ASA\Java\JDBCExamples.class’
Dabei gilt: Suchpfad ist der Suchpfad zu Ihrem Installationsverzeichnis.
Es besteht außerdem die Möglichkeit, die Klasse mit Sybase Central zu
installieren. Öffnen Sie den Ordner mit den Java-Objekten bei
vorhandener Verbindung mit der Datenbank und doppelklicken Sie auf
"Java-Klasse hinzufügen". Befolgen Sie dann die Anweisungen im
Assistenten.
4 Jetzt können Sie die Methode InternalConnect dieser Klasse aufrufen,
als wenn Sie eine gespeicherte Prozedur aufrufen würden:
CALL JDBCExamples>>InternalConnect()
Beim ersten Aufruf einer Java-Klasse muss die Java Virtual Machine
gestartet werden. Dies kann einige Sekunden dauern.
5 Auf dem Serverbildschirm muss Hello World erscheinen.
163

JDBC-Verbindungen herstellen
Hinweise zu JDBC-Verbindungen
164
♦ AutoCommit-Verhalten Die JDBC-Spezifikation erfordert, dass
standardmäßig nach jeder Datenänderungsanweisung ein COMMIT
ausgeführt wird. Derzeit ist das serverseitige JDBC-Verhalten auf
"Festschreiben" eingestellt. Sie können dieses Verhalten steuern, indem
Sie folgende Anweisung verwenden:
conn.setAutoCommit( false ) ;
Dabei gilt: conn ist das aktuelle Verbindungsobjekt.
♦ Standardwerte für die Verbindung Bei der serverseitigen JDBC erstellt
nur der erste Aufruf von getConnection( "jdbc:default:connection" )
eine neue Verbindung mit den Standardwerten. Nachfolgende Aufrufe
geben einen Behälter der aktuellen Verbindung mit allen unveränderten
Verbindungseigenschaften zurück. Wenn Sie AutoCommit in Ihrer
ursprünglichen Verbindung auf OFF setzen, geben alle nachfolgenden
getConnection Aufrufe in demselben Java-Code eine Verbindung mit
AutoCommit in Stellung OFF zurück.
Es kann sinnvoll sein, die Verbindungseigenschaften beim Schließen der
Verbindung auf die Standardwerte zurücksetzen zu lassen, damit
nachfolgende Verbindungen mit Standard-JDBC-Werten eingerichtet
werden. Verwenden Sie dafür den folgenden Programmcode:
Connection conn = DriverManager.getConnection("");
boolean oldAutoCommit = conn.getAutoCommit();
try {
// Code hierher setzen
}
finally {
conn.setAutoCommit( oldAutoCommit );
}
Diese Hinweise gelten nicht nur für AutoCommit, sondern auch für
andere Verbindungseigenschaften wie TransactionIsolation und
isReadOnly.

Kapitel 5 Datenzugriff über JDBC
JDBC für den Zugriff auf Daten verwenden
Vorbereitung der Beispiele
Beispielcode
Java-Anwendungen, die einige oder alle Klassen in der Datenbank enthalten,
bieten einen erheblichen Vorteil gegenüber traditionellen in SQL
geschriebenen gespeicherten Prozeduren. Als Einführung kann es jedoch
hilfreich sein, Parallelen zu mit SQL geschriebenen gespeicherten
Prozeduren zu ziehen, um die Fähigkeiten von JDBC zu demonstrieren. In
den folgenden Beispielen werden Java-Klassen geschrieben, die eine Zeile in
die Tabelle Department einfügen.
Wie auch bei anderen Schnittstellen können SQL-Anweisungen in JDBC
entweder statisch oder dynamisch sein. Statische SQL-Anweisungen
werden in der Java-Anwendung aufgebaut und zur Datenbank gesandt. Der
Datenbankserver analysiert die Anweisung syntaktisch, wählt einen
Ausführungsplan und führt die Anweisung aus. Syntaktische Analyse und
Auswahl eines Ausführungsplans werden in der Folge als Vorbereitung der
Anweisung bezeichnet.
Wenn eine ähnliche Anweisung häufig ausgeführt werden soll (z.B. viele
Einfügungen in eine Tabelle), kann dies zu erheblichem Overhead in der
statischen SQL führen, weil jedesmal der Vorbereitungsschritt ausgeführt
werden muss.
Im Gegensatz dazu enthält eine dynamische SQL-Anweisung Platzhalter.
Die Anweisung wird einmal mit Hilfe dieser Platzhalter vorbereitet und kann
dann mehrmals ausgeführt werden, ohne dass sie neuerlich vorbereitet
werden muss.
In diesem Abschnitt verwenden wir statische SQL. Dynamische SQL wird
weiter unten behandelt.
In diesem Abschnitt wird beschrieben, welche Vorbereitungsmaßnahmen für
die Beispiele im restlichen Teil des Kapitels ergriffen werden müssen.
Die Codefragmente in diesem Abschnitt stammen aus der vollständigen
Klasse Samples\ASA\Java\JDBCExamples.java.
v So wird die Klasse JDBCExamples installiert:
1 Wenn Sie dies noch nicht getan haben, installieren Sie die Datei
JDBCExamples.class in der Beispieldatenbank. Wenn die Verbindung
von Interactive SQL mit der Beispieldatenbank hergestellt ist, können
Sie im Fensterausschnitt für die SQL-Anweisungen folgenden Befehl
verwenden:
165

JDBC für den Zugriff auf Daten verwenden
166
INSTALL JAVA NEW
FROM FILE
’Suchpfad\Samples\ASA\Java\JDBCExamples.class’
Dabei gilt: Suchpfad ist der Suchpfad zu Ihrem Installationsverzeichnis.
Es besteht außerdem die Möglichkeit, die Klasse mit Sybase Central zu
installieren. Öffnen Sie den Ordner mit den Java-Objekten bei
vorhandener Verbindung mit der Datenbank und doppelklicken Sie auf
"Java-Klasse hinzufügen". Befolgen Sie dann die Anweisungen im
Assistenten.
Einfügen, Aktualisieren und Löschen mit JDBC
Das Objekt Statement führt statische SQL-Anweisungen aus. SQL-
Anweisungen wie INSERT, UPDATE, DELETE, die keine Ergebnismengen
zurückgeben, können Sie mit Hilfe der Methode executeUpdate des Objekts
Statement ausführen. Anweisungen wie CREATE TABLE und andere
Anweisungen zur Datendefinition können auch mit executeUpdate
ausgeführt werden.
Das folgende Codefragment veranschaulicht, wie INSERT-Anweisungen
innerhalb von JDBC ausgeführt werden. Es benutzt eine interne Verbindung,
die im Verbindungsobjekt conn definiert ist. Der Programmcode für das
Einfügen von Werten aus einer externen Anwendung mit JDBC benötigt eine
andere Verbindung, ist aber ansonsten unverändert.
public static void InsertFixed() {
// Gibt die aktuelle Verbindung zurück
conn =
DriverManager.getConnection("jdbc:default:connection");
// AutoCommit deaktivieren
conn.setAutoCommit( false );
Statement stmt = conn.createStatement();
Integer IRows = new Integer( stmt.executeUpdate
("INSERT INTO Department (dept_id, dept_name )"
+ "VALUES (201, 'Eastern Sales')"
) );
// Anzahl von aktualisierten Zeilen ausgeben
System.out.println(IRows.toString() + " row
inserted" );
}

Hinweise
Kapitel 5 Datenzugriff über JDBC
Quellcode verfügbar
Dieses Codefragment ist Teil der Methode InsertFixed der Klasse
JDBCExamples, die sich im Unterverzeichnis Samples\ASA\Java Ihres
Installationsverzeichnisses befindet.
♦ Die Methode setAutoCommit deaktiviert das AutoCommit-Verhalten,
sodass Änderungen nur festgeschrieben werden, wenn eine explizite
COMMIT-Anweisung ausgeführt wird.
♦ Die Methode executeUpdate gibt eine Ganzzahl zurück, die die Anzahl
der Zeilen ausdrückt, die von dem Vorgang betroffen waren. In diesem
Fall würde ein erfolgreicher INSERT-Vorgang den Wert Eins (1)
zurückgeben.
♦ Der Rückgabetyp "Ganzzahl" wird in ein Objekt Integer konvertiert.
Die Klasse "Integer" ist ein Behälter für den grundlegenden Datentyp
int, der einige nützliche Methoden enthält, wie z.B. toString().
♦ Die Ganzzahl IRows wird in eine Zeichenfolge konvertiert, die
ausgegeben werden muss. Die Ausgabe erfolgt im Serverfenster.
v So wird das Beispiel JDBC Insert ausgeführt:
1 Über Interactive SQL stellen Sie als Benutzer DBA eine Verbindung mit
der Beispieldatenbank her.
2 Die Klasse JDBCExamples muss installiert sein. Sie wird gemeinsam
mit den anderen Java-Beispielklassen installiert.
$ Weitere Hinweise, wie Sie die Java-Beispiele installieren können,
finden Sie unter "Java-Beispiele einrichten" auf Seite 94.
3 Rufen Sie die Methode wie folgt auf:
CALL JDBCExamples>>InsertFixed()
4 Vergewissern Sie sich, dass in die Tabelle Department eine zusätzliche
Zeile eingefügt wurde.
SELECT *
FROM department
Die Zeile 201 ist nicht festgeschrieben. Sie können eine ROLLBACK-
Anweisung ausführen, um die Zeile zu entfernen.
In diesem Beispiel haben Sie gesehen, wie eine sehr einfache JDBC-Klasse
erstellt wird. Die nächsten Beispiele bauen darauf auf.
167

JDBC für den Zugriff auf Daten verwenden
Argumente an Java-Methoden übergeben
Hinweise
168
Wir können die Methode InsertFixed erweitern, um zu veranschaulichen,
wie Argumente an Java-Methoden übergeben werden.
Die folgende Methode verwendet Argumente, die im Aufruf als die
einzufügenden Werte an die Methode übergeben werden:
public static void InsertArguments(
String id, String name) {
try {
conn = DriverManager.getConnection(
"jdbc:default:connection" );
String sqlStr = "INSERT INTO Department "
+ " ( dept_id, dept_name )"
+ " VALUES (" + id + ", ’" + name + "’)";
// Anweisung ausführen
Statement stmt = conn.createStatement();
Integer IRows = new Integer( stmt.executeUpdate(
sqlStr.toString() ) );
// Anzahl von aktualisierten Zeilen ausgeben
System.out.println(IRows.toString() + " row
inserted" );
}
catch ( Exception e ) {
System.out.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
♦ Die beiden Argumente sind "department ID" (eine Ganzzahl) und
"department name" (eine Zeichenfolge). Hier werden beide Argumente
als Zeichenfolgen an die Methode übergeben, weil sie als Teil der
Zeichenfolge der SQL-Anweisung verwendet werden.
♦ INSERT ist eine statische Anweisung: Sie nimmt außer der SQL selbst
keine Parameter an.
♦ Wenn Sie eine falsche Anzahl oder einen falschen Typ von Argumenten
angeben, erscheint die Fehlermeldung Prozedur nicht gefunden
(Procedure Not Found).
v So wird die Java-Methode mit Argumenten verwendet:
1 Wenn Sie dies noch nicht getan haben, installieren Sie die Datei
JDBCExamples.class in der Beispieldatenbank.

Abfragen mit JDBC
Kapitel 5 Datenzugriff über JDBC
2 Stellen Sie über Interactive SQL eine Verbindung zur Beispieldatenbank
her und geben Sie folgenden Befehl ein:
call JDBCExamples>>InsertArguments( ’203’, ’Northern
Sales’ )
3 Vergewissern Sie sich, dass in die Tabelle "Department" eine
zusätzliche Zeile eingefügt wurde.
SELECT *
FROM Department
4 Setzen Sie die Änderungen zurück, damit die Datenbank unverändert
bleibt:
ROLLBACK
Das Objekt Statement wird für die Ausführung von statischen Abfragen und
für Anweisungen eingesetzt, die keine Ergebnismengen zurückgeben. Bei
Abfragen verwenden Sie die Methode executeQuery des Objekts
Statement. Dies führt zur Rückgabe der Ergebnismenge in einem Objekt
ResultSet.
Das folgende Codefragment veranschaulicht, wie Abfragen in JDBC
behandelt werden. Das Codefragment setzt den Gesamt-Bestandswert für ein
Produkt in eine Variable mit dem Namen Inventory. Die
Artikelbezeichnung wird in der String-Variablen prodname abgelegt.
Dieses Beispiel ist als Methode Query der Klasse JDBCExamples
verfügbar.
Es gilt die Voraussetzung, dass eine interne bzw. externe Verbindung
hergestellt wurde, die sich im Verbindungsobjekt mit der Bezeichnung conn
befindet.
public static int Query () {
int max_price = 0;
try{
conn = DriverManager.getConnection(
"jdbc:default:connection" );
// Abfrage aufbauen
String sqlStr = "SELECT id, unit_price "
+ "FROM product" ;
// Anweisung ausführen
Statement stmt = conn.createStatement();
ResultSet result = stmt.executeQuery( sqlStr );
while( result.next() ) {
169

JDBC für den Zugriff auf Daten verwenden
Das Beispiel
ausführen
Hinweise
170
int price = result.getInt(2);
System.out.println( "Price is " + price );
if( price > max_price ) {
max_price = price ;
}
}
}
catch( Exception e ) {
System.out.println("Error: " + e.getMessage());
e.printStackTrace();
}
return max_price;
}
Wenn Sie die Klasse JDBCExamples in der Beispieldatenbank installiert
haben, können Sie diese Methode mit folgender Anweisung in Interactive
SQL ausführen:
select JDBCExamples>>Query()
♦ Die Abfrage wählt Menge und Einheitspreis für alle Produkte mit dem
Namen prodname. Diese Ergebnisse werden in das Objekt ResultSet
mit dem Namen result zurückgegeben.
♦ In der Ergebnismenge wird über jeder Zeile eine Schleife ausgeführt.
Die Schleife verwendet die Methode next.
♦ Für jede Zeile wird der Wert jeder Spalte mit der Methode getInt in eine
Ganzzahlvariable abgerufen. ResultSet umfasst ebenfalls Methoden für
andere Datentypen, wie etwa getString, getDate und getBinaryString.
Das Argument für die Methode getInt ist eine Indexnummer für die
Spalte, beginnend mit 1.
Die Datentyp-Konvertierung von SQL auf Java wird gemäß den
Angaben im folgenden Abschnitt erklärt: "Datentypkonvertierung von
SQL in Java" auf Seite 96 der Dokumentation ASA SQL-
Referenzhandbuch.
♦ Adaptive Server Anywhere unterstützt bidirektional abrollende Cursor.
JDBC bietet jedoch nur die Methode next, die dem Vorwärts-Abrollen
durch die Ergebnismenge entspricht.
♦ Die Methode gibt der aufrufenden Umgebung den Wert max_price
zurück, und Interactive SQL zeigt ihn auf dem Register "Ergebnisse" im
Fenster "Ergebnisse" an.

Kapitel 5 Datenzugriff über JDBC
Vorbereitete Anweisungen für effizienteren Zugriff verwenden
Beispiel
Wenn Sie ein Statement-Interface verwenden, muss jede Anweisung, die Sie
an die Datenbank senden, syntaktisch analysiert werden. Außerdem ist ein
Zugriffsplan zu generieren und die Anweisung auszuführen. Die Schritte vor
der eigentlichen Ausführung werden als Vorbereitung der Anweisung
bezeichnet.
Sie können Performance-Vorteile erzielen, wenn Sie die
PreparedStatement-Schnittstelle verwenden. Damit haben Sie die
Möglichkeit, eine Anweisung mit Platzhaltern vorzubereiten, und dann beim
Ausführen der Anweisung diesen Platzhaltern Werte zuzuordnen.
Der Einsatz von vorbereiteten Anweisungen ist besonders dann nützlich,
wenn viele ähnliche Aktionen ausgeführt werden, wie etwa das Einfügen von
vielen Zeilen.
$ Weitere Hinweise über vorbereitete Anweisungen finden Sie unter
"Anweisungen vorbereiten" auf Seite 12.
Das folgende Beispiel zeigt, wie die Schnittstelle PreparedStatement
benutzt werden kann, obwohl das Einfügen einer einzelnen Zeile in der
Praxis nicht mit vorbereiteten Anweisungen erfolgen sollte.
Die folgende Methode der Klasse JDBCExamples führt eine vorbereitete
Anweisung aus:
public static void JInsertPrepared(int id, String name)
try {
conn = DriverManager.getConnection(
"jdbc:default:connection");
// INSERT-Anweisung erstellen
// ? ist ein Platzhalterzeichen
String sqlStr = "INSERT INTO Department "
+ "( dept_id, dept_name ) "
+ "VALUES ( ? , ? )" ;
// Anweisung vorbereiten
PreparedStatement stmt = conn.prepareStatement(
sqlStr );
stmt.setInt(1, id);
stmt.setString(2, name );
Integer IRows = new Integer(
stmt.executeUpdate() );
// Anzahl von aktualisierten Zeilen ausgeben
System.out.println(IRows.toString() + " row
inserted" );
}
171

JDBC für den Zugriff auf Daten verwenden
Das Beispiel
ausführen
Objekte einfügen und abrufen
Objekte abrufen
172
}
catch ( Exception e ) {
System.out.println("Error: " + e.getMessage());
e.printStackTrace();
}
Wenn Sie die Klasse JDBCExamples in der Beispieldatenbank installiert
haben, können Sie das Beispiel mit folgender Anweisung ausführen:
call JDBCExamples>>InsertPrepared(
202, ’Eastern Sales’ )
Das Zeichenfolgenargument wird entsprechend den SQL-Regeln in
Apostrophe eingeschlossen. Wenn Sie diese Methode von einer Java-
Anwendung aus aktiviert hätten, sind zur Begrenzung der Zeichenfolge
Anführungszeichen zu verwenden.
Als Schnittstelle für relationale Datenbanken ist JDBC für das Abrufen von
traditionellen SQL-Datentypen sowie für das Arbeiten mit diesen Typen
konzipiert. Adaptive Server Anywhere umfasst auch abstrakte Datentypen in
Form von Java-Klassen. Die Art, wie Sie mit JDBC auf diese Java-Klassen
zugreifen, hängt davon ab, ob Sie die Objekte einfügen oder abrufen.
$ Weitere Hinweise zum Abrufen und Setzen ganzer Objekte finden Sie
unter "Verteilte Anwendungen erstellen" auf Seite 174.
Auf folgende Art und Weise können Sie Objekte, deren Felder und deren
Methoden abrufen:
♦ Auf Methoden und Felder zugreifen Java-Methoden und -Felder
können in die Auswahlliste einer Abfrage einbezogen werden. Eine
Methode oder ein Feld erscheint als eine Spalte in der Ergebnismenge.
Sie können mit einer der standardmäßigen ResultSet-Methoden darauf
zugreifen, wie etwa getInt oder getString.
♦ Objekt abrufen Wenn Sie eine Spalte mit einem Java-Klassen-Datentyp
in die Auswahlliste einer Abfrage einbeziehen, können Sie die
ResultSet-Methode getObject verwenden, um das Objekt in die Java-
Klasse abzurufen. Dann können Sie innerhalb der Java-Klasse auf die
Methoden und Felder des betreffenden Objekts zugreifen.

Objekte einfügen
Gemischte JDBC-Hinweise
Kapitel 5 Datenzugriff über JDBC
Von einer serverseitigen Java-Klasse aus können Sie die JDBC-Methode
setObject benutzen, um ein Objekt in eine Spalte mit Java-Klassen-Datentyp
einzufügen.
Sie können Objekte mit einer vorbereiteten Anweisung einfügen. Das
folgende Codefragment fügt z.B. ein Objekt vom Typ "MyJavaClass" in eine
Spalte der Tabelle T ein:
java.sql.PreparedStatement ps =
conn.prepareStatement("insert T values( ? )" );
ps.setObject( 1, new MyJavaClass() );
ps.executeUpdate();
Eine Alternative wäre, eine SQL-Variable einzurichten, die das Objekt
enthält, und dann die SQL-Variable in die Tabelle einzufügen.
♦ Zugriffsberechtigungen Wie auf alle Java-Klassen in der Datenbank,
kann jeder beliebige Benutzer auch auf Klassen mit JDBC-Anweisungen
zugreifen. Es gibt keine Entsprechung zur Anweisung GRANT
EXECUTE, die die Berechtigung zum Ausführen von Prozeduren erteilt,
und der Name einer Klasse braucht nicht mit dem Namen des
Eigentümers qualifiziert zu werden.
♦ Berechtigung zum Ausführen Java-Klassen werden mit den
Berechtigungen der sie ausführenden Verbindung ausgeführt. Dieses
Verhalten unterscheidet sich von dem der gespeicherten Prozeduren, die
mit den Berechtigungen des Eigentümers ausgeführt werden.
173

Verteilte Anwendungen erstellen
Verteilte Anwendungen erstellen
Dazugehörige
Aufgaben
Anforderungen für
verteilte
Anwendungen
174
In einer verteilten Anwendung laufen Teile der Anwendungslogik auf
einem Rechner, andere Teile auf einem anderen. In Adaptive Server
Anywhere können Sie verteilte Java-Anwendungen erstellen, bei denen ein
Teil der Logik auf dem Datenbankserver, und ein Teil auf dem Clientsystem
läuft.
Adaptive Server Anywhere ist in der Lage, Java-Objekte mit einem externen
Java-Client auszutauschen.
Die Schlüsselaufgabe für eine Clientanwendung in einer verteilten
Anwendung besteht darin, ein Java-Objekt von einer Datenbank abzurufen.
In diesem Abschnitt wird beschrieben, wie dies geschieht.
In anderen Teilen dieses Kapitels haben wir beschrieben, wie mehrere
Aufgaben abgerufen werden, die in Beziehung mit abrufenden Objekten
stehen, jedoch nicht mit dem Abrufen des Objekts selbst verwechselt werden
sollten. Zum Beispiel:
♦ "Java-Objekte abfragen" auf Seite 117 Hier wird beschrieben, wie ein
Objekt in eine SQL-Variable abgerufen wird. Damit ist allerdings noch
nicht das Problem gelöst, wie das Objekt in Ihre Java-Anwendung
gelangt.
♦ "Java-Objekte abfragen" auf Seite 117 Hier wird auch beschrieben, wie
die öffentlichen Felder und der Rückgabewert von Java-Methoden
abgerufen werden. Auch dies unterscheidet sich vom Abrufen eines
Objekts in eine Java-Anwendung.
♦ "Objekte einfügen und abrufen" auf Seite 172 Hier wird beschrieben,
wie Objekte in serverseitige Java-Klassen abgerufen werden. Auch dies
unterscheidet sich vom Abrufen von Objekten in eine Clientanwendung.
Beim Aufbau einer verteilten Anwendung müssen mehrere Aufgaben erfüllt
werden.
v So wird eine verteilte Anwendung aufgebaut:
1 Jede auf dem Server laufende Klasse muss die serialisierbare
Schnittstelle implementieren. Dies ist sehr einfach.
2 Die clientseitige Anwendung muss die Klasse importieren, damit das
Objekt auf der Clientseite wieder aufgebaut werden kann.
3 Verwenden Sie die Methode sybase.sql.ASAUtils.toByteArray auf der
Serverseite, um das Objekt zu serialisieren. Dies ist nur für Adaptive
Server Anywhere Version 6.0.1 und älter erforderlich.

Kapitel 5 Datenzugriff über JDBC
4 Verwenden Sie die Methode sybase.sql.ASAUtils.fromByteArray auf
der Clientseite, um das Objekt wieder aufzubauen. Dies ist nur für
Adaptive Server Anywhere Version 6.0.1 und älter erforderlich.
Diese Aufgaben werden in den folgenden Abschnitten beschrieben.
Serialisierbare Schnittstelle implementieren
Objekte werden in einer so genannten serialisierten Form vom Server an
eine Clientanwendung übergeben. Das bedeutet, dass jede Zeile folgende
Informationen enthält:
♦ Einen Versionsbezeichner
♦ Einen Bezeichner für die Klasse (oder Unterklasse), die gespeichert wird
♦ Die Werte von nicht-statischen, nicht-zeitweiligen Feldern in der Klasse
♦ Andere Overhead-Informationen
Damit ein Objekt an eine Clientanwendung gesendet wird, muss zunächst die
serialisierbare Schnittstelle implementiert werden. Dies ist eine sehr einfache
Aufgabe.
v So wird die serialisierbare Schnittstelle implementiert:
♦ Fügen Sie den Text implements java.io.Serializable in Ihre
Klassendefinition ein.
Zum Beispiel implementiert Samples\ASA\Java\asademo\Product.java
die serialisierbare Schnittstelle über die folgende Deklaration:
public class Product implements java.io.Serializable
Die Implementierung der serialisierbaren Schnittstelle besteht lediglich
darin, zu deklarieren, dass diese Klasse serialisiert werden kann.
Die serialisierbare Schnittstelle enthält weder Methoden noch Variable. Die
Serialisierung eines Objekts besteht darin, dass es in einen Byte-Strom
konvertiert wird, wodurch es auf einer Platte gespeichert bzw. an eine andere
Java-Anwendung gesendet werden und wieder aufgebaut bzw. deserialisiert
werden kann.
Ein Java-Objekt, das in einem Datenbankserver serialisiert, an eine
Clientanwendung gesendet und deserialisiert wurde, ist in jeder Hinsicht
identisch mit dem Original. Einige Variable in einem Objekt brauchen nicht,
bzw. sollten aus Sicherheitsgründen nicht serialisiert werden. Diese
Variablen werden wie in der folgenden Deklaration der Variablen mit Hilfe
des Schlüsselworts transient deklariert:
175

Verteilte Anwendungen erstellen
176
transient String password;
Klassen clientseitig importieren
Wenn ein Objekt mit dieser Variablen deserialisiert wird, enthält die
Variable immer ihren Standardwert Null.
Angepasste Serialisierung kann durch Hinzufügen der Methoden
writeObject() und readObject() zu Ihren Klassen erreicht werden.
$ Weitere Hinweise zur Serialisierung finden Sie im Java Development
Kit (JDK) von Sun Microsystems.
Auf der Clientseite muss jede Klasse, die ein Objekt abruft, Zugriff auf die
geeignete Klassendefinition haben, damit sie das Objekt benutzen kann. Um
die Klasse Product verwenden zu können, die Teil des Pakets asademo ist,
müssen Sie folgende Zeile in Ihre Anwendung einbeziehen:
import asademo.*
Die Datei asademo.jar muss in Ihren CLASSPATH einbezogen sein, damit
dieses Paket gefunden werden kann.
Beispiel für eine verteilte Anwendung
Die Klasse JDBCExamples.java enthält drei Methoden als Beispiel für den
verteilten Einsatz von Java. Sie werden alle von der Methode main
aufgerufen. Diese Methode wird im Verbindungsbeispiel im Abschnitt "Von
einer JDBC-Clientanwendung aus mit jConnect eine Verbindung herstellen"
auf Seite 157 beschrieben und ist ein Beispiel für eine verteilte Anwendung.
So sieht die Methode getObjectColumn aus der Klasse JDBCExamples aus:
private static void getObjectColumn() throws Exception {
// Rückgabe einer Ergebnismenge von einer Spalte mit
// Java-Objekten
asademo.ContactInfo ci;
String name;
String sComment ;
if ( conn != null ) {
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(
"SELECT JContactInfo FROM jdba.contact"
);

Ältere Methode
Abfrageergebnisse
serialisieren und
deserialisieren
Kapitel 5 Datenzugriff über JDBC
while ( rs.next() ) {
ci = ( asademo.ContactInfo )rs.getObject(1);
System.out.println( "\n\tStreet: " + ci.street +
"City: " + ci.city +
"\n\tState: " + ci.state +
"Phone: " + ci.phone +
"\n" );
}
}
}
Die getObject-Methode wird wie bei einem internen Java-Fall verwendet.
getObject und setObject empfohlen
Die Methoden getObject und setObject machen eine explizite
Serialisierung und Deserialisierung überflüssig, die bei früheren
Versionen der Software erforderlich waren. In diesem Abschnitt wird für
Benutzer, die den älteren Programmcode benutzen, die ältere Methode
beschrieben.
In diesem Abschnitt wird beschrieben, wie eines dieser Beispiele
funktioniert. Für die anderen Beispiele können Sie sich den Code ansehen.
Dies ist die Methode serializeColumn einer alten Version der Klasse
JDBCExamples.
private static void serializeColumn() throws Exception {
Statement stmt;
ResultSet rs;
byte arrayb[];
asademo.ContactInfo ci;
String name;
if ( conn != null ) {
stmt = conn.createStatement();
rs = stmt.executeQuery( "SELECT
sybase.sql.ASAUtils.toByteArray( JName.getName() )
AS Name,
sybase.sql.ASAUtils.toByteArray(
jdba.contact.JContactInfo )
FROM jdba.contact" );
while ( rs.next() ) {
arrayb = rs.getBytes("Name");
name = ( String
)sybase.sql.ASAUtils.fromByteArray( arrayb );
arrayb = rs.getBytes(2);
177

Verteilte Anwendungen erstellen
178
ci =
(asademo.ContactInfo)sybase.sql.ASAUtils.fromByteArray(
arrayb );
System.out.println( "Name: " + name +
"\n\tStreet: " + ci.street +
"\n\tCity: " + ci.city +
"\n\tState: " + ci.state +
"\n\tPhone: " + ci.phone +
"\n" );
}
System.out.println( "\n\n" );
}
}
Und so funktioniert die Methode:
1 Es ist bereits eine Verbindung vorhanden, wenn die Methode aufgerufen
wird. Das Verbindungsobjekt wird geprüft, und wenn es vorhanden ist,
wird der Code ausgeführt.
2 Eine SQL-Abfrage wird aufgebaut und ausgeführt. Die Abfrage lautet
folgendermaßen:
SELECT
sybase.sql.ASAUtils.toByteArray( JName.getName() )
AS Name,
sybase.sql.ASAUtils.toByteArray(
jdba.contact.JContactInfo )
FROM jdba.contact
Diese Anweisung führt eine Abfrage in der Tabelle jdba.contact aus. Sie
ruft Daten aus den Spalten JName und JContactInfo ab. Anstatt
einfach nur die Spalten selbst bzw. eine Methode der Spalte abzurufen,
wird die Funktion sybase.sql.ASAUtils.toByteArray verwendet.
3 Der Client führt eine Schleife über die Zeilen der Ergebnismenge aus.
Für jede Zeile wird der Wert jeder Spalte in ein Objekt deserialisiert.
4 Die Ausgabe (System.out.println) zeigt, dass die Felder und Methoden
des Objekts ebenso wie im Originalstatus eingesetzt werden können.
Sonstige Funktionen von verteilten Anwendungen
Es gibt zwei weitere Methoden in JDBCExamples.java, die verteilte
Informatinosverarbeitung verwenden:
♦ serializeVariable Diese Methode erstellt ein natives Java-Objekt, das
von einer SQL-Variablen auf dem Datenbankserver referenziert wird,
und gibt es an die Clientanwendung zurück.

Kapitel 5 Datenzugriff über JDBC
♦ serializeColumnCastClass Diese Methode ähnelt der Methode
serializeColumn, veranschaulicht jedoch, wie Unterklassen wieder
aufgebaut werden. Die abgefragte Spalte (JProd aus der Tabelle
product) hat den Datentyp asademo.Product. Einige der Zeilen sind
asademo.Hat, wobei es sich um eine Unterklasse der Klasse "Product"
handelt. Die richtige Klasse wird clientseitig wieder aufgebaut.
179

Verteilte Anwendungen erstellen
180

KAPITEL 6
Programmieren mit Embedded SQL
Über dieses
Kapitel
Inhalt
In diesem Kapitel wird beschrieben, wie die Embedded SQL-Schnittstelle zu
Adaptive Server Anywhere verwendet wird.
Thema Seite
Überblick 182
Beispielprogramme mit Embedded SQL 190
Datentypen in Embedded SQL 196
Hostvariable benutzen 200
SQL-Kommunikationsbereich (SQLCA) 208
Daten abrufen 214
Statische und dynamische SQL 223
Der SQL-Deskriptor-Bereich (SQLDA) 228
Lange Werte senden und abfragen 237
Gespeicherte Prozeduren verwenden 243
Programmiertechniken für Embedded SQL 247
SQL-Präprozessor 249
Referenz der Bibliotheksfunktion 253
Befehlszusammenfassung für Embedded SQL 272
181

Überblick
Überblick
182
Embedded SQL ist eine Datenbank-Programmierschnittstelle für die
Programmiersprachen C und C++. Es besteht aus SQL-Anweisungen, die in
C- oder C++-Quellcode eingebettet sind. Die SQL-Anweisungen werden von
einem SQL-Präprozessor in C- oder C++-Quellcode konvertiert, die Sie
anschließend kompilieren.
Während der Laufzeit verwenden Embedded SQL-Anwendungen eine
Adaptive Server Anywhere-Schnittstellenbibliothek für die
Kommunikation mit dem Datenbankserver. Die Schnittstellenbibliothek ist
eine dynamische Verknüpfungsbibliothek (dynamic link library - DLL) oder
- auf den meisten Betriebssystemplattformen - eine gemeinsam genutzte
Bibliothek (shared library).
♦ Unter Windows-Betriebssystemen ist die Schnittstellenbibliothek
dblib8.dll.
♦ Bei UNIX-Betriebssystemen heißt die Schnittstellenbibliothek je nach
Betriebssystem libdblib8.so, libdblib8.sl oder libdblib8.a.
Adaptive Server Anywhere liefert zwei Arten von Embedded SQL.
Statisches Embedded SQL ist einfacher zu verwenden, jedoch weniger
flexibel als dynamisches Embedded SQL. Diese beiden Arten werden in
diesem Kapitel behandelt.

Überblick über den Entwicklungsprozess
Kapitel 6 Programmieren mit Embedded SQL
Sobald das Anwendungsprogramm erfolgreich vom SQL-Präprozessor
konvertiert und anschließend kompiliert ist, wird es mit der
Importbibliothek für die Schnittstellenbibliothek von Adaptive Server
Anywhere verknüpft, um eine ausführbare Programmdatei zu erzeugen.
Wenn die Datenbank läuft, verwendet diese Programmdatei die Adaptive
Server Anywhere-DLL, um mit der Datenbank zu interagieren. Solange das
Programm durch den Präprozessor läuft, braucht die Datenbank nicht zu
laufen.
Unter Windows gibt es verschiedene Importbibliotheken für Watcom C/C++,
für Microsoft Visual C++, und für Borland C++.
$ Die Verwendung von Importbibliotheken ist die Standard-
Entwicklungsmethode für Anwendungen, die Funktionen in DLLs aufrufen.
Adaptive Server Anywhere bietet eine - empfohlene - alternative Methode,
die die Verwendung von Importbibliotheken vermeidet. Weitere Hinweise
finden Sie unter "Die Schnittstellenbibliothek dynamisch laden" auf
Seite 187.
183

Überblick
Den SQL-Präprozessor verwenden
Befehlszeile
Unterstützte Compiler
184
Der SQL-Präprozessor ist eine Programmdatei namens sqlpp.exe.
Die SQLPP-Befehlszeile sieht wie folgt aus:
sqlpp [ Parameter ] SQL-Dateiname [ Ausgabedateiname ]
Der SQL-Präprozessor konvertiert ein C-Programm mit Embedded SQL,
bevor der C- oder C++-Compiler ausgeführt wird. Der Präprozessor
übersetzt die SQL-Anweisungen in C-/C++-Quellcode und schreibt den
Quellcode in eine Ausgabedatei. Die normale Dateinamenerweiterung für
Quelldateien mit embedded SQL ist .sqc. Der voreingestellte Name für die
Ausgabedatei ist der Name der SQL-Datei mit der Erweiterung .c. Falls der
Name der SQL-Datei bereits die Erweiterung .c hat, erhält die Ausgabedeitei
standardmäßig die Erweiterung .cc.
$ Eine vollständige Auflistung der Optionen finden Sie unter "SQL-
Präprozessor" auf Seite 249.
Der SQL-Präprozessor für C wird bisher in Verbindung mit folgenden
Compilern benutzt:
Betriebssystem Compiler Version
Windows Watcom C/C++ 9.5 und höher
Windows Microsoft Visual C/C++ 1.0 und höher
Windows Borland C++ 4.5
Windows CE Microsoft Visual C/C++ 5.0
UNIX GNU oder nativer
Compiler
NetWare Watcom C/C++ 10.6, 11
$ Anweisungen zur Erstellung von NetWare NLMs finden Sie unter
"NetWare loadable Modules erstellen" auf Seite 188.
Header-Dateien für Embedded SQL
Alle Header-Dateien befinden sich nach der Installation von Adaptive Server
Anywhere im Unterverzeichnis h des Installationsverzeichnisses.

Importbibliotheken
Dateiname Beschreibung
Kapitel 6 Programmieren mit Embedded SQL
sqlca.h Wichtigste Header-Datei, wird in alle Embedded SQL-
Programme eingefügt. Die Datei fügt die Strukturdefinition für
den SQL-Kommunikationsbereich ein (SQL Communication
Area - SQLCA), sowie Prototypen für alle Embedded SQL-
Datenbankschnittstellenfunktionen.
sqlda.h SQL-Deskriptorbereich-Strukturdefinition, wird in Embedded
SQL-Programme eingefügt, die dynamisches SQL benutzen
sqldef.h Definition der Datentypen für die Embedded SQL-
Schnittstelle. Die Datei enthält auch Strukturdefinitionen und
Rückgabewerte, die gebraucht werden, um den
Datenbankserver aus einem C-Programm zu starten.
sqlerr.h Definitionen für Fehlercodes, die im Feld sqlcode des
SQLCA-Bereichs zurückgegeben werden
sqlstate.h Definitionen für ANSI/ISO SQL-Standardfehlerzustände, die
im Feld sqlstate des SQLCA-Bereichs zurückgegeben werden
pshpk1.h,
pshpk2.h,
poppk.h
Diese Header stellen sicher, dass das Strukturverdichten
(structure packing) korrekt gehandhabt wird. Sie unterstützen
die Compiler Watcom C/C++, Microsoft Visual C++, IBM
Visual Age und Borland C/C++.
Alle Importbibliotheken sind im Unterverzeichnis lib unter dem
Installationsunterverzeichnis von Adaptive Server Anywhere installiert. Die
Windows-Importbibliotheken sind zum Beispiel im Unterverzeichnis
win32\lib abgelegt.
Betriebssystem Compiler Importbibliothek
Windows Watcom C/C++ dblibtw.lib
Windows Microsoft Visual
C++
Windows CE Microsoft Visual
C++
dblibtm.lib
dblib8.lib
NetWare Watcom C/C++ dblib8.lib
Solaris (nicht verkettete
Anwendungen)
Solaris (verkettete
Anwendungen)
Alle Compiler libdblib8.so,
libdbtasks8.so
Alle Compiler libdblib8_r.so,
libdbtasks8_r.so
185

Überblick
Ein einfaches Beispiel
186
Die Bibliotheken libdbtasks8 werden von der Bibliothek libdblib8 aufgerufen.
Einige Compiler ermitteln die Position von libdbtasks8 automatisch, während
Sie dies für andere explizit angeben müssen.
Es folgt ein sehr einfaches Beispiel für ein Embedded SQL-Programm.
#include
EXEC SQL INCLUDE SQLCA;
main()
{
db_init( &sqlca );
EXEC SQL WHENEVER SQLERROR GOTO error;
EXEC SQL CONNECT "DBA" IDENTIFIED BY "SQL";
EXEC SQL UPDATE employee
SET emp_lname = ’Plankton’
WHERE emp_id = 195;
EXEC SQL COMMIT WORK;
EXEC SQL DISCONNECT;
db_fini( &sqlca );
return( 0 );
}
error:
printf( "update unsuccessful -- sqlcode = %ld.n",
sqlca.sqlcode );
db_fini( &sqlca );
return( -1 );
Dieses Beispiel stellt eine Verbindung mit der Datenbank her, aktualisiert
den Nachnamen des Angestellten mit der Nummer 195, schreibt die
Änderung fest und beendet das Programm. Es gibt praktisch keine
Interaktion zwischen dem SQL-Code und dem C-Code. C-Code wird in
diesem Beispiel ausschließlich zur Ablaufsteuerung benutzt. Die Anweisung
WHENEVER wird für Fehlerüberprüfung benutzt. Die Fehleraktion (in
diesem Beispiel GOTO) wird nach jeder SQL-Anweisung ausgeführt, die
einen Fehler verursacht.
$ Weitere Hinweise zum Abrufen von Daten finden Sie unter "Daten
abrufen" auf Seite 214.

Struktur von Embedded SQL-Programmen
Kapitel 6 Programmieren mit Embedded SQL
In Embedded-SQL-Programmen sind SQL-Anweisungen in normalen Coder
C++-Code eingebettet. Alle Embedded SQL-Anweisungen beginnen
mit den Worten EXEC SQL und enden mit einem Semikolon (;). Normale
Kommentare der Sprache C sind innerhalb von Embedded SQL-
Anweisungen erlaubt.
Der Quellcode eines C-Programms, das Embedded SQL benutzt, muss vor
der ersten Embedded SQL-Anweisung in der Quelldatei folgende Anweisung
enthalten:
EXEC SQL INCLUDE SQLCA;
Die erste Embedded SQL-Anweisung, die von dem C-Programm ausgeführt
wird, muss eine CONNECT-Anweisung sein. Die CONNECT-Anweisung
stellt eine Verbindung mit dem Datenbankserver her und spezifiziert die
Benutzer-ID für alle Anweisungen, die während der Verbindung ausgeführt
werden.
Die CONNECT-Anweisung muss als erste Embedded SQL-Anweisung
ausgeführt werden. Ausnahme: Einige Embedded SQL-Befehle erzeugen
keinen C-Code oder benötigen keine Verbindung mit der Datenbank. Diese
Befehle sind daher vor der CONNECT-Anweisung erlaubt. Die wichtigsten
sind die INCLUDE-Anweisung und die WHENEVER-Anweisung für die
Fehlerbehandlung.
Die Schnittstellenbibliothek dynamisch laden
Um Anwendungen zu entwickeln, die Funktionen aus DLLs aufrufen, ist es
üblich, die Anwendung mit einer Importbibliothek zu verknüpfen, die die
erforderlichen Funktionsdefinitionen enthält.
Dieser Abschnitt beschreibt eine alternative Methode, um Anwendungen für
Adaptive Server Anywhere zu entwickeln. Die Adaptive Server Anywhere
Schnittstellenbibliothek kann dynamisch geladen werden, ohne dass sie mit
der Importbibliothek verknüpft werden muss, und zwar mit Hilfe des Moduls
esqldll.c im Unterverzeichnis src Ihres Installationsverzeichnisses. Wir
empfehlen, esqldll.c zu benutzen, denn diese Methode ist einfacher
anzuwenden und findet die Schnittstellen-DLL zuverlässiger.
187

Überblick
Beispiel
188
v Um die Schnittstellen-DLL dynamisch zu laden, gehen Sie wie folgt
vor:
1 Ihr Programm muss db_init_dll aufrufen, um die DLL zu laden, und es
muss db_fini_dll aufrufen, um die DLL wieder freizugeben. db_init_dll
muss vor jeder anderen Funktion der Datenbankschnittstelle aufgerufen
werden. Nach db_fini_dll kann keine Funktion der
Datenbankschnittstelle mehr aufgerufen werden.
Sie müssen trotzdem die Bibliotheksfunktionen db_init und db_fini
aufrufen.
2 Fügen Sie vor der Anweisung EXEC SQL INCLUDE SQLCA mit
#include die Header-Datei esqldll.h ein, oder fügen Sie #include <
sqlca.h> in Ihr Embedded SQL-Programm ein.
3 Ein SQL OS (Operating System - Betriebssystem)-Makro muss definiert
werden. Die Header-Datei sqlca.h, die mit esqdll.c eingefügt wird,
versucht das passende Makro zu bestimmen und zu definieren. Bei
bestimmten Kombinationen von Betriebssystemen und Compilern kann
dieser Versuch allerdings fehlschlagen. In diesem Fall müssen Sie
entweder mit #define eine Definition am Beginn Ihrer Datei einfügen,
oder die Definition mit einer Compiler-Option liefern.
Makro Unterstützte Plattformen
_SQL_OS_WINNT Alle Windows-Betriebssysteme
_SQL_OS_UNIX UNIX
_SQL_OS_UNIX NetWare
4 Kompilieren Sie esqldll.c.
5 Statt mit der Importbibliothek verknüpfen Sie Ihre Embedded SQL-
Anwendung mit dem Objektmodul esqldll.obj.
Ein Beispielprogramm, aus dem ersichtlich ist, wie die
Schnittstellenbibliothek dynamisch geladen werden kann, finden Sie im
Unterverzeichnis Samples\ASA\ESQLDynamicLoad in Ihrem
SQL Anywhere-Verzeichnis. Der Quellcode befindet sich in
Samples\ASA\ESQLDynamicLoad\sample.sqc.
NetWare loadable Modules erstellen
Sie müssen den Watcom C/C++-Compiler, Version 10.6 oder 11.0
verwenden, um Embedded SQL-Programme als NetWare loadable Modules
(NLM) zu kompilieren.

v So erstellen Sie ein Embedded SQL-NLM:
Kapitel 6 Programmieren mit Embedded SQL
1 Auf einem Windows-basierten System müssen Sie die Embedded SQL-
Datei mit folgendem Befehl vorverarbeiten:
sqlpp -o NETWARE srcfile.sqc
Diese Anweisung erstellt eine Datei mit der Erweiterung .c.
2 Kompilieren Sie file.c mit dem Watcom-Compiler (10.6 oder 11.0) unter
Verwendung der Option /bt=netware.
3 Verknüpfen Sie die sich ergebende Objektdatei mit Hilfe des Watcom-
Linkers mit den folgenden Optionen:
FORMAT NOVELL
MODULE dblib8
OPTION CASEEXACT
IMPORT @dblib8.imp
LIBRARY dblib8.lib
Die Dateien dblib8.imp und dblib8.lib werden mit Adaptive Server
Anywhere ausgeliefert und befinden sich im Verzeichnis nlm. Für die
Zeilen IMPORT und LIBRARY ist eventuell der vollständige Suchpfad
notwendig.
189

Beispielprogramme mit Embedded SQL
Beispielprogramme mit Embedded SQL
190
Die Embedded SQL-Beispiele sind Teil der Adaptive Server Anywhere-
Installation. Sie werden im Unterverzeichnis Samples\ASA\C Ihres
Verzeichnisses SQL Anywhere gespeichert.
♦ Das Beispiel für statische Cursor Samples\ASA\C\cur.sqc zeigt die
Verwendung von statischen SQL-Anweisungen.
♦ Das Beispiel für dynamische Cursor und Embedded SQL
Samples\ASA\C\dcur.sqc zeigt die Verwendung von dynamischen SQL-
Anweisungen.
Um die Anzahl der Codezeilen zu verringern, die in den
Beispielprogrammen cur und dcur (und dem odbc-Beispiel) mehrmals
vorkommen, sind die Mainlines und die Druckfunktionen in einer separaten
Datei enthalten. Und zwar in mainch.c für zeichenbasierte Systeme und in
mainwin.c für fensterbasierte Systeme.
Die Beispielprogramme liefern jeweils folgende drei Routinen, die von den
Mainlines aufgerufen werden.
♦ WSQLEX_Init Stellt eine Verbindung zur Datenbank her und öffnet den
Cursor
♦ WSQLEX_Process_Command Verarbeitet Benutzerbefehle und
bedient den Cursor
♦ WSQLEX_Finish Schließt den Cursor und trennt die Verbindung zur
Datenbank
Die Funktion der Mainline ist:
1 Die Routine WSQLEX_Init aufzurufen
2 Sie ist eine Schleife, die Befehle vom Benutzer abholt, und
WSQL_Process_Command aufruft, bis der Benutzer das Programm
beendet
3 Die Routine WSQLEX_Finish aufzurufen
Die Verbindung mit der Datenbank wird mit dem Embedded SQL-Befehl
CONNECT hergestellt, der die erforderliche Benutzer-ID und das Kennwort
bereitstellt.
Zusätzlich zu diesen Beispielen können Sie als Teil von SQL Anywhere
Studio weitere Programme und Quelldateien finden, die Eigenschaften des
Servers für bestimmte Betriebssystemplattformen veranschaulichen.

Beispielprogramme erstellen
Beispielprogramme ausführen
Kapitel 6 Programmieren mit Embedded SQL
Dateien für den Aufbau der Beispielprogramme werden mit dem
Beispielcode geliefert.
♦ Bei Windows- und NetWare-Betriebssystemen mit Windows als Host-
Betriebssystem, verwenden Sie makeall.bat zum Kompilieren der
Beispielprogramme.
♦ Für UNIX verwenden Sie das Shell-Skript makeall.
♦ Für Windows CE verwenden Sie die dcur.dsp-Projektdatei für Microsoft
Visual C++.
Die Syntax des Befehls ist wie folgt:
makeall {Beispiel} {Plattform} {Compiler}
Der erste Parameter ist der Name des Beispielprogramms, das Sie
kompilieren wollen. Es ist eines der folgenden Programme:
♦ CUR Beispiel für statischen Cursor
♦ DCUR Beispiel für dynamischen Cursor
♦ ODBC Beispiel für ODBC
Der zweite Parameter ist die Zielplattform. Sie ist eines der folgenden
Programme:
♦ WINNT Für Windows kompilieren
♦ NETWARE Für NetWare NLM kompilieren
Der dritte Parameter ist der Compiler, mit dem das Programm kompiliert
werden soll. Der Compiler kann einer der folgenden sein:
♦ WC - Watcom C/C++
♦ MC Microsoft C
♦ BC Borland C
Die ausführbaren Dateien befinden sich gemeinsam mit dem Quellcode im
Verzeichnis Samples\ASA\C.
v So wird das Beispielprogramm für einen statischen Cursor
ausgeführt:
1 Starten Sie das Programm:
191

Beispielprogramme mit Embedded SQL
Windows Beispiele
192
♦ Starten Sie die Personal Server Beispieldatenbank von Adaptive
Server Anywhere.
♦ Führen Sie die Datei Samples\ASA\C\curwnt.exe aus.
2 Befolgen Sie die Anweisungen auf dem Bildschirm.
Die verschiedenen Befehle verändern einen Datenbankcursor und geben
Abfrageergebnisse am Bildschirm aus. Geben Sie einfach den
Buchstaben des Befehls ein, den Sie ausführen wollen. Bei einigen
Systemen müssen Sie anschließend die Eingabetaste (ENTER) drücken,
um den Befehl auszuführen.
v So wird das Beispielprogramm für einen dynamischen Cursor
ausgeführt:
1 Starten Sie das Programm:
♦ Führen Sie die Datei Samples\ASA\C\dcurwnt.exe aus.
2 Stellen Sie eine Verbindung zu einer Datenbank her:
♦ Alle Beispielprogramme haben eine Konsolen-Benutzeroberfläche
mit einer Eingabeaufforderung. Geben Sie die nachstehende
Zeichenfolge ein, damit eine Verbindung mit der Beispieldatenbank
hergestellt wird:
DSN=ASA 8.0 Sample
3 Wählen Sie eine Tabelle:
♦ Jedes einzelne Beispielprogramm fordert Sie auf, eine Tabelle
anzugeben. Wählen Sie eine der Tabellen in der Beispieldatenbank.
Sie können z.B. Customer oder Employee eingeben.
4 Befolgen Sie die Anweisungen auf dem Bildschirm.
Die verschiedenen Befehle verändern einen Datenbankcursor und geben
Abfrageergebnisse am Bildschirm aus. Geben Sie einfach den
Buchstaben des Befehls ein, den Sie ausführen wollen. Bei einigen
Systemen müssen Sie anschließend die Eingabetaste (ENTER) drücken,
um den Befehl auszuführen.
Die Windows-Versionen der Beispielprogramme sind echte Windows-
Programme. Um allerdings den Code für die Benutzeroberfläche nicht zu
kompliziert zu gestalten, wurden einige Vereinfachungen vorgenommen. Im
Besonderen schreiben diese Programme auf WM_PAINT-Nachrichten hin
nicht die Fenster neu, sondern nur die Eingabeaufforderung.

Beispiel für statischen Cursor
Beispiel für dynamischen Cursor
Kapitel 6 Programmieren mit Embedded SQL
Dieses Beispiel zeigt die Verwendung von Cursorn. Der Cursor, der hier
verwendet wurde, ruft bestimmte Informationen aus der Tabelle employee in
der Beispieldatenbank ab. Der Cursor wird statisch deklariert, das heißt, die
SQL-Anweisung, die die Information abruft, ist im Quellprogramm
enthalten. Dies ist ein gutes Beispiel, um zu lernen, wie Cursor
funktionieren. Das nächste Beispiel ("Beispiel für dynamischen Cursor" auf
Seite 193) konvertiert dieses erste Beispiel und verwendet dynamische SQL-
Anweisungen.
$ Wo der Quellcode zu finden ist und wie Sie dieses Beispielprogramm
kompilieren, finden Sie unter "Beispielprogramme mit Embedded SQL" auf
Seite 190.
Die open_cursor-Routine deklariert einen Cursor für den jeweiligen SQL-
Befehl und öffnet ebenfalls den Cursor.
Die print-Routine druckt eine Seite mit Informationen. Sie führt pagesizemal
eine Schleife aus, die eine einzelne Zeile vom Cursor abruft und druckt.
Beachten Sie, dass die Abrufroutine überprüft, ob eine Warnsituation
vorliegt (wie Row not found), und gegebenenfalls die erforderliche
Fehlermeldung ausgibt. Außerdem positioniert das Programm den Cursor
neu in der Zeile vor derjenigen, die am Anfang der aktuellen Datenseite
ausgegeben wurde.
Die Routinen move, top und bottom benutzen die geeignete Form der
FETCH-Anweisung, um den Cursor zu positionieren. Beachten Sie bitte,
dass diese Form der FETCH-Anweisung nicht tatsächlich die Daten abruft,
die Anweisung positioniert lediglich den Cursor. Außerdem wurde eine
allgemeine Routine namens move zur relativen Positionierung
implementiert, die abhängig vom Vorzeichen des Parameters den Cursor in
die eine oder andere Richtung bewegt.
Beendet der Benutzer das Programm, wird der Cursor geschlossen und die
Datenbankverbindung getrennt. Der Cursor wird durch eine ROLLBACK
WORK-Anweisung geschlossen und die Verbindung mit DISCONNECT
getrennt.
Dieses Beispiel veranschaulicht, wie Cursor für eine dynamische SQL-
SELECT-Anweisung verwendet werden. Es ist eine leichte Änderung des
vorangehenden Beispiels. Bitte sehen Sie sich das vorangehende "Beispiel
für statischen Cursor" auf Seite 193 an, bevor Sie sich mit diesem Beispiel
befassen.
193

Beispielprogramme mit Embedded SQL
194
$ Wo der Quellcode zu finden ist und wie Sie dieses Beispielprogramm
kompilieren, finden Sie unter "Beispielprogramme mit Embedded SQL" auf
Seite 190.
Das Programm dcur erlaubt dem Benutzer, mit dem n-Befehl eine Tabelle
auszuwählen, die er anschauen möchte. Das Programm zeigt dann so viele
Informationen aus dieser Tabelle an, wie auf den Bildschirm passen.
Wenn dieses Programm ausgeführt wird, erwartet es eine Zeichenfolge für
die Verbindung der Form:
uid=DBA;pwd=SQL;dbf=c:\Programme\Sybase\SQL
Anywhere 8\asademo.db
Das C-Programm mit Embedded SQL befindet sich im Unterverzeichnis
Samples\ASA\C Ihres SQL Anywhere-Installationsverzeichnisses.
Abgesehen von den Funktionen connect, open_cursor und print gleicht das
Programm weitgehend dem vorigen Beispiel.
Die Funktion connect benutzt die Embedded SQL-Schnittstellenfunktion
db_string_connect, um die Verbindung zur Datenbank herzustellen. Diese
Funktion liefert die zusätzliche Funktionalität, um die Zeichenfolge für die
Verbindung zu unterstützen, die benutzt wird, um die Verbindung zur
Datenbank herzustellen.
Die Routine open_cursor baut zuerst die SELECT-Anweisung auf:
SELECT * FROM Tabellenname
Wobei Tabellenname der Parameter ist, der an die Routine übergeben wird.
Dann bereitet sie eine dynamische SQL-Anweisung mit Hilfe dieser
Zeichenfolge vor.
Der Embedded SQL-Befehl DESCRIBE wird benutzt, um die Ergebnisse der
SELECT-Anweisung in die SQLDA-Struktur zu schreiben.
Größe der SQLDA
Zu Beginn wird die Größe der SQLDA geschätzt (3). Ist das nicht groß
genug, wird die tatsächliche Größe der Auswahlliste, die vom
Datenbankserver zurückgegeben wurde, benutzt, um eine SQLDA der
richtigen Größe zuzuweisen.
Die SQLDA-Struktur wird dann mit Puffern gefüllt, die Zeichenfolgen
enthalten, die wiederum für das Ergebnis der Abfrage stehen. Die Routine
fill_s_sqlda konvertiert alle Datentypen in der SQLDA in DT_STRING
und weist Puffer der passenden Größe zu.
Dann wird für diese Anweisung ein Cursor deklariert und geöffnet. Die
übrigen Routinen zum Bewegen und Schließen des Cursors sind die gleichen
wie beim vorhergehenden Beispiel.

Beispiele für Dienste
Kapitel 6 Programmieren mit Embedded SQL
Die fetch-Routine differiert leicht, sie schreibt die Ergebnisse in die
SQLDA-Struktur statt in eine Liste von Hostvariablen. Die print-Routine ist
leicht verändert, um Ergebnisse aus der SQLDA-Struktur bis zur vollen
Bildschirmbreite auszugeben. Die print-Routine benutzt auch die
Namenfelder des SQLDA-Bereichs, um Überschriften für die Spalten
auszugeben.
Die Beispielprogramme cur.sqc und dcur.sqc werden optional als Dienste
ausgeführt, wenn sie für eine Windows-Version kompiliert werden, auf
denen Dienste laufen können.
Die beiden Dateien, die den Beispielcode für Windows-Dienste enthalten,
sind die Quelldatei ntsvc.c und die Header-Datei ntsvc.h. Der Code
ermöglicht es, das damit gelinkte ausführbare Programm entweder als
normales Programm oder als Windows-Dienst auszuführen.
v Um eines der kompilierten Beispiele als Windows-Dienst
auszuführen, gehen Sie wie folgt vor:
1 Starten Sie Sybase Central und öffnen Sie das Verzeichnis "Dienste".
2 Wählen Sie einen Diensttyp aus der Beispielanwendung aus und klicken
Sie auf "OK".
3 Geben Sie einen Dienstnamen in das entsprechende Feld ein.
4 Wählen Sie das Beispielprogramm (curwnt.exe oder dcurwnt.exe) aus
dem Unterverzeichnis Samples\ASA|C im SQL Anywhere-
Installationsverzeichnis.
5 Klicken Sie auf "OK", um den Dienst zu installieren.
6 Klicken Sie auf "Start" im Hauptfenster, um den Dienst zu starten.
Wird das Programm als Dienst ausgeführt, zeigt es, falls möglich, die
normale Benutzeroberfläche. Die Ausgabe wird in das Ereignisprotokoll der
Anwendung geschrieben. Falls die Benutzeroberfläche nicht gestartet werden
kann, schreiben die Programme eine Seite in das Ereignisprotokoll der
Anwendung und halten an.
Diese Beispiele wurden mit dem Watcom C/C++ 10.5-Compiler und dem
Microsoft Visual C++-Compiler getestet.
195

Datentypen in Embedded SQL
Datentypen in Embedded SQL
196
Um Informationen zwischen einem Programm und dem Datenbankserver
austauschen zu können, müssen alle Datenelemente einen Datentyp haben.
Die Konstanten für Embedded SQL haben alle das Präfix DT_ und befinden
sich in der Header-Datei sqldef.h. Eine Hostvariable kann jeden der
unterstützten Datentypen haben. Sie können diese Datentypen auch in einer
SQLDA-Struktur benutzen, um Daten mit der Datenbank auszutauschen.
Sie können mit den DECL_-Makros in sqlca.h Variablen dieser Datentypen
definieren. Beispielsweise kann mit DECL_BIGINT eine Variable mit einem
BIGINT-Wert deklariert werden.
Folgende Datentypen werden von der Embedded SQL-
Programmierschnittstelle unterstützt:
♦ DT_BIT 8-Bit Ganzzahl mit Vorzeichen
♦ DT_SMALLINT 16-Bit-Ganzzahl mit Vorzeichen
♦ DT_UNSSMALLINT 16-Bit Ganzzahl ohne Vorzeichen
♦ DT_TINYINT 8-Bit Ganzzahl mit Vorzeichen
♦ DT_BIGINT 64-Bit Ganzzahl mit Vorzeichen
♦ DT_INT 32-Bit Ganzzahl mit Vorzeichen
♦ DT_UNSINT 16-Bit Ganzzahl ohne Vorzeichen
♦ DT_FLOAT 4-Byte-Gleitkommazahl
♦ DT_DOUBLE 8-Byte-Gleitkommazahl.
♦ DT_DECIMAL gepackte Dezimalzahl
typedef struct DECIMAL {
char array[1];
} DECIMAL;
♦ DT_STRING Mit Nullwert endende Zeichenfolge. Die Zeichenfolge
wird mit Leerzeichen aufgefüllt, wenn bei der Initialisierung der
Datenbank mit Leerzeichen aufgefüllte Zeichenfolgen verwendet
werden.
♦ DT_DATE Mit Nullwert endende Zeichenfolge, die ein gültiges Datum
repräsentiert
♦ DT_TIME Mit Nullwert endende Zeichenfolge, die eine gültige
Zeitangabe repräsentiert
♦ DT_TIMESTAMP Mit Nullwert endende Zeichenfolge, die einen
gültigen Zeitstempel repräsentiert

Kapitel 6 Programmieren mit Embedded SQL
♦ DT_FIXCHAR Zeichenfolge mit fester Länge, mit Leerzeichen aufgefüllt
♦ DT_VARCHAR Zeichenfolge variabler Länge, mit einem 2-Byte-
Längenfeld. Wenn Sie dem Datenbankserver Informationen liefern,
müssen Sie das Längenfeld setzen. Wenn Sie Informationen vom
Datenbankserver abholen, setzt der Datenbankserver das Längenfeld
(nicht aufgefüllt).
typedef struct VARCHAR {
unsigned short int len;
char array[1];
} VARCHAR;
♦ DT_LONGVARCHAR Lange Zeichendaten mit unterschiedlicher Länge.
Das Makro definiert eine Struktur folgendermaßen:
#define DECL_LONGVARCHAR( size ) \
struct { a_sql_uint32 array_len; \
a_sql_uint32 stored_len; \
a_sql_uint32 untrunc_len; \
char array[size+1];\
}
Die DECL_LONGVARCHAR-Struktur kann mit Daten über 32 Kbyte
verwendet werden. Umfangreiche Daten können auf einmal,
beziehungsweise in Abschnitten abgerufen werden, und zwar mit der
GET DATA-Anweisung. Sie können an den Server auf einmal,
beziehungsweise in Abschnitten übermittelt werden, indem sie an eine
Datenbankvariable mit der SET-Anweisung angehängt werden. Die
Daten werden nicht mit Nullwert abgeschlossen.
$ Weitere Hinweise finden Sie unter "Lange Werte senden und
abfragen" auf Seite 237.
♦ DT_BINARY Binärdaten variabler Länge mit einem 2-Byte-Längenfeld.
Wenn Sie dem Datenbankserver Informationen liefern, müssen Sie das
Längenfeld setzen. Wenn Sie Informationen vom Datenbankserver
abholen, setzt der Datenbankserver das Längenfeld.
typedef struct BINARY {
unsigned short int len;
char array[1];
} BINARY;
♦ DT_LONGBINARY Lange Binärdaten. Das Makro definiert eine Struktur
folgendermaßen:
#define DECL_LONGBINARY( size ) \
struct { a_sql_uint32 array_len; \
a_sql_uint32 stored_len; \
a_sql_uint32 untrunc_len; \
char array[size]; \
}
197

Datentypen in Embedded SQL
198
Die DECL_ LONGBINARY -Struktur kann mit Daten über 32 Kbyte
verwendet werden. Umfangreiche Daten können auf einmal
beziehungsweise in Abschnitten abgerufen werden, und zwar mit der
GET DATA-Anweisung. Sie können an den Server auf einmal,
beziehungsweise in Abschnitten übermittelt werden, indem sie an eine
Datenbankvariable mit der SET-Anweisung angehängt werden.
$ Weitere Hinweise finden Sie unter "Lange Werte senden und
abfragen" auf Seite 237.
♦ DT_TIMESTAMP_STRUCT SQLDATETIME-Struktur mit Feldern für
jeden Teil des Zeitstempels.
typedef struct sqldatetime {
unsigned short year; /* z. B. 1999 */
unsigned char month; /* 0-11 */
unsigned char day_of_week; /* 0-6 0=Sonntag */
unsigned short day_of_year; /* 0-365 */
unsigned char day; /* 1-31 */
unsigned char hour; /* 0-23 */
unsigned char minute; /* 0-59 */
unsigned char second; /* 0-59 */
unsigned long microsecond; /* 0-999999 */
} SQLDATETIME;
Die SQLDATETIME-Struktur kann benutzt werden, um Felder vom
Typ DATE, TIME und TIMESTAMP abzurufen (oder alles, was in
einen dieser Datentypen konvertiert werden kann). Anwendungen haben
häufig eigene Formate und einen eigenen Programmcode für Zeit und
Datum. Der Abruf von Daten in dieser Struktur, erleichtert dem
Programmierer den Umgang damit. Beachten Sie, dass Felder vom Typ
DATE, TIME und TIMESTAMP auch mit einem beliebigen
Zeichendatentyp abgerufen und aktualisiert werden können.
Wenn Sie eine SQLDATETIME-Struktur verwenden, um ein Datum,
eine Zeit oder einen Zeitstempel in die Datenbank einzugeben, werden
die Untersätze day_of_year und day_of_week ignoriert.
$ Näheres finden Sie unter den Datenbankoptionen
DATE_FORMAT, TIME_FORMAT, TIMESTAMP_FORMAT und
DATE_ORDER in "Datenbankoptionen" auf Seite 597 der
Dokumentation ASA Datenbankadministration.
♦ DT_VARIABLE mit Nullwert abgeschlossene Zeichenfolge. Die
Zeichenfolge muss der Name einer SQL-Variablen sein, deren Wert
vom Datenbankserver benutzt wird. Dieser Datentyp wird ausschließlich
benutzt, um Daten an den Datenbankserver zu liefern. Er kann nicht
benutzt werden, um Daten vom Datenbankserver abzurufen.

Datenbank-
Datentypen DATE
und TIME
Kapitel 6 Programmieren mit Embedded SQL
Die Strukturen sind in der Datei sqlca.h festgelegt. Die Datentypen
VARCHAR, BINARY und DECIMAL enthalten ein Array, das aus einem
einzigen Zeichen besteht und sind daher nicht geeignet, um Hostvariable zu
deklarieren. Sie sind dagegen nützlich, um Variable dynamisch zuzuweisen
oder Variable zu konvertieren (typecasting).
Die Embedded SQL-Schnittstelle bietet keine Datentypen, die den
verschiedenen Datenbank-Datentypen von DATE und TIME entsprechen.
Diese Datenbank-Datentypen werden alle entweder mit der Struktur
SQLDATETIME oder mit Zeichenfolgen abgerufen und aktualisiert.
$ Weitere Hinweise finden Sie unter "GET DATA-Anweisung [ESQL]"
auf Seite 471 der Dokumentation ASA SQL-Referenzhandbuch und "SET-
Anweisung" auf Seite 572 der Dokumentation ASA SQL-Referenzhandbuch.
199

Hostvariable benutzen
Hostvariable benutzen
Hostvariable deklarieren
Beispiel
200
Hostvariable sind C-Variable, die dem SQL-Präprozessor bekannt gemacht
werden. Hostvariable können benutzt werden, um Werte an den
Datenbankserver zu übergeben oder um Werte vom Datenbankserver
abzurufen.
Hostvariable sind recht einfach zu benutzen, aber sie unterliegen einigen
Einschränkungen. Dynamische SQL ist eine allgemeinere Art, um
Informationen mit dem Datenbankserver auszutauschen, mit Hilfe einer
Struktur namens SQL-Deskriptor-Bereich (SQL Descriptor Area - SQLDA).
Der SQL-Präprozessor erzeugt für jede einzelne Anweisung, in der
Hostvariablen verwendet werden, automatisch ein SQLDA.
$ Weitere Hinweise zu dynamischem SQL finden Sie unter "Statische
und dynamische SQL" auf Seite 223.
Hostvariable werden definiert, indem sie in einen Deklarationsabschnitt
eingefügt werden (declaration section). Wie in den Standards für IBM SAA
und ANSI Embedded SQL beschrieben, werden Hostvariable definiert,
indem eine normale C-Variable mit folgenden Zeilen eingeschlossen wird:
EXEC SQL BEGIN DECLARE SECTION;
/* Deklarationen der C-Variablen */
EXEC SQL END DECLARE SECTION;
Diese Hostvariable können dann an Stelle von konstanten Werten in jeder
SQL-Anweisung verwendet werden. Wenn der Datenbankserver den Befehl
ausführt, wird der Wert der Hostvariable benutzt. Beachten Sie, dass
Hostvariable nicht an Stelle von Tabellen- oder Spaltennamen verwendet
werden können: Dafür ist dynamisches SQL erforderlich. Der
Variablenname hat in einer SQL-Anweisung einen Doppelpunkt (:) als
Präfix, um ihn von anderen Namen zu unterscheiden, die in der Anweisung
erlaubt sind.
Ein standardmäßiger SQL-Präprozessor durchsucht nur den C-
Programmcode, der innerhalb des Deklarationsabschnitts steht. TYPEDEF-
Typen und –Strukturen sind also nicht zulässig. Variable können innerhalb
des DECLARE-Abschnitts initialisiert werden.
♦ Das folgende Beispiel zeigt den Gebrauch von Hostvariablen für einen
INSERT-Befehl. Die Variablen werden von dem Programm belegt und
dann in die Datenbank eingefügt:

C-Hostvariablentypen
Kapitel 6 Programmieren mit Embedded SQL
EXEC SQL BEGIN DECLARE SECTION;
long employee_number;
char employee_name[50];
char employee_initials[8];
char employee_phone[15];
EXEC SQL END DECLARE SECTION;
/* Das Programm belegt die Variablen mit passenden
Werten*/
*/
EXEC SQL INSERT INTO Employee
VALUES (:employee_number, :employee_name,
:employee_initials, :employee_phone );
$ Ein größeres Beispiel finden Sie unter "Beispiel für statischen
Cursor" auf Seite 193.
Nur eine begrenzte Anzahl von C-Datentypen werden als Hostvariable
unterstützt. Andererseits haben bestimmte Hostvariable keinen
entsprechenden Datentyp in C.
In der Header-Datei sqlca.h festgelegte Makros können dazu verwendet
werden, Hostvariable folgenden Typs zu definieren: VARCHAR,
FIXCHAR, BINARY, PACKED DECIMAL, LONG VARCHAR, LONG
BINARY oder SQLDATETIME. Sie werden wie folgt benutzt:
EXEC SQL BEGIN DECLARE SECTION;
DECL_VARCHAR( 10 ) v_varchar;
DECL_FIXCHAR( 10 ) v_fixchar;
DECL_LONGVARCHAR( 32678 ) v_longvarchar;
DECL_BINARY( 4000 ) v_binary;
DECL_LONGBINARY( 128000 ) v_longbinary;
DECL_DECIMAL( 10, 2 ) v_packed_decimal;
DECL_DATETIME v_datetime;
EXEC SQL END DECLARE SECTION;
Der Präprozessor erkennt diese Makros innerhalb eines
Deklarationsabschnitts und behandelt Variable ihrem Typ entsprechend.
Die folgende Tabelle zeigt die C-Variablentypen, die als Hostvariable erlaubt
sind und die entsprechenden Datentypen der Embedded SQL-Schnittstelle.
201

Hostvariable benutzen
202
C-Datentyp Datentyp der Embedded
SQL-Schnittstelle
short i;
short int i;
unsigned short int i;
long l;
long int l;
unsigned long int l;
Beschreibung
DT_SMALLINT 16-Bit-Ganzzahl mit
Vorzeichen
DT_INT 32-Bit-Ganzzahl mit
Vorzeichen
float f; DT_FLOAT 4-Byte-Gleitkomma
double d; DT_DOUBLE 8-Byte-Gleitkomma
DECL_DECIMAL(p,s) DT_DECIMAL(p,s) Gepackte Dezimalzahl
char a; /*n=1*/
DECL_FIXCHAR(n) a;
DECL_FIXCHAR a[n];
DT_FIXCHAR(n) Mit Leerzeichen aufgefüllte
Zeichenfolge fester Länge.
char a[n]; /*n>=1*/ DT_STRING(n) Mit Nullwert abgeschlossene
Zeichenfolge. Die
Zeichenfolge wird mit
Leerzeichen aufgefüllt, wenn
bei der Initialisierung der
Datenbank mit Leerzeichen
aufgefüllte Zeichenfolgen
verwendet werden.
char *a; DT_STRING(32767) Mit Nullwert abgeschlossene
Zeichenfolge
DECL_VARCHAR(n) a; DT_VARCHAR(n) Zeichenfolge mit variabler
Länge mit 2-Byte-
Längenfeld, nicht mit
Leerzeichen aufgefüllt
DECL_BINARY(n) a; DT_BINARY(n) Zeichenfolge mit variabler
Länge mit 2-Byte-
Längenfeld
DECL_DATETIME a; DT_TIMESTAMP_STRUCT SQLDATETIME-Struktur
DECL_LONGVARCHAR( n )
a;
DT_LONGVARCHAR Lange Zeichenfolgen von
variabler Länge mit drei 4-
Byte-Längenfeldern. Nicht
mit Leerzeichen aufgefüllt
oder mit Nullwert endend.
DECL_LONGBINARY( n ) a; DT_LONGBINARY Lange Binärdaten von
variabler Länge mit drei 4-
Byte-Längenfeldern. Nicht
mit Leerzeichen aufgefüllt.

Zeiger auf ein
Zeichen (pointer to
char)
Gültigkeitsbereich
von Hostvariablen
Hostvariable benutzen
Kapitel 6 Programmieren mit Embedded SQL
Von einer Hostvariable, die als pointer to char (char *a) deklariert ist,
nimmt die Datenbankschnittstelle an, dass sie 32.767 Bytes lang ist. Jede
Hostvariable vom Typ pointer to char, die benutzt wird, um Informationen
von der Datenbank abzurufen, muss auf einen Puffer zeigen, der groß genug
ist, um jeden Wert enthalten zu können, der möglicherweise von der
Datenbank zurückkommen könnte.
Dies kann recht gefährlich sein, denn jemand könnte die Definition der
Spalte in der Datenbank ändern, sodass sie größer wird als zu dem Zeitpunkt,
als das Programm geschrieben wurde. Dies wiederum könnte zu
unvorhersehbaren Speicherbelegungen und daraus resultierenden Problemen
führen. Falls Sie einen 16-Bit-Compiler benutzen, könnten die erforderlichen
32.767 Bytes einen Programm-Stack-Überlauf verursachen. Es ist daher
vorzuziehen, ein deklariertes Array zu benutzen, auch als Parameter für eine
Funktion, die einen pointer to char erwartet. So erkennt die PREPARE-
Anweisung die Größe des Arrays.
Die Deklaration einer Hostvariablen kann im Allgemeinen überall dort
stehen, wo auch eine C-Variablendeklaration stehen könnte. Das gilt auch für
den Parameterdeklarationsbereich einer C-Funktion. Die dort deklarierten C-
Variablen haben ihre normalen Aufgaben (sie stehen innerhalb des Blocks
zur Verfügung, in dem sie definiert sind). Da aber der SQL-Präprozessor den
C-Code nicht durchsucht, erkennt er keine C-Blöcke.
Für den SQL-Präprozessor sind Hostvariable globale Variable: zwei
Hostvariable können niemals den gleichen Namen haben.
Hostvariable können unter folgenden Umständen benutzt werden:
♦ In SELECT-, INSERT-, UPDATE- und DELETE-Anweisungen sind sie
überall dort erlaubt, wo eine Zahlen- oder Zeichenfolgenkonstante
erlaubt sind.
♦ In der INTO-Klausel einer SELECT oder FETCH-Anweisung
♦ Hostvariable können auch in Embedded SQL-Befehlen benutzt werden
an Stelle eines Anweisungsnamens, eines Cursornamens oder eines
Optionsnamens.
♦ Im Fall von CONNECT, DISCONNECT und SET CONNECT kann
eine Hostvariable benutzt werden an Stelle einer Benutzer-ID, eines
Kennworts, eines Verbindungsnamens, einer Verbindungszeichenfolge
oder eines Datenbank-Umgebungsnamens.
203

Hostvariable benutzen
Beispiele
Indikatorvariable
204
♦ Im Fall von SET OPTION und GET OPTION kann eine Hostvariable
benutzt werden an Stelle einer Benutzer-ID, eines Optionsnamens oder
eines Optionswerts.
♦ Hostvariable können nicht an Stelle eines Tabellennamens oder eines
Spaltennamens in einer Anweisung benutzt werden.
♦ Folgendes ist gültiges Embedded SQL:
INCLUDE SQLCA;
long SQLCODE;
sub1() {
char SQLSTATE[6];
exec SQL CREATE TABLE ...
}
♦ Folgendes ist nicht gültiges Embedded SQL:
INCLUDE SQLCA;
sub1() {
char SQLSTATE[6];
exec SQL CREATE TABLE ...
}
sub2() {
exec SQL DROP TABLE...
// Kein SQLSTATE im Gültigkeitsbereich dieser
Anweisung
}
♦ SQLSTATE und SQLCODE sind besonders wichtig. Der ISO/ANSI-
Standard verlangt, dass sie exakt wie folgt definiert werden:
long SQLCODE;
char SQLSTATE[6];
Indikatorvariable sind C-Variable, die zusätzliche Informationen liefern,
wenn Sie Daten abrufen oder speichern. Indikatorvariable werden in
folgenden Fällen benutzt:
♦ NULL-Werte Damit eine Anwendung mit NULL-Werten umgehen kann.
♦ Gekürzte Zeichenfolgen Damit eine Anwendung Fälle behandeln kann,
in denen ein abgerufener Wert gekürzt werden muss, um in eine
Hostvariable zu passen.
♦ Konvertierungsfehler Für Fehlerinformationen

Kapitel 6 Programmieren mit Embedded SQL
Eine Indikatorvariable ist eine Hostvariable vom Typ short int, die in einer
SQL-Anweisung unmittelbar auf eine normale Hostvariable folgt. In der
folgenden INSERT-Anweisung zum Beispiel ist :ind_phone eine
Indikatorvariable:
EXEC SQL INSERT INTO Employee
VALUES (:employee_number, :employee_name,
:employee_initials, :employee_phone:ind_phone );
Indikatorvariable für die Behandlung von Nullwerten verwenden
Indikatorvariable
verwenden, um
NULL einzufügen
In SQL-Daten repräsentiert NULL entweder ein unbekanntes Attribut oder
eine nicht anwendbare Information. NULL in SQL darf nicht verwechselt
werden mit der C-Konstante gleichen Namens (NULL). Die C-Konstante
NULL wird benutzt, um nicht initialisierte oder ungültige Zeiger zu
repräsentieren.
In der Dokumentation zum Adaptive Server Anywhere bezieht sich eine
Erwähnung von NULL immer auf die Bedeutung, die es in einer SQL-
Datenbank hat (wie oben definiert). Die gleichnamige C-Konstante wird
dagegen als Null-Zeiger bezeichnet (Groß-/Kleinschreibung).
NULL kann nicht für einen Wert stehen, der dem für die Spalte definierten
Typ entspricht. Um einen NULL-Wert an die Datenbank zu übergeben oder
NULL als Ergebnis von der Datenbank erhalten zu können, ist daher mehr
als eine normale Hostvariable erforderlich. Indikatorvariable werden für
diesen Zweck eingesetzt.
Eine INSERT-Anweisung könnte wie folgt eine Indikatorvariable einfügen:
EXEC SQL BEGIN DECLARE SECTION;
short int employee_number;
char employee_name[50];
char employee_initials[6];
char employee_phone[15];
short int ind_phone;
EXEC SQL END DECLARE SECTION;
/*
Das Programm belegt empnum, empname,
initials und homephone
*/
if( /* falls die Telefonnummer unbekannt ist */ ) {
ind_phone = -1;
} else {
ind_phone = 0;
}
EXEC SQL INSERT INTO Employee
VALUES (:employee_number, :employee_name,
:employee_initials, :employee_phone:ind_phone );
205

Hostvariable benutzen
Indikatorvariable
verwenden, um
NULL abzurufen
206
Hat die Indikatorvariable den Wert –1, wird NULL eingefügt. Hat sie den
Wert 0, wird der tatsächliche Wert von employee_phone eingefügt.
Indikatorvariable werden auch benutzt, um Daten von der Datenbank
abzurufen. Sie werden verwendet, um anzuzeigen, dass ein NULL-Wert
abgerufen wurde (der Indikator ist negativ). Falls ein NULL-Wert von der
Datenbank abgerufen wird und keine Indikatorvariable zur Verfügung steht,
wird ein Fehler erzeugt (SQLE_NO_INDICATOR). Fehler werden im
nächsten Abschnitt erklärt.
Indikatorvariable für gekürzte Werte verwenden
Indikatorvariable zeigen an, ob irgendwelche abgerufenen Werte gekürzt
wurden, um in eine Hostvariable zu passen. So können Anwendungen mit
dem Kürzen von Werten angemessen umgehen.
Falls ein Wert beim Abrufen gekürzt wurde, wird die Indikatorvariable mit
einem positiven Wert belegt. Dieser Wert gibt die Länge an, den der aus der
Datenbank abgerufene Wert vor dem Kürzen hatte. Ist die Länge des
gekürzten Werts größer als 32.767, hat die Indikatorvariable den Wert
32.767.
Indikatorwerte für Konvertierungsfehler verwenden
Als Voreinstellung ist die Datenbankoption CONVERSION_ERROR auf
ON gesetzt, jede fehlgeschlagene Datentypkonvertierung führt zu einem
Fehler und es wird keine Zeile zurückgegeben.
Sie können Indikatorvariable verwenden, um festzustellen, in welcher Spalte
eine fehlgeschlagene Datentypkonvertierung auftrat. Wenn Sie die
Datenbankoption CONVERSION_ERROR auf OFF setzen, erzeugt jede
fehlgeschlagene Datentypkonvertierung (statt eines Fehlers) die Warnung
CANNOT_CONVERT. Hat die Spalte, in der der Konvertierungsfehler
auftrat, eine Indikatorvariable, wird diese Variable mit –2 belegt.
Wenn Sie beim Einfügen von Daten in die Datenbank die Datenbankoption
CONVERSION_ERROR auf OFF setzen, wird der Wert NULL eingefügt,
falls eine fehlgeschlagene Konvertierung auftritt.
Zusammenfassung: Werte für Indikatorvariable
Folgende Tabelle bietet eine Zusammenfassung zum Gebrauch von
Indikatorvariablen.

Indikatorwert
Wert, an die
Datenbank
übergeben
Kapitel 6 Programmieren mit Embedded SQL
Wert von der Datenbank erhalten
> 0 Wert der Hostvariable Der abgerufene Wert wurde gekürzt -
tatsächliche Länge in der
Indikatorvariable
0 Wert der Hostvariable Entweder das Abrufen war erfolgreich
oder CONVERSION_ERROR ist auf
ON gesetzt.
–1 Nullwert Ergebnis NULL
–2 Nullwert Konvertierungsfehler (nur wenn
CONVERSION_ERROR auf OFF
gesetzt ist). SQLCODE gibt die
Warnung CANNOT_CONVERT aus.
< –2 Nullwert Ergebnis NULL
$ Weitere Informationen über das Abrufen von long-Werten finden Sie
unter "GET DATA-Anweisung [ESQL]" auf Seite 471 der Dokumentation
ASA SQL-Referenzhandbuch.
207

SQL-Kommunikationsbereich (SQLCA)
SQL-Kommunikationsbereich (SQLCA)
SQLCA-Bereich
bietet Fehlercodes
SQLCA-Felder
208
Der SQL-Kommunikationsbereich (SQL Communication Area - SQLCA)
ist ein Speicherbereich, der bei jeder Datenbankanforderung benutzt wird,
um Statistiken und Fehlermeldungen von der Anwendung zum
Datenbankserver zu übermitteln und umgekehrt. Der SQLCA-Bereich wird
als Handle für die Kommunikationsverbindung zwischen Anwendung und
Datenbank benutzt. Er wird allen Datenbank-Bibliotheksfunktionen
übergeben, die mit dem Datenbankserver kommunizieren müssen. Er wird
implizit allen Embedded SQL-Anweisungen übergeben.
Eine globale SQLCA-Variable ist in der Schnittstellenbibliothek definiert.
Der Präprozessor erzeugt eine externe Referenz auf die globale SQLCA-
Variable und eine externe Referenz auf einen Zeiger auf die Variable. Die
externe Referenz heißt sqlca und ist vom Typ SQLCA. Der Zeiger heißt
sqlcaptr. Die globale Variable selbst wird in der Importbibliothek deklariert.
Der SQLCA-Bereich ist in der Header-Datei sqlca.h definiert, die im
Unterverzeichnis h Ihres Installationsverzeichnisses enthalten ist.
Sie benutzen den SQLCA-Bereich, um auf einen bestimmten Fehlercode zu
testen. Die Felder sqlcode und sqlstate enthalten Fehlercodes, falls eine
Anforderung an die Datenbank einen Fehler hervorrief (siehe unten). Einige
C-Makros sind definiert, um die Felder sqlcode, sqlstate und einige weitere
anzusprechen.
Die SQLCA-Felder haben folgende Bedeutung:
♦ sqlcaid 8-Byte Zeichenfeld, das die Zeichenfolge SQLCA enthält (zur
Identifizierung der SQLCA-Struktur). Dieses Feld unterstützt die
Fehlersuche, wenn Sie Speicherinhalte untersuchen.
♦ sqlcabc Ganzzahl (long integer), die die Länge der SQLCA-Struktur
enthält (136 Bytes)
♦ sqlcode Eine Ganzzahl ("long integer"), die den Fehlercode angibt,
wenn die Datenbank einen Fehler bei einer Anforderung feststellt.
Definitionen für die Fehlercodes befinden sich in der Header-Datei
sqlerr.h. Bei einer erfolgreichen Operation ist der Fehlercode 0 (Null),
bei einer Warnung ist er positiv und bei einem Fehler ist er negativ.
$ Eine vollständige Auflistung der Fehlercodes finden Sie unter
"Datenbank-Fehlermeldungen" auf Seite 1 der Dokumentation ASA
Fehlermeldungen.

sqlerror-Array
Kapitel 6 Programmieren mit Embedded SQL
♦ sqlerrml Die Länge der Daten im Feld sqlerrmc
♦ sqlerrmc Kann eine oder mehrere Zeichenfolgen enthalten, die in eine
Fehlermeldung einzufügen sind. Einige Fehlermeldungen enthalten eine
oder mehr Platzhalter-Zeichenfolgen (%1, %2, …), die durch die
Zeichenfolge in diesem Feld ersetzt werden.
Wenn zum Beispiel ein Fehler Table Not Found erzeugt wird, enthält
sqlerrmc den Tabellennamen, der dann an passender Stelle in die
Fehlermeldung eingefügt wird.
$ Eine vollständige Auflistung der Fehlermeldungen finden Sie unter
"Datenbank-Fehlermeldungen" auf Seite 1 der Dokumentation ASA
Fehlermeldungen.
♦ sqlerrp Reserviert
♦ sqlerrd Array von Ganzzahlen ("long integer")
♦ sqlwarn Reserviert
♦ sqlstate SQLSTATE-Statuswert. Der ANSI SQL-Standard (SQL-92)
definiert einen neuen Rückgabewerttyp für SQL-Anweisungen,
zusätzlich zu dem in früheren Standards definierten SQLCODE. Der
Wert von SQLSTATE ist immer eine fünf Zeichen lange mit 0 (Null)
abgeschlossene Zeichenfolge, aufgeteilt in eine zwei Zeichen lange
Klasse (die ersten zwei Zeichen) und eine drei Zeichen lange
Unterklasse. Jedes Zeichen kann eine Ziffer von 0 bis 9 sein oder ein
Großbuchstabe von A bis Z.
Jede Klasse oder Unterklasse, die mit 0 bis 4 oder A bis H beginnt, ist
durch den SQL-Standard definiert. Andere Klassen und Unterklassen
sind durch die Implementierung definiert. Hat SQLSTATE den Wert
'00000', ist kein Fehler und keine Warnung aufgetreten.
$ Weitere SQLSTATE-Werte finden Sie unter "Datenbank-
Fehlermeldungen" auf Seite 1 der Dokumentation ASA
Fehlermeldungen.
Das Array sqlerror besteht aus folgenden Elementen:
♦ sqlerrd[1] (SQLIOCOUNT) Die Anzahl der Eingabe/Ausgabe-Vorgänge,
die erforderlich waren, um einen Befehl auszuführen.
Die Datenbank beginnt diese Zählung nicht mit 0 (Null) für jeden
Befehl. Ihr Programm kann diese Variable vor der Ausführung einer
Befehlssequenz auf 0 (Null) setzen. Nach dem letzten Befehl zeigt der
Wert der Variablen die Gesamtzahl der Eingabe/Ausgabe-Vorgänge für
die gesamte Befehlssequenz an.
♦ sqlerrd[2] (SQLCOUNT) Der Wert dieses Felds hängt davon ab, welche
Anweisung ausgeführt wurde.
209

SQL-Kommunikationsbereich (SQLCA)
210
♦ INSERT-, UPDATE-, PUT und DELETE-Anweisungen Anzahl der
Zeilen, die von der Anweisung betroffen waren
Bei Cursor OPEN wird das Feld belegt entweder mit der
tatsächlichen Anzahl der Zeilen im Cursor (ein Wert größer als oder
gleich 0) oder mit einer Schätzung der Anzahl (ein negative Zahl,
deren absoluter Wert die Schätzung ist). Es wird sich um die
tatsächliche Anzahl der Zeilen handeln, wenn der Datenbankserver
sie errechnen kann, ohne die Zeilen zu zählen. Die Datenbank kann
auch so konfiguriert werden, dass sie immer die tatsächliche Anzahl
der Zeilen liefert (mit der Option ROW_COUNT).
♦ FETCH Cursor-Anweisung Das Feld SQLCOUNT wird belegt,
falls eine SQLE_NOTFOUND-Warnung zurückgegeben wird. Es
enthält die Anzahl der Zeilen, um die eine FETCH RELATIVEoder
eine FETCH ABSOLUTE-Anweisung den Bereich der
möglichen Cursorpositionen überschritten hat. (Ein Cursor kann
sich auf einer Zeile, vor der ersten Zeile oder nach der letzten Zeile
befinden.) Bei weiten Abrufen entspricht SQLCOUNT der Anzahl
der tatsächlich abgerufenen Zeilen und ist kleiner oder gleich der
Anzahl der angeforderten Zeilen. Während eines weiten Abrufs
wird SQLE_NOTFOUND nicht festgelegt.
$ Weitere Hinweise zu weiten Abrufen finden Sie unter "Mehr
als eine Zeile auf einmal abrufen" auf Seite 218.
Der Wert ist 0 (Null), falls die Zeile nicht gefunden wurde, die
Position aber gültig ist, zum Beispiel wenn FETCH RELATIVE 1
ausgeführt wird, und die Position ist auf der letzten Zeile eines
Cursors. Der Wert ist positiv, falls das Abrufen jenseits des Cursors
versucht wurde, und negativ, falls das Abrufen vor dem Anfang des
Cursors versucht wurde.
♦ GET DATA-Anweisung Das Feld SQLCOUNT enthält die
tatsächliche Länge des Werts.
♦ DESCRIBE-Anweisung In der Klausel WITH VARIABLE
RESULT, die benutzt wird, um Prozeduren zu beschreiben, die
mehr als ein Ergebnis haben können, wird SQLCOUNT auf einen
der folgenden Werte gesetzt:
♦ 0 Die Ergebnismenge kann sich ändern: der Prozeduraufruf
sollte nach jeder OPEN-Anweisung neu beschrieben werden.
♦ 1 Die Ergebnismenge ist unveränderlich. Eine erneute
Beschreibung ist nicht erforderlich.
Im Fall eines Syntaxfehlers, SQLE_SYNTAX_ERROR, enthält
dieses Feld die ungefähre Position des Zeichens innerhalb der
Befehlszeichenfolge, wo der Fehler erkannt wurde.

Kapitel 6 Programmieren mit Embedded SQL
♦ sqlerrd[3] (SQLIOESTIMATE) Die geschätzte Anzahl der
Eingabe/Ausgabe-Vorgänge für den Abschluss des Befehls. Dieses Feld
wird bei einem OPEN- oder EXPLAIN-Befehl belegt.
SQLCA-Verwaltung für Code mit mehreren Threads oder
"reentrant"-Code
Sie können Embedded SQL-Anweisungen in Code mit mehreren Threads
oder reentrant-Code benutzen. Wenn Sie allerdings eine einfache
Verbindung benutzen, sind Sie auf eine aktive Anforderung pro Verbindung
beschränkt. In einer Applikation mit mehreren Threads sollten Sie es
vermeiden, für alle Threads dieselbe Verbindung zur Datenbank benutzen,
außer wenn Sie Semaphore für die Zugriffssteuerung benutzen.
Sie können ohne Einschränkung für jeden Thread, der die Datenbank
benutzen will, eine separate Verbindung öffnen. Der SQLCA-Bereich wird
von der Laufzeitbibliothek benutzt, um zwischen den verschiedenen Thread-
Kontexten zu unterscheiden. Daher braucht jeder Thread, der eine
Verbindung zur Datenbank benötigt, seinen eigenen SQCLA-Bereich.
Jede einzelne Datenbankverbindung ist nur von einem einzelnen SQLCA-
Bereich aus zugänglich, außer bei der Abbruchanweisung, die von einem
separaten Thread aus ausgegeben werden muss.
$ Hinweise zur Abbruchanforderung finden Sie unter "Anforderungs-
Management implementieren" auf Seite 247.
Mehrere SQLCA-Bereiche benutzen
v Um mehrere SQLCA-Bereiche in Ihrer Anwendung zu benutzen,
gehen Sie wie folgt vor:
1 Sie müssen für den SQL-Präprozessor den Befehlszeilenschalter
benutzen, der reentrant-Code erzeugt (-r). Der reentrant-Code ist etwas
umfangreicher und etwas langsamer, weil keine statisch initialisierten
globalen Variablen benutzt werden können. Diese Auswirkungen sind
allerdings minimal.
2 Jeder SQLCA-Bereich, der in Ihrem Programm benutzt wird, muss mit
einem Aufruf von db_init initialisiert und am Ende mit einem Aufruf
von db_fini wieder freigegeben werden.
211

SQL-Kommunikationsbereich (SQLCA)
212
Vorsicht
Wird unter NetWare nicht db_fini für jedes db_init aufgerufen,
kann das den Datenbankserver und den NetWare-Dateiserver zum
Absturz bringen.
3 Die Embedded SQL-Anweisung SET SQLCA ("SET SQLCA-
Anweisung [ESQL]" auf Seite 588 der Dokumentation ASA SQL-
Referenzhandbuch) wird verwendet, um den SQL-Präprozessor
anzuweisen, einen anderen SQLCA-Bereich für
Datenbankanforderungen zu benutzen. Ein Beispiel ist die folgende
Anweisung: EXEC SQL SET SQLCA 'task_data->sqlca' wird zu Beginn
eines Programms oder in einer Header-Datei benutzt, um SQLCA-
Referenzen so einzustellen, dass sie auf Task-spezifische Daten zeigen.
Diese Anweisung erzeugt keinen Code und hat daher keinen Einfluss auf
die Performance. Sie ändert den Status innerhalb des Präprozessors,
sodass jede Referenz auf den SQLCA-Bereich die angegebene
Zeichenfolge benutzt.
$ Weitere Hinweise zum Erstellen von SQLCA-Bereichen finden Sie
unter "SET SQLCA-Anweisung [ESQL]" auf Seite 588 der Dokumentation
ASA SQL-Referenzhandbuch.
In welchen Fällen Sie mehrere SQLCA-Bereiche benutzen
Sie können die Unterstützung mehrfacher SQLCAs in jeder der unterstützten
Embedded SQL-Umgebungen benutzen, sie ist jedoch nur für reentrant-Code
erforderlich.
Die folgende Aufstellung gibt einen Überblick über die Umgebungen, in
denen mehrfache SQLCAs benutzt werden müssen:
♦ Anwendungen mit mehreren Threads Falls mehr als ein Thread
denselben SQLCA-Bereich benutzt, kann ein Kontextwechsel
verursachen, dass zum gleichen Zeitpunkt mehr als ein Thread auf den
SQLCA-Bereich zugreift. Jeder Thread braucht seinen eigenen SQLCA-
Bereich. Das kann auch geschehen, wenn Sie eine DLL haben, die
Embedded SQL benutzt und die von mehr als einem Thread in Ihrer
Anwendung aufgerufen wird.

Kapitel 6 Programmieren mit Embedded SQL
♦ Dynamische Verknüpfungsbibliotheken (DLL) und gemeinsam
genutzte Bibliotheken Eine DLL hat nur ein Datensegment. Während
der Datenbankserver eine Anforderung von einer Anwendung bearbeitet,
könnte er die Kontrolle an eine andere Anwendung übergeben, die
ebenfalls eine Anforderung an den Datenbankserver richtet. Falls Ihre
DLL den globalen SQLCA-Bereich benutzt, greifen beide
Anwendungen gleichzeitig darauf zu. Jede Windows-Anwendung
braucht ihren eigenen SQLCA-Bereich.
♦ Eine DLL mit einem Datensegment Eine DLL kann mit nur einem
Datensegment erstellt werden oder mit einem Datensegment für jede
Anwendung. Falls Ihre DLL nur ein Datensegment hat, dürfen Sie aus
dem gleichen Grund nicht den globalen SQLCA-Bereich benutzen, aus
dem eine DLL den globalen SQLCA-Bereich nicht benutzen kann. Jede
Anwendung braucht ihren eigenen SQLCA-Bereich.
Verbindungsverwaltung mit mehreren SQLCA-Bereichen
Sie müssen nicht mehrere SQLCA-Bereiche benutzen, um Verbindungen zu
mehr als einer Datenbank herzustellen oder um mehr als eine Verbindung zu
einer einzelnen Datenbank zu halten.
Jeder SQLCA-Bereich kann eine namenlose Verbindung haben. Jeder
SQLCA-Bereich hat eine aktive oder aktuelle Verbindung (siehe "SET
CONNECTION-Anweisung [Interactive SQL]" auf Seite 578 der
Dokumentation ASA SQL-Referenzhandbuch). Alle Vorgänge, die sich auf
eine angegebene Datenbankverbindung beziehen, müssen denselben
SQLCA-Bereich benutzen, der verwendet wurde, als die Verbindung
geöffnet wurde.
Datensatz sperren
Vorgänge, die sich auf verschiedene Verbindungen beziehen, sind den
normalen Datensatz-Sperrmechanismen unterworfen und können sich
gegenseitig blockieren oder möglicherweise zu einer Deadlock-Situation
führen. Information über Sperrmechanismen finden Sie im Kapitel
"Transaktionen und Isolationsstufen verwenden" auf Seite 99 der
Dokumentation ASA SQL-Benutzerhandbuch.
213

Daten abrufen
Daten abrufen
214
In Embedded SQL werden Daten mit der Anweisung SELECT abgerufen.
Dabei werden zwei Fälle unterschieden:
♦ Die SELECT-Anweisung gibt mehr als eine Zeile zurück Verwenden
Sie eine INTO-Klausel, damit die zurückgegebenen Werte direkt
Hostvariablen zugeordnet werden.
$ Hinweise dazu finden Sie unter "SELECT-Anweisungen, die
höchstens eine Zeile zurückgeben" auf Seite 214.
♦ Die SELECT-Anweisung kann mehrere Zeilen zurückgeben
Verwenden Sie Cursor zur Verwaltung der Zeilen in der Ergebnismenge.
$ Weitere Hinweise finden Sie unter "Cursor in Embedded SQL
verwenden" auf Seite 215.
$ LONG VARCHAR- und LONG BINARY-Datentypen werden
unterschiedlich zu anderen Datentypen behandelt. Weitere Hinweise finden
Sie unter "LONG-Daten abrufen" auf Seite 238.
SELECT-Anweisungen, die höchstens eine Zeile zurückgeben
Beispiel
Eine einzeilige Abfrage fragt höchstens eine Zeile von der Datenbank ab. In
einer SELECT-Anweisung für eine einzeilige Abfrage befindet sich eine
INTO-Klausel nach der Auswahlliste und vor der FROM-Klausel. Die
INTO-Klausel enthält eine Liste der Hostvariablen, die die Werte der
Auswahllisten-Elemente übernehmen sollen. Die Anzahl der Hostvariablen
muss mit der Anzahl der Auswahllisten-Elemente übereinstimmen. Die
Hostvariable können von Indikatorvariablen gefolgt sein, um NULL-
Ergebnisse anzuzeigen.
Sobald die SELECT-Anweisung ausgeführt wird, ruft der Datenbankserver
die Ergebnisse ab und schreibt sie in die Hostvariable. Falls die
Abfrageergebnisse mehr als eine Zeile enthalten, gibt der Datenbankserver
einen Fehler zurück.
Falls das Abfrageergebnis ist, dass keine Zeile ausgewählt ist, wird eine Row
Not Found-Warnung zurückgeben. Fehler und Warnungen werden in der
SQLCA-Struktur zurückgegeben, wie beschrieben in "SQL-
Kommunikationsbereich (SQLCA)" auf Seite 208.
Folgendes Code-Fragment gibt zum Beispiel 1 zurück, falls eine Zeile der
Tabelle "employee" erfolgreich abgerufen wird, 0, falls die Zeile nicht
existiert, und –1, falls ein Fehler auftritt.
EXEC SQL BEGIN DECLARE SECTION;

Cursor in Embedded SQL verwenden
Kapitel 6 Programmieren mit Embedded SQL
long emp_id;
char name[41];
char sex;
char birthdate[15];
short int ind_birthdate;
EXEC SQL END DECLARE SECTION;
. . .
int find_employee( long employee )
{
emp_id = employee;
EXEC SQL SELECT emp_fname ||
’ ’ || emp_lname, sex, birth_date
INTO :name, :sex,
:birthdate:ind_birthdate
FROM "DBA".employee
WHERE emp_id = :emp_id;
if( SQLCODE == SQLE_NOTFOUND ) {
return( 0 ); /* ’employee’ wurde nicht gefunden
*/
} else if( SQLCODE < 0 ) {
return( -1 ); /* Fehler */
} else {
return( 1 ); /* gefunden */
}
}
Ein Cursor wird benutzt, um Zeilen aus einer Abfrage abzurufen, die
mehrere Zeilen in Ihrer Ergebnismenge hat. Ein Cursor ist ein Handle oder
ein Name (identifier) für die SQL-Abfrage und eine Position innerhalb der
Ergebnismenge.
$ Eine Einführung zu Cursorn finden Sie unter "Mit Cursorn arbeiten"
auf Seite 20.
v So verwalten Sie einen Cursor in Embedded SQL:
1 Deklarieren Sie einen Cursor für eine bestimmte SELECT-Anweisung
mit der DECLARE-Anweisung.
2 Öffnen Sie den Cursor mit der Anweisung OPEN.
3 Rufen Sie die Ergebnisse Zeile für Zeile aus dem Cursor ab mit der
FETCH-Anweisung.
4 Wiederholen Sie das Abrufen der Zeilen, bis die Warnung Row Not
Found zurückgegeben wird.
215

Daten abrufen
Cursor
positionieren
216
Fehler und Warnungen werden in der SQLCA-Struktur zurückgegeben,
wie in "SQL-Kommunikationsbereich (SQLCA)" auf Seite 208
beschrieben.
5 Schließen Sie den Cursor mit der CLOSE-Anweisung.
Als Voreinstellung werden Cursor automatisch am Ende der Transaktion
geschlossen (bei COMMIT oder ROLLBACK). Cursor, die mit einer WITH
HOLD-Klausel geöffnet werden, bleiben für folgende Transaktionen
geöffnet, bis sie explizit geschlossen werden.
Das folgende einfache Beispiel zeigt den Gebrauch von Cursorn:
void print_employees( void )
{
EXEC SQL BEGIN DECLARE SECTION;
char name[50];
char sex;
char birthdate[15];
short int ind_birthdate;
EXEC SQL END DECLARE SECTION;
EXEC SQL DECLARE C1 CURSOR FOR
SELECT emp_fname || ’ ’ || emp_lname,
sex, birth_date
FROM "DBA".employee;
EXEC SQL OPEN C1;
for( ;; ) {
EXEC SQL FETCH C1 INTO :name, :sex,
:birthdate:ind_birthdate;
if( SQLCODE == SQLE_NOTFOUND ) {
break;
} else if( SQLCODE < 0 ) {
break;
}
if( ind_birthdate < 0 ) {
strcpy( birthdate, "UNKNOWN" );
}
printf( "Name: %s Sex: %c Birthdate:
%s.n",name, sex, birthdate );
}
EXEC SQL CLOSE C1;
}
$ Vollständige Beispiele für Cursor finden Sie unter "Beispiel für
statischen Cursor" auf Seite 193 und "Beispiel für dynamischen Cursor" auf
Seite 193.
Ein Cursor wird an einer von drei Stellen positioniert:
♦ Auf einer Zeile
♦ Vor der ersten Zeile

Cursorpositionierungsprobleme
♦ Nach der letzten Zeile
Kapitel 6 Programmieren mit Embedded SQL
Wird ein Cursor geöffnet, ist er vor der ersten Zeile positioniert. Die
Cursorposition kann mit dem FETCH-Befehl verschoben werden (siehe
"FETCH-Anweisung [ESQL] [GP]" auf Seite 458 der Dokumentation ASA
SQL-Referenzhandbuch ). Er kann absolut positioniert werden, entweder
bezogen auf den Anfang oder auf das Ende des Abfrageergebnisses. Er kann
auch relativ zur aktuellen Cursorposition verschoben werden.
Mit speziellen positioned-Versionen der Anweisungen UPDATE und
DELETE können Sie die Zeile an der aktuellen Cursor-Position aktualisieren
oder löschen. Ist der Cursor vor der ersten Zeile oder nach der letzten Zeile
positioniert, wird der Fehler No Current Row of Cursor zurückgeben.
Die Anweisung PUT kann verwendet werden, um eine Zeile in einen Cursor
einzufügen.
Einfügungen und einige Aktualisierungen zu DYNAMIC SCROLL-Cursorn
können Probleme bei der Cursorpositionierung verursachen. Der
Datenbankserver platziert eingefügte Zeilen an unvorhersehbaren Positionen
innerhalb eines Cursors, falls die SELECT-Anweisung keine ORDER BY-
Klausel hat. In einigen Fällen erscheint die eingefügte Zeile überhaupt nicht,
bis der Cursor geschlossen und wieder geöffnet wurde.
217

Daten abrufen
218
Bei Adaptive Server Anywhere tritt dies auf, wenn zum Öffnen eines
Cursors eine temporäre Tabelle erstellt werden musste.
$ Eine Beschreibung finden Sie unter "Arbeitstabellen in der
Abfrageverarbeitung verwenden" auf Seite 178 der Dokumentation ASA
SQL-Benutzerhandbuch.
Die UPDATE-Anweisung kann bewirken, dass sich eine Zeile im Cursor
verschiebt. Das passiert, wenn der Cursor eine ORDER BY-Klausel hat, die
einen vorhandenen Index benutzt (es wird keine temporäre Tabelle erstellt).
Mehr als eine Zeile auf einmal abrufen
Beispiel
Die FETCH-Anweisung kann so modifiziert werden, dass sie mehr als eine
Zeile auf einmal abruft. Das kann die Performance verbessern. Man nennt
diese Methode mehrzeiliges Abrufen (wide fetch) oder auch Array-
Abrufen (array fetch).
$ Der Adaptive Server Anywhere unterstützt auch mehrzeiliges Speichern
(wide puts) und mehrzeiliges Einfügen (wide inserts). Hinweise dazu finden
Sie unter "PUT-Anweisung [ESQL]" auf Seite 538 der Dokumentation ASA
SQL-Referenzhandbuch und "EXECUTE-Anweisung [ESQL]" auf Seite 449
der Dokumentation ASA SQL-Referenzhandbuch.
Um mehrzeiliges Abrufen (wide fetches) in Embedded SQL zu verwenden,
fügen Sie die Abrufanweisung wie folgt in Ihren Code ein:
EXEC SQL FETCH . . . ARRAY nnn
Dabei ist ARRAY nnn das letzte Element der FETCH-Anweisung. Die
Abrufanzahl nnn kann eine Hostvariable sein. Die Anzahl der Variablen im
SQLDA-Bereich muss das Produkt aus nnn multipliziert mit der Anzahl der
Spalten pro Zeile sein. Die erste Zeile wird in die SQLDA-Variablen von 0
bis (Anzahl der Spalten pro Zeile)-1 geschrieben, und so fort.
Jede Spalte muss in jeder Zeile des SQLDA-Bereichs vom selben Typ sein,
sonst wird der Fehler SQLDA_INCONSISTENT ausgegeben.
Der Server gibt in SQLCOUNT die Anzahl der Datensätze zurück, die
abgerufen wurden. Diese Anzahl ist immer größer als 0 (Null), außer wenn
ein Fehler oder eine Warnung ausgegeben wird. Bei einem mehrzeiligen
Abruf gibt ein SQLCOUNT von 1 ohne Fehlerzustand an, dass eine gültige
Zeile abgerufen wurde.
Der folgende Beispielcode zeigt den Gebrauch von mehrzeiligen Abrufen
(wide fetches). Sie können diesen Code auch in
samples\ASA\esqlwidefetch\widefetch.sqc in Ihrem SQL Anywhere-
Verzeichnis finden.

#include
#include
#include
#include "sqldef.h"
EXEC SQL INCLUDE SQLCA;
Kapitel 6 Programmieren mit Embedded SQL
EXEC SQL WHENEVER SQLERROR { PrintSQLError();
goto err; };
static void PrintSQLError()
/*************************/
{
char buffer[200];
}
printf( "SQL error %d -- %s\n",
SQLCODE,
sqlerror_message( &sqlca,
buffer,
sizeof( buffer ) ) );
static SQLDA * PrepareSQLDA(
a_sql_statement_number stat0,
unsigned width,
unsigned *cols_per_row )
/*********************************************/
/* Einen SQLDA-Bereich für Abrufe von der von
"stat0" definierten Anweisung zuordnen. "width"-
Zeilen werden bei jeder FETCH-Anforderung abgerufen.
Die Anzahl der Spalten wird "cols_per_row"
zugeordnet. */
{
int num_cols;
unsigned row, col, offset;
SQLDA * sqlda;
EXEC SQL BEGIN DECLARE SECTION;
a_sql_statement_number stat;
EXEC SQL END DECLARE SECTION;
stat = stat0;
sqlda = alloc_sqlda( 100 );
if( sqlda == NULL ) return( NULL );
EXEC SQL DESCRIBE :stat INTO sqlda;
*cols_per_row = num_cols = sqlda->sqld;
if( num_cols * width > sqlda->sqln ) {
free_sqlda( sqlda );
sqlda = alloc_sqlda( num_cols * width );
if( sqlda == NULL ) return( NULL );
EXEC SQL DESCRIBE :stat INTO sqlda;
}
// Erste Zeile in SQLDA mit describe in
// folgende (weite) Zeilen kopieren
219

Daten abrufen
220
);
sqlda->sqld = num_cols * width;
offset = num_cols;
for( row = 1; row < width; row++ ) {
for( col = 0;
col < num_cols;
col++, offset++ ) {
sqlda->sqlvar[offset].sqltype =
sqlda->sqlvar[col].sqltype;
sqlda->sqlvar[offset].sqllen =
sqlda->sqlvar[col].sqllen;
// optional: beschriebenen Spaltennamen kopieren
memcpy( &sqlda->sqlvar[offset].sqlname,
&sqlda->sqlvar[col].sqlname,
sizeof( sqlda->sqlvar[0].sqlname )
}
}
fill_s_sqlda( sqlda, 40 );
return( sqlda );
err:
return( NULL );
}
static void PrintFetchedRows( SQLDA * sqlda,
unsigned cols_per_row )
/******************************************/
/* Bereits durch weite Abrufe erhaltene Zeilen in SQLDA
ausgeben */
{
long rows_fetched;
int row, col, offset;
}
if( SQLCOUNT == 0 ) {
rows_fetched = 1;
} else {
rows_fetched = SQLCOUNT;
}
printf( "Abgerufene %d Zeilen:\n", rows_fetched );
for( row = 0; row < rows_fetched; row++ ) {
for( col = 0; col < cols_per_row; col++ ) {
offset = row * cols_per_row + col;
printf( " \"%s\"",
(char *)sqlda->sqlvar[offset]
.sqldata );
}
printf( "\n" );
}
static int DoQuery( char * query_str0,
unsigned fetch_width0 )

Kapitel 6 Programmieren mit Embedded SQL
/*****************************************/
/* Wide Fetch "query_str0"-Auswahlanweisung
* mit der Weite von "fetch_width0" Zeilen" */
{
SQLDA * sqlda;
unsigned cols_per_row;
EXEC SQL BEGIN DECLARE SECTION;
a_sql_statement_number stat;
char * query_str;
unsigned fetch_width;
EXEC SQL END DECLARE SECTION;
}
query_str = query_str0;
fetch_width = fetch_width0;
EXEC SQL PREPARE :stat FROM :query_str;
EXEC SQL DECLARE QCURSOR CURSOR FOR :stat
FOR READ ONLY;
EXEC SQL OPEN QCURSOR;
sqlda = PrepareSQLDA( stat,
fetch_width,
&cols_per_row );
if( sqlda == NULL ) {
printf( "Fehler beim Zuweisen von SQLDA\n" );
return( SQLE_NO_MEMORY );
for( ;; ) {
EXEC SQL FETCH QCURSOR INTO DESCRIPTOR sqlda
ARRAY :fetch_width;
if( SQLCODE != SQLE_NOERROR ) break;
PrintFetchedRows( sqlda, cols_per_row );
}
EXEC SQL CLOSE QCURSOR;
EXEC SQL DROP STATEMENT :stat;
free_filled_sqlda( sqlda );
err:
return( SQLCODE );
}
void main( int argc, char *argv[] )
/*********************************/
/* Optionales erstes Argument ist ’select’-Anweisung
* optionales zweites Argument ist ’Fetch’-Weite */
{
char *query_str =
"select emp_fname, emp_lname from employee";
unsigned fetch_width = 10;
if( argc > 1 ) {
query_str = argv[1];
if( argc > 2 ) {
fetch_width = atoi( argv[2] );
221

Daten abrufen
Hinweise zur
Verwendung von
mehrzeiligen
Abrufen (wide
fetches)
222
if( fetch_width < 2 ) {
fetch_width = 2;
}
}
}
db_init( &sqlca );
EXEC SQL CONNECT "dba" IDENTIFIED BY "sql";
DoQuery( query_str, fetch_width );
EXEC SQL DISCONNECT;
err:
db_fini( &sqlca );
}
♦ Die Funktion PrepareSQLDA weist den SQLDA-Bereich mit Hilfe der
Funktion alloc_sqlda einem Speicherbereich zu. So wird Platz für
Indikatorvariable ermöglicht, anstatt die Funktion alloc_sqlda_noind zu
verwenden.
♦ Falls weniger als die angeforderte Anzahl von Zeilen, jedoch nicht Null,
abgerufen wurden (zum Beispiel am Ende des Cursors), wird für die
nicht abgerufenen SQLDA-Elemente jeweils NULL zurückgegeben,
indem der entsprechende Indikatorwert gesetzt wird. Falls keine
Indikatorvariable vorhanden ist, wird ein Fehler erzeugt
(SQLE_NO_INDICATOR: keine Indikatorvariable für ein NULL-
Ergebnis).
♦ Falls eine Zeile zurückgegeben wird, die aktualisiert wurde, und die eine
Warnung SQLE_ROW_UPDATED_WARNING hervorgerufen hat,
wird der Abruf in der Zeile angehalten, die die Warnung verursacht hat.
Die Werte aller bis zu diesem Zeitpunkt abgearbeiteten Zeilen werden
zurückgegeben (einschließlich der Zeile, die die Warnung verursacht
hat). SQLCOUNT enthält die Anzahl der Zeilen, die abgerufen wurden,
einschließlich der Zeile, die die Warnung verursacht hat. Alle
verbleibenden SQLDA-Elemente werden mit NULL gekennzeichnet.
♦ Falls eine Zeile, die abgerufen werden soll, gelöscht oder gesperrt wurde
und so einen Fehler hervorruft (SQLE_NO_CURRENT_ROW oder
SQLE_LOCKED), enthält SQLCOUNT die Anzahl der Zeilen, die vor
dem Fehler gelesen wurden. Dies schließt nicht die Zeile ein, die den
Fehler verursachte. Der SQLDA-Bereich enthält keine Werte für die
Zeilen, denn bei Fehlern werden keine SQLDA-Werte zurückgegeben.
Der Wert von SQLCOUNT kann verwendet werden, um den Cursor neu
zu positionieren und, falls nötig, um die Zeilen zu lesen.

Statische und dynamische SQL
Statische SQL-Anweisungen
Dynamische SQL-Anweisungen
Kapitel 6 Programmieren mit Embedded SQL
Es gibt zwei Möglichkeiten, SQL-Anweisungen in ein C-Programm
einzubetten:
♦ Statische Anweisungen
♦ Dynamische Anweisungen
Bis hier haben wir statische SQL erklärt. Dieser Abschnitt vergleicht
statische und dynamische SQL.
Alle Standard-SQL-Anweisungen zur Datenmanipulation und
Datendefinition können in ein C-Programm eingebettet werden, indem man
sie mit dem Präfix EXEC SQL versieht und das Kommando mit einem
Semikolon (;) abschliesst. Diese Anweisungen werden als statische
Anweisungen bezeichnet.
Statische Anweisungen können Referenzen auf Hostvariable enthalten, wie
in "Hostvariable benutzen" auf Seite 200 beschrieben. Alle Beispiele bis hier
haben statische Embedded SQL-Anweisungen benutzt.
Hostvariable können nur an Stelle von Zeichenfolgen- und numerischen
Konstanten benutzt werden. Sie können nicht verwendet werden, um
Spalten- oder Tabellennamen zu ersetzen; für diese Vorgänge sind
dynamische Anweisungen erforderlich.
In C werden Zeichenfolgen in Zeichen-Arrays gespeichert. Dynamische
Anweisungen werden in C-Zeichenfolgen konstruiert. Diese dynamischen
Anweisungen können dann mit der PREPARE-Anweisung und der
EXECUTE-Anweisung ausgeführt werden. Solche SQL-Anweisungen
können Hostvariable nicht in der gleichen Weise ansprechen wie statische
Anweisungen, denn auf C-Variable kann nicht über den Namen zugegriffen
werden, solange das C-Programm ausgeführt wird.
223

Statische und dynamische SQL
Beispiel
224
Um Informationen zwischen dynamischen SQL-Anweisungen und C-
Variablen auszutauschen, wird eine Datenstruktur namens SQL-
Deskriptorbereich (SQL Descriptor Area - SQLDA) verwendet. Diese
Struktur wird vom SQL-Präprozessor erzeugt, wenn Sie beim EXECUTE-
Befehl in der USING-Klausel eine Liste von Hostvariablen spezifizieren.
Jeder Variablen entspricht jeweils ein Platzhalter in der vorbereiteten
Anweisung, zugeordnet über die Position.
$ Informationen zum SQLDA-Bereich finden Sie unter "Der SQL-
Deskriptor-Bereich (SQLDA)" auf Seite 228.
Ein Platzhalter wird in die Anweisung eingefügt, um anzuzeigen, wo auf
Hostvariable zugegriffen wird. Ein Platzhalter ist entweder ein Fragezeichen
(?) oder eine Referenz auf eine Hostvariable wie in statischen Anweisungen
(ein Hostvariablen-Name mit einem vorangestellten Doppelpunkt). Im
letzteren Fall dient der Name der Hostvariable, der im Text der Anweisung
benutzt wird, nur als Platzhalter für eine Referenz auf den SQL-
Deskriptorbereich.
Eine Hostvariable, mit der Informationen an die Datenbank übergeben
werden, wird eine Bindevariable genannt.
Zum Beispiel:
EXEC SQL BEGIN DECLARE SECTION;
char comm[200];
char address[30];
char city[20];
short int cityind;
long empnum;
EXEC SQL END DECLARE SECTION;
. . .
sprintf( comm, "update %s set address = :?,
city = :?"
" where employee_number = :?",
tablename );
EXEC SQL PREPARE S1 FROM :comm;
EXEC SQL EXECUTE S1 USING :address, :city:cityind,
:empnum;
Um diese Methode zu benutzen, muss der Programmierer wissen, wie viele
Hostvariable in der Anweisung vorkommen. Normalerweise ist das nicht der
Fall. Daher können Sie Ihre eigene SQLDA-Struktur aufsetzen und diesen
SQLDA-Bereich in der USING-Klausel des EXECUTE-Befehls angeben.
Die Anweisung DESCRIBE BIND VARIABLES gibt die Namen der
Hostvariablen zu den Bindevariablen zurück, die in einem Prepared-
Statement gefunden wurden. Dies erleichtert es dem C-Programm, die
Hostvariablen zu verwalten. Im Folgenden finden Sie die allgemeine
Methode:

SQLDA-Inhalt
Indikatorvariable
und NULL
Kapitel 6 Programmieren mit Embedded SQL
EXEC SQL BEGIN DECLARE SECTION;
char comm[200];
EXEC SQL END DECLARE SECTION;
. . .
sprintf( comm, "update %s set address = :address,
city = :city"
" where employee_number = :empnum",
tablename );
EXEC SQL PREPARE S1 FROM :comm;
/* Nehmen Sie an, dass es nicht mehr als 10 Hostvariable
gibt. Siehe nächstes Beispiel, falls Sie
keine Grenze festlegen können */
sqlda = alloc_sqlda( 10 );
EXEC SQL DESCRIBE BIND VARIABLES FOR S1 USING DESCRIPTOR
sqlda;
/* sqlda->sqld sagt Ihnen, wie viele Hostvariable
gefunden wurden. */
/* SQLDA_VARIABLE-Felder mit Werten belegen,
die auf den name-Feldern in sqlda basieren.
. . .
EXEC SQL EXECUTE S1 USING DESCRIPTOR sqlda;
free_sqlda( sqlda );
Der SQLDA-Bereich besteht aus einem Array von Variablendeskriptoren.
Jeder Deskriptor beschreibt die Attribute der entsprechenden Variablen des
C-Programms, oder die Stelle, an der die Datenbank Daten speichert oder
von der sie Daten abruft:
♦ den Datentyp
♦ die Länge, falls type eine Zeichenfolge ist
♦ Gesamtstellen und Dezimalstellen, falls type ein nummerischer
Datentyp ist
♦ Speicheradresse
♦ Indikatorvariable
$ Eine vollständige Beschreibung der SQLDA-Struktur finden Sie unter
"Der SQL-Deskriptor-Bereich (SQLDA)" auf Seite 228
Die Indikatorvariable wird verwendet, um einen NULL-Wert an die
Datenbank zu übergeben, oder um einen NULL-Wert von der Datenbank
abzurufen. Die Indikatorvariable wird auch vom Datenbankserver verwendet,
um anzuzeigen, unter welchen Bedingungen Werte während einer
Datenbankoperation gekürzt wurden. Die Indikatorvariable wird mit einem
positiven Wert besetzt, wenn nicht genug Platz zur Verfügung stand, um
einen Wert von der Datenbank zu erhalten.
$ Weitere Hinweise finden Sie unter "Indikatorvariable" auf Seite 204.
225

Statische und dynamische SQL
Die dynamische SELECT-Anweisung
226
Eine SELECT-Anweisung, die nur eine einzige Zeile zurückgibt, kann
dynamisch vorbereitet werden, gefolgt von einer EXECUTE-Anweisung mit
einer INTO-Klausel, um das einzeilige Ergebnis abzurufen. SELECT-
Anweisungen, die mehrere Zeilen zurückgeben, werden dagegen mit Hilfe
von dynamischen Cursorn verwaltet.
Mit dynamischen Cursorn werden Ergebnisse in eine Hostvariablen-Liste
geschrieben, oder in einen SQLDA-Bereich, der mit der FETCH-Anweisung
angegeben wird (FETCH INTO und FETCH USING DESCRIPTOR). Da
die Anzahl der Elemente in der Auswahlliste dem C-Programmierer
normalerweise unbekannt ist, wird in der Regel der SQLDA-Bereich benutzt.
Die Anweisung DESCRIBE SELECT LIST richtet einen SQLDA-Bereich
ein mit Typen für die Elemente der Auswahlliste. Der Platzbedarf für die
Werte wird dann mit der Funktion fill_sqlda() zugewiesen, die Information
wird mit der Anweisung FETCH USING DESCRIPTOR abgerufen.
Ein typisches Szenario sieht wie folgt aus:
EXEC SQL BEGIN DECLARE SECTION;
char comm[200];
EXEC SQL END DECLARE SECTION;
int actual_size;
SQLDA * sqlda;
. . .
sprintf( comm, "select * from %s", table_name );
EXEC SQL PREPARE S1 FROM :comm;
/* Anfaengliche Schaetzung von 10 Spalten im Ergebnis.
Falls es
falsch ist, wird es gleich nach dem ersten
DESCRIBE korrigiert, indem sqlda neu zugewiesen und
DESCRIBE erneut ausgeführt wird. */
sqlda = alloc_sqlda( 10 );
EXEC SQL DESCRIBE SELECT LIST FOR S1 USING DESCRIPTOR
sqlda;
if( sqlda->sqld > sqlda->sqln ){
actual_size = sqlda->sqld;
free_sqlda( sqlda );
sqlda = alloc_sqlda( actual_size );
EXEC SQL DESCRIBE SELECT LIST FOR S1
USING DESCRIPTOR sqlda;
}
fill_sqlda( sqlda );
EXEC SQL DECLARE C1 CURSOR FOR S1;
EXEC SQL OPEN C1;
EXEC SQL WHENEVER NOTFOUND {break};
for( ;; ){
EXEC SQL FETCH C1 USING DESCRIPTOR sqlda;
/* Daten verarbeiten */

}
EXEC SQL CLOSE C1;
EXEC SQL DROP STATEMENT S1;
Kapitel 6 Programmieren mit Embedded SQL
Beenden Sie Anweisungen (drop), wenn sie nicht mehr gebraucht werden.
So stellen Sie sicher, dass Anweisungen beendet werden, damit nicht
unnötigerweise Ressourcen gebunden bleiben.
$ Ein vollständiges Beispiel für den Gebrauch von Cursorn für eine
dynamische Anweisung finden Sie unter "Beispiel für dynamischen Cursor"
auf Seite 193.
$ Detaillierte Informationen zu den oben erwähnten Funktionen finden
Sie unter "Referenz der Bibliotheksfunktion" auf Seite 253.
227

Der SQL-Deskriptor-Bereich (SQLDA)
Der SQL-Deskriptor-Bereich (SQLDA)
Die SQLDA-Header-Datei
228
Der SQLDA-Bereich (SQL Descriptor Area) ist eine Schnittstellenstruktur,
die für dynamische SQL-Anweisungen verwendet wird. Die Struktur tauscht
Informationen über Hostvariable und Ergebnisse der SELECT-Anweisung
mit der Datenbank aus. Der SQLDA-Bereich ist in der Header-Datei sqlda.h
definiert.
$ In der Datenbank-Schnittstellenbibliothek oder DLL gibt es
Funktionen, die Sie zur Verwaltung der SQLDA-Bereiche verwenden
können. Die Beschreibung dieser Funktionen finden Sie unter "Referenz der
Bibliotheksfunktion" auf Seite 253.
Wenn Hostvariable mit statischen SQL-Anweisungen verwendet werden,
erzeugt der Präprozessor einen SQDLA-Bereich für diese Hostvariable. Was
dann mit der Datenbank ausgetauscht wird, ist tatsächlich dieser SQLDA-
Bereich.
Der Inhalt von sqlda.h ist der folgende:
#ifndef _SQLDA_H_INCLUDED
#define _SQLDA_H_INCLUDED
#define II_SQLDA
#include "sqlca.h"
#if defined( _SQL_PACK_STRUCTURES )
#include "pshpk1.h"
#endif
#define SQL_MAX_NAME_LEN 30
#define _sqldafar _sqlfar
typedef short int a_SQL_type;
struct sqlname {
short int length; /* Länge der Char-Daten */
char data[ SQL_MAX_NAME_LEN ]; /* Daten */
};
struct sqlvar { /* Array der Deskriptoren der Variablen */
short int sqltype; /* Typ der Hostvariablen */
short int sqllen; /* Länge der Hostvariablen */
void _sqldafar *sqldata; /* Adresse der Variablen */
short int _sqldafar *sqlind; /* Indikatorvariablen-Zeiger */
struct sqlname sqlname;
};

SQLDA-Felder
Kapitel 6 Programmieren mit Embedded SQL
struct sqlda{
unsigned char sqldaid[8]; /* Eye-catcher "SQLDA"*/
a_SQL_int32 sqldabc; /* Länge der sqlda-Struktur*/
short int sqln; /* Deskriptorgröße in Anzahl der Einträge */
short int sqld; /* Anzahl der von DESCRIBE gefundenen Variablen*/
struct sqlvar sqlvar[1]; /* Array der Variablendeskriptoren */
};
#define SCALE(sqllen) ((sqllen)/256)
#define PRECISION(sqllen) ((sqllen)&0xff)
#define SET_PRECISION_SCALE(sqllen,precision,scale) \
sqllen = (scale)*256 + (precision)
#define DECIMALSTORAGE(sqllen) (PRECISION(sqllen)/2 + 1)
typedef struct sqlda SQLDA;
typedef struct sqlvar SQLVAR, SQLDA_VARIABLE;
typedef struct sqlname SQLNAME, SQLDA_NAME;
#ifndef SQLDASIZE
#define SQLDASIZE(n) ( sizeof( struct sqlda ) + \
(n-1) * sizeof( struct sqlvar) )
#endif
#if defined( _SQL_PACK_STRUCTURES )
#include "poppk.h"
#endif
#endif
Die SQLDA-Felder haben folgende Bedeutung:
Feld Beschreibung
sqldaid Ein 8-Byte-Zeichenfeld, das die Zeichenfolge SQLDA zur
Identifizierung der SQLDA-Struktur enthält. Dieses Feld
unterstützt die Fehlersuche, wenn Sie Speicherinhalte untersuchen.
sqldabc Eine Ganzzahl (long integer), die die Länge der SQLDA-Struktur
enthält
sqln Die Anzahl der Variablendeskriptoren im Array sqlvar
sqld Die Anzahl der gültigen Variablendeskriptoren (die eine
Hostvariable beschreiben). Dieses Feld wird in der Regel von der
DESCRIBE-Anweisung gesetzt, manchmal auch vom
Programmierer, wenn Daten an den Datenbankserver geliefert
werden.
sqlvar Ein Array, bestehend aus Deskriptoren vom Typ struct sqlvar,
von denen jeder eine Hostvariable beschreibt
229

Der SQL-Deskriptor-Bereich (SQLDA)
SQLDA-Hostvariablen-Beschreibungen
230
Jede sqlvar-Struktur im SQLDA-Bereich beschreibt eine Hostvariable. Die
Felder der sqlvar-Struktur haben folgende Bedeutung:
♦ sqltype Der Typ der Variable, die von diesem Deskriptor beschrieben
wird (siehe "Datentypen in Embedded SQL" auf Seite 196)
Das "low order Bit" zeigt an, ob NULL-Werte erlaubt sind. Gültige
Typen- und Konstantendefinitionen befinden sich in der Header-Datei
sqldef.h.
Dieses Feld wird von der DESCRIBE-Anweisung belegt. Sie können
dieses Feld mit jedem Typ belegen, wenn Sie Daten an den
Datenbankserver liefern oder Daten vom Datenbankserver abrufen.
Erforderliche Typkonvertierungen erfolgen automatisch.
♦ sqllen Länge der Variable. Was der Wert dieser Variable tatsächlich
bedeutet, hängt von den Informationen zum Typ ab und davon, wie der
SQLDA-Bereich verwendet wird.
Für DECIMAL-Typen wird dieses Feld in zwei je 1 Byte lange Felder
aufgeteilt. Das "high byte" repräsentiert die Anzahl der Gesamtstellen
und das "low byte" die Anzahl der Dezimalstellen. Die Gesamtstellen
sind die Gesamtzahl der Ziffern. Die Dezimalstellen sind die Anzahl der
Ziffern nach dem Dezimalzeichen.
Bei LONG VARCHAR- und LONG BINARY-Datentypen wird das
array_len-Feld der DT_LONGBINARY- und DT_LONGVARCHAR-
Datentypstruktur anstelle des sqllen-Felds verwendet.
$ Weitere Informationen über das Längenfeld finden Sie unter
"SQLDA sqllen-Feldwerte" auf Seite 232.
♦ sqldata Ein 4-Byte-Zeiger auf den Speicher, der von der Variable belegt
wird. Dieser Speicherinhalt muss den Feldern sqltype und sqllen
entsprechen.
$ Informationen über Speicherformate finden Sie unter "Datentypen
in Embedded SQL" auf Seite 196.
Beim UPDATE- und INSERT-Befehl spielt diese Variable keine Rolle
für den Vorgang, falls der sqldata-Zeiger ein Null-Zeiger ist. Bei
FETCH werden keine Daten zurückgegeben, falls der sqldata-Zeiger
ein Null-Zeiger ist. In anderen Worten, die vom Zeiger sqldata
zurückgegebene Spalte ist eine entbundene Spalte.

Kapitel 6 Programmieren mit Embedded SQL
Falls die DESCRIBE-Anweisung LONG NAMES benutzt, enthält
dieses Feld den Langnamen der Ergebnismengen-Spalte. Falls die
DESCRIBE-Anweisung darüber hinaus eine DESCRIBE USER
TYPES-Anweisung ist, dann enthält dieses Feld den Langnamen des
benutzerdefinierten Datentyps statt der Spalte. Ist der Typ ein ein
vordefinierter Datentyp, ist das Feld leer.
♦ sqlind Ein Zeiger auf den Indikatorwert. Ein Indikatorwert ist eine
Ganzzahl (short int). Ein negativer Indikatorwert zeigt einen NULL-
Wert an. Ein positiver Indikatorwert bedeutet, dass diese Variable von
einer FETCH-Anweisung gekürzt wurde. Der Indikatorwert enthält die
Länge der Daten, bevor sie gekürzt wurden. Ein Wert von –2 zeigt
einen Konvertierungsfehler an, wenn die Datenbankoption
CONVERSION_ERROR auf OFF gesetzt ist.
$ Weitere Hinweise finden Sie unter "Indikatorvariable" auf
Seite 204.
Ist der sqlind-Zeiger ein Null-Zeiger, gehört keine Indikatorvariable zu
dieser Hostvariable.
Das sqlind-Feld wird auch in der DESCRIBE-Anweisung verwendet,
um Parametertypen anzuzeigen. Ist der Datentyp benutzerdefiniert, wird
das Feld auf DT_HAS_USERTYPE_INFO gesetzt. In diesem Fall
sollten Sie DESCRIBE USER TYPES ausführen, um Informationen
über den benutzerdefinierten Datentyp zu erhalten.
♦ sqlname Eine VARCHAR-Struktur, die einen Längen- und einen
Zeichenpuffer enthält. Sie ist mit einer DESCRIBE-Anweisung belegt
und wird nur dafür benutzt. Dieses Feld hat verschiedene Bedeutungen
für zwei Formate der DESCRIBE-Anweisung:
♦ Auswahlliste (SELECT LIST) Der Namenpuffer ist belegt mit dem
Spaltentitel des entsprechenden Elements in der ausgewählten Liste.
♦ Bindevariable Der Namenpuffer ist belegt mit dem Namen der
Hostvariable, die als Bindevariable benutzt wurde, oder mit "?" falls
eine namenlose Parametermarkierung verwendet wurde.
Handelt es sich um einen DESCRIBE SELECT LIST-Befehl, sind alle
vorhandenen Indikatorvariablen mit einer Markierung (flag) belegt, die
anzeigt, ob das Listenelement aktualisierbar ist. Weitere Informationen
über diese Markierung finden Sie in der Header-Datei sqldef.h.
Handelt es sich um eine DESCRIBE USER TYPES-Anweisung, dann
enthält dieses Feld den Langnamen des benutzerdefinierten Datentyps an
Stelle der Spalte. Ist der Typ ein ein vordefinierter Datentyp, ist das Feld
leer.
231

Der SQL-Deskriptor-Bereich (SQLDA)
SQLDA sqllen-Feldwerte
Werte beschreiben
232
Die Feldlänge sqllen der sqlvar-Struktur in einem SQLDA-Bereich wird in
drei verschiedenen Arten von Interaktionen mit dem Datenbankserver
verwendet.
♦ Werte beschreiben Mit der DESCRIBE-Anweisung erhalten Sie
Informationen über die Hostvariablen, die zum Speichern von Daten
erforderlich sind, die von der Datenbank abgerufen wurden, oder über
Hostvariable, die zum Übergeben von Daten an die Datenbank
erforderlich sind.
$ Siehe "Werte beschreiben" auf Seite 232.
♦ Werte abrufen Werte von der Datenbank abrufen.
$ Siehe "Werte abrufen" auf Seite 235.
♦ Werte senden Informationen an die Datenbank senden.
$ Siehe "Werte senden" auf Seite 234.
Diese Interaktionen werden in diesem Abschnitt behandelt.
Die folgenden Tabellen beschreiben detailliert jede dieser Interaktionen.
Diese Tabellen enthalten die Schnittstellen-Konstantentypen (DT_-Typen),
die in der Header-Datei sqldef.h zu finden sind. Es sind die Konstanten, die
das SQLDA-Feld sqltype belegen können.
$ Hinweise über sqltype-Feldwerte finden Sie unter "Datentypen in
Embedded SQL" auf Seite 196.
Auch in statischem SQL wird ein SQLDA-Bereich verwendet, er wird
allerdings vom SQL-Präprozessor erzeugt und vollständig belegt. In diesem
Fall zeigen die Tabellen die Entsprechungen zwischen den statischen C-
Hostvariablentypen und den Schnittstellenkonstanten.
Die folgende Tabelle zeigt die Werte der Strukturelemente sqllen und
sqltype, die der DESCRIBE-Befehl für verschiedene Datenbanktypen
zurückgibt (sowohl SELECT LIST als auch BIND VARIABLE DESCRIBE-
Anweisungen). Im Fall eines benutzerdefinierten Datenbank-Datentyps wird
der zu Grunde liegende Datentyp beschrieben.
Ihr Programm kann entweder die Typen und Längen benutzen, die
DESCRIBE zurückgibt, oder es kann andere Typen benutzen. Der
Datenbankserver wird jede erforderliche Typkonvertierung durchführen. Der
Speicherbereich, auf den das Feld sqldata zeigt, muss den Feldern sqltype
und sqllen entsprechen.

Kapitel 6 Programmieren mit Embedded SQL
$ Weitere Hinweise zu Embedded SQL-Datentypen finden Sie unter
"Datentypen in Embedded SQL" auf Seite 196.
Datenbank-Feldtyp zurückgegebener
Embedded SQL-Typ
BIGINT DT_BIGINT 8
BINARY(n) DT_BINARY n
BIT DT_BIT 1
CHAR(n) DT_FIXCHAR n
von describe
zurückgegebene
Länge
DATE DT_DATE die Länge der
längsten formatierten
Zeichenfolge
DECIMAL(p,s) DT_DECIMAL das high byte des
Längenfelds im
SQLDA-Bereich auf
p setzen, das low
byte auf s
DOUBLE DT_DOUBLE 8
FLOAT DT_FLOAT 4
INT DT_INT 4
LONG BINARY DT_LONGBINARY 32767
LONG VARCHAR DT_LONGVARCHAR 32767
REAL DT_FLOAT 4
SMALLINT DT_SMALLINT 2
TIME DT_TIME die Länge der
längsten formatierten
Zeichenfolge
TIMESTAMP DT_TIMESTAMP die Länge der
längsten formatierten
Zeichenfolge
TINYINT DT_TINYINT 1
UNSIGNED BIGINT DT_UNSBIGINT 8
UNSIGNED INT DT_UNSINT 4
UNSIGNED SMALLINT DT_UNSSMALLINT 2
VARCHAR(n) DT_VARCHAR n
233

Der SQL-Deskriptor-Bereich (SQLDA)
Werte senden
234
Die folgende Tabelle zeigt, wie Sie die Länge eines Werts spezifizieren,
wenn Sie im SQLDA-Bereich Daten an den Datenbankserver liefern.
In diesem Fall sind nur die in der Tabelle gezeigten Datentypen erlaubt. Die
Datentypen DT_DATE, DT_TIME und DT_TIMESTAMP werden genau so
behandelt wie DT_STRING, wenn Informationen an die Datenbank geliefert
werden. Der Wert muss eine mit Nullwert abgeschlossene Zeichenfolge in
einem passenden Datumsformat sein.
Embedded SQL-Datentyp Programmaktion zur Einstellung der
Länge
DT_BIGINT keine Aktion erforderlich
DT_BINARY(n) die Länge wird einem Feld in der Struktur
BINARY entnommen
DT_BIT keine Aktion erforderlich
DT_DATE Länge durch das abschließende \0 bestimmt
DT_DECIMAL(p,s) das high byte des Längenfelds im SQLDA-
Bereich auf p setzen, das low byte auf s
DT_DOUBLE keine Aktion erforderlich
DT_FIXCHAR(n) das Längenfeld im SQLDA-Bereich
bestimmt die Länge der Zeichenfolge
DT_FLOAT keine Aktion erforderlich
DT_INT keine Aktion erforderlich
DT_LONGBINARY Längenfeld ignoriert. Siehe "LONG-Daten
senden" auf Seite 240
DT_LONGVARCHAR Längenfeld ignoriert. Siehe "LONG-Daten
senden" auf Seite 240
DT_SMALLINT keine Aktion erforderlich
DT_STRING Länge durch das abschließende \0 bestimmt
DT_TIME Länge durch das abschließende \0 bestimmt
DT_TIMESTAMP Länge durch das abschließende \0 bestimmt
DT_TIMESTAMP_STRUCT keine Aktion erforderlich

Werte abrufen
Kapitel 6 Programmieren mit Embedded SQL
Embedded SQL-Datentyp Programmaktion zur Einstellung der
Länge
DT_UNSBIGINT keine Aktion erforderlich
DT_UNSINT keine Aktion erforderlich
DT_UNSSMALLINT keine Aktion erforderlich
DT_VARCHAR(n) die Länge wird einem Feld in der Struktur
VARCHAR entnommen
DT_VARIABLE Länge durch das abschließende \0 bestimmt
Die folgende Tabelle zeigt die Werte des Längenfelds, wenn Sie Daten von
der Datenbank abrufen und den SQLDA-Bereich verwenden. Das Feld
sqllen wird beim Abrufen von Daten nie geändert.
In diesem Fall sind nur die in der Tabelle gezeigten Datentypen erlaubt. Die
Datentypen DT_DATE, DT_TIME und DT_TIMESTAMP werden genau so
behandelt wie DT_STRING, wenn Informationen von der Datenbank
abgerufen werden. Der Wert wird als Zeichenfolge im aktuellen
Datumsformat formatiert.
Embedded SQL-
Datentyp
Auf welchen Wert
muss das Programm
das Längenfeld setzen,
wenn es Daten von der
Datenbank abruft?
Wie gibt die Datenbank
Längeninformationen
zurück, nachdem ein
Wert abgerufen
wurde?
DT_BIGINT keine Aktion erforderlich keine Aktion erforderlich
DT_BINARY(n) Maximale Länge der
Struktur BINARY (n+2)
das Feld len der Struktur
BINARY ist auf die
tatsächliche Länge gesetzt
DT_BIT keine Aktion erforderlich keine Aktion erforderlich
DT_DATE Länge des Puffers \0 am Ende der
Zeichenfolge
DT_DECIMAL(p,s) Das "high byte" auf p
setzen und das "low byte"
auf s
keine Aktion erforderlich
DT_DOUBLE keine Aktion erforderlich keine Aktion erforderlich
DT_FIXCHAR(n) Länge des Puffers bis zur Länge des Puffers
aufgefüllt mit Leerzeichen
DT_FLOAT keine Aktion erforderlich keine Aktion erforderlich
235

Der SQL-Deskriptor-Bereich (SQLDA)
236
Embedded SQL-
Datentyp
Auf welchen Wert
muss das Programm
das Längenfeld setzen,
wenn es Daten von der
Datenbank abruft?
Wie gibt die Datenbank
Längeninformationen
zurück, nachdem ein
Wert abgerufen
wurde?
DT_INT keine Aktion erforderlich keine Aktion erforderlich
DT_LONGBINARY Länge-Feld ignoriert. Siehe
"LONG-Daten abrufen"
auf Seite 238
DT_LONGVARCHAR Länge-Feld ignoriert. Siehe
"LONG-Daten abrufen"
auf Seite 238
Länge-Feld ignoriert. Siehe
"LONG-Daten abrufen"
auf Seite 238
Länge-Feld ignoriert. Siehe
"LONG-Daten abrufen"
auf Seite 238
DT_SMALLINT keine Aktion erforderlich keine Aktion erforderlich
DT_STRING Länge des Puffers \0 am Ende der
Zeichenfolge
DT_TIME Länge des Puffers \0 am Ende der
Zeichenfolge
DT_TIMESTAMP Länge des Puffers \0 am Ende der
Zeichenfolge
DT_TIMESTAMP_
STRUCT
keine Aktion erforderlich keine Aktion erforderlich
DT_UNSBIGINT keine Aktion erforderlich keine Aktion erforderlich
DT_UNSINT keine Aktion erforderlich keine Aktion erforderlich
DT_UNSSMALLINT keine Aktion erforderlich keine Aktion erforderlich
DT_VARCHAR(n) Maximale Länge der
Struktur VARCHAR (n+2)
das Feld len der Struktur
VARCHAR ist auf die
tatsächliche Länge gesetzt

Lange Werte senden und abfragen
Verwendung von
statischem SQL
Verwendung von
dynamischem SQL
Kapitel 6 Programmieren mit Embedded SQL
Die Methode zum Senden und Abrufen von LONG VARCHAR- und LONG
BINARY-Werten in Embedded SQL-Anwendungen ist anders als bei den
übrigen Datentypen. Sie können auch die Standard-SQLDA-Felder
verwenden, allerdings sind diese auf 32-Kbyte-Daten beschränkt, da die
Felder, die die Informationen enthalten (sqldata, sqllen, sqlind), 16-Bit-
Werte sind. Eine Änderung dieser Werte auf 32-Bit-Werte würde
vorhandene Anwendungen zerstören.
Die Methode zur Beschreibung von LONG VARCHAR- und LONG
BINARY-Werten ist dieselbe wie bei anderen Datentypen.
$ Hinweise über das Abrufen und Senden von Werten finden Sie unter
"LONG-Daten abrufen" auf Seite 238 und "LONG-Daten senden" auf
Seite 240.
Es werden separate Struktuten verwendet, um die zugeordneten,
gespeicherten und ungekürzten Längen von LONG BINARY- und LONG
VARCHAR-Datentypen aufzunehmen. Die statischen SQL-Datentypen
werden in sqlca.h folgendermaßen definiert:
#define DECL_LONGVARCHAR( size ) \
struct { a_sql_uint32 array_len; \
a_sql_uint32 stored_len; \
a_sql_uint32 untrunc_len; \
char array[size+1];\
}
#define DECL_LONGBINARY( size ) \
struct { a_sql_uint32 array_len; \
a_sql_uint32 stored_len; \
a_sql_uint32 untrunc_len; \
char array[size]; \
}
Bei dynamischem SQL ist das Einstellen des sqltype-Felds auf
DT_LONGVARCHAR oder DT_LONGBINARY ausreichend. Die
zugeordneten LONGBINARY- und LONGVARCHAR-Sturkturen sehen
folgendermaßen aus:
237

Lange Werte senden und abfragen
LONG-Daten abrufen
238
typedef struct LONGVARCHAR {
a_sql_uint32 array_len;
/* Anzahl der zugeordneten Byte im Array */
a_sql_uint32 stored_len;
/* Anzahl der im Array gespeicherten Byte
* (nie höher als array_len)
*/
a_sql_uint32 untrunc_len;
/* Anzahl der Byte in nicht-gekürztem
* Ausdruck(kann höher sein als array_len)
*/
char array[1]; /* die Daten */
} LONGVARCHAR, LONGBINARY;
$ Hinweise darüber, wie Sie diese Funktion in Ihren Anwendungen
implementieren, finden Sie unter "LONG-Daten abrufen" auf Seite 238 und
"LONG-Daten senden" auf Seite 240.
Dieser Abschnitt beschreibt, wie Sie LONG-Werte aus der Datenbank
abrufen. Hintergrundinformationen finden Sie unter "Lange Werte senden
und abfragen" auf Seite 237.
Die Prozeduren unterscheiden sich abhängig davon, ob Sie statisches oder
dynamisches SQL verwenden.
v So rufen Sie einen LONG VARCHAR- oder LONG BINARY-Wert ab
(statisches SQL):
1 Deklarieren Sie eine Hostvariable vom Typ DECL_LONGVARCHAR
oder DECL_LONGBINARY, wie erforderlich.
2 Rufen Sie die Daten mit FETCH, GET DATA oder EXECUTE INTO
ab. Adaptive Server Anywhere stellt die folgenden Informationen ein:
♦ Indikatorvariable Die Indikatorvariable ist negativ, wenn der Wert
NULL ist, oder 0, wenn es keine Kürzung gibt; beziehungsweise die
positive ungekürzte Länge in Byte bis zu einem Höchstwert von
32767.
$ Weitere Hinweise finden Sie unter "Indikatorvariable" auf
Seite 204.
♦ stored_len Dieses DECL_LONGVARCHAR- oder
DECL_LONGBINARY-Feld enthält die Anzahl von Byte, die in
das Array abgerufen werden. Der Wert ist niemals größer als
array_len.

Kapitel 6 Programmieren mit Embedded SQL
♦ untrunc_len Dieses DECL_LONGVARCHAR- oder
DECL_LONGBINARY-Feld enthält die Anzahl von Byte, die vom
Datenbankserver gehalten werden. Dieser Wert muss kleiner/gleich
dem stored_len-Wert sein. Er wird auch gesetzt, wenn der
Datenwert ungekürzt ist.
v So nehmen Sie einen Wert in eine LONGVARCHAR- oder
LONGBINARY-Struktur auf (dynamisches SQL):
1 Stellen Sie das sqltype-Feld auf DT_LONGVARCHAR oder
DT_LONGBINARY ein, wie erforderlich.
2 Stellen Sie das sqldata-Feld so ein, dass es auf die LONGVARCHARoder
LONGBINARY-Struktur zeigt.
Sie können das LONGVARCHARSIZE( n )- oder LONGBINARYSIZE( n
)-Makro verwenden, um die Gesamtanzahl der Bytes zu bestimmen, die
zugeordnet werden müssen, um n-Byte von Daten im Array-Feld
aufzunehmen.
3 Stellen Sie das array_len-Feld der LONGVARCHAR- oder
LONGBINARY-Struktur auf die Anzahl der Bytes ein, die dem Array-
Feld zugeordnet sind.
4 Rufen Sie die Daten mit FETCH, GET DATA oder EXECUTE INTO
ab. Adaptive Server Anywhere stellt die folgenden Informationen ein:
♦ * sqlind Dieses sqlda-Feld ist negativ, wenn der Wert NULL ist,
oder 0, wenn es keine Kürzung gibt, beziehungsweise die positive
ungekürzte Länge in Byte bis zu einem Höchstwert von 32767.
♦ stored_len Dieses LONGVARCHAR- oder LONGBINARY-Feld
enthält die Anzahl von Byte, die in das Array abgerufen werden.
Der Wert ist niemals größer als array_len.
♦ untrunc_len Dieses LONGVARCHAR- oder LONGBINARY-Feld
enthält die Anzahl von Byte, die vom Datenbankserver gehalten
werden. Dieser Wert muss kleiner/gleich dem stored_len-Wert
sein. Er wird auch gesetzt, wenn der Datenwert ungekürzt ist.
Der folgende Codeabschnitt illustriert den Mechanismus, der zum Abrufen
von LONG VARCHAR-Daten mittels dynamischem Embedded SQL
verwendet wird. Er dient nur zur Illustration und ist nicht für eine
tatsächliche Verwendung bestimmt.
239

Lange Werte senden und abfragen
LONG-Daten senden
240
#define DATA_LEN 128000
void get_test_var()
/*****************/
{
LONGVARCHAR *longptr;
SQLDA *sqlda;
SQLVAR *sqlvar;
}
sqlda = alloc_sqlda( 1 );
longptr = (LONGVARCHAR *)malloc(
LONGVARCHARSIZE( DATA_LEN ) );
if( sqlda == NULL || longptr == NULL ) {
fatal_error( "Allocation failed" );
}
// longptr für Datenaufnahme initialisieren
longptr->array_len = DATA_LEN;
// _
// (sqllen wird nicht mit DT_LONG-Typen verwendet)
sqlda->sqld = 1; // 1 sqlvar verwenden
sqlvar = &sqlda->sqlvar[0];
sqlvar->sqltype = DT_LONGVARCHAR;
sqlvar->sqldata = longptr;
printf( "fetching test_var\n" );
EXEC SQL PREPARE select_stmt FROM 'SELECT test_var';
EXEC SQL EXECUTE select_stmt INTO DESCRIPTOR sqlda;
EXEC SQL DROP STATEMENT select_stmt;
printf( "stored_len: %d, untrunc_len: %d,
1st char: %c, last char: %c\n",
longptr->stored_len,
longptr->untrunc_len,
longptr->array[0],
longptr->array[DATA_LEN-1] );
free_sqlda( sqlda );
free( longptr );
Dieser Abschnitt beschreibt, wie Sie LONG-Werte an die Datenbank von
Embedded SQL-Anwendungen senden. Hintergrundinformationen finden Sie
unter "Lange Werte senden und abfragen" auf Seite 237.
Die Prozeduren unterscheiden sich abhängig davon, ob Sie statisches oder
dynamisches SQL verwenden.

Kapitel 6 Programmieren mit Embedded SQL
v So senden Sie einen LONG VARCHAR- oder LONG BINARY-Wert
(statisches SQL):
1 Deklarieren Sie eine Hostvariable vom Typ DECL_LONGVARCHAR
oder DECL_LONGBINARY, wie erforderlich.
2 Wenn Sie NULL senden und eine Indikatorvariable verwenden, stellen
Sie die Indikatorvariable auf einen negativen Wert ein.
$ Weitere Hinweise finden Sie unter "Indikatorvariable" auf
Seite 204.
3 Stellen Sie das stored_len-Feld der DECL_LONGVARCHAR- oder
DECL_LONGBINARY-Struktur auf die Anzahl von Byte der Daten im
Array-Feld ein.
4 Senden Sie die Daten, indem Sie den Corsor öffnen oder die Anweisung
ausführen.
Der folgende Codeabschnitt illustriert den Mechanismus, der zum Senden
von LONG VARCHAR-Daten mittels statischem Embedded SQL verwendet
wird. Er dient nur zur Illustration und ist nicht für eine tatsächliche
Verwendung bestimmt.
#define DATA_LEN 12800
EXEC SQL BEGIN DECLARE SECTION;
// SQLPP initialisiert longdata.array_len
DECL_LONGVARCHAR(128000) longdata;
EXEC SQL END DECLARE SECTION;
void set_test_var()
/*****************/
{
// longdata für das Senden von Daten initialisieren
memset( longdata.array, 'a', DATA_LEN );
longdata.stored_len = DATA_LEN;
}
printf( "Setting test_var to %d a's\n", DATA_LEN );
EXEC SQL SET test_var = :longdata;
v So senden Sie einen Wert mittels einer LONGVARCHAR- oder
LONGBINARY-Struktur (dynamisches SQL):
1 Stellen Sie das sqltype-Feld auf DT_LONGVARCHAR oder
DT_LONGBINARY ein, wie erforderlich.
2 Wenn Sie NULL senden, stellen Sie * sqlind auf einen negativen Wert
ein.
3 Stellen Sie das sqldata-Feld so ein, dass es auf die LONGVARCHARoder
LONGBINARY-Struktur zeigt.
241

Lange Werte senden und abfragen
242
Sie können das LONGVARCHARSIZE( n )- oder LONGBINARYSIZE( n
)-Makro verwenden, um die Gesamtanzahl an Byte zu bestimmen, die
zugeordnet werden müssen, um n-Byte von Daten im Array-Feld
aufzunehmen.
4 Stellen Sie das array_len-Feld der LONGVARCHAR- oder
LONGBINARY-Struktur auf die Anzahl an Byte ein, die dem Array-
Feld zugeordnet sind.
5 Stellen Sie das stored_len-Feld der LONGVARCHAR- oder
LONGBINARY-Struktur auf die Anzahl an Byte der Daten im Array-
Feld ein. Dieser Wert darf nicht größer als array_len sein.
6 Senden Sie die Daten, indem Sie den Cursor öffnen oder die Anweisung
ausführen.

Kapitel 6 Programmieren mit Embedded SQL
Gespeicherte Prozeduren verwenden
In diesem Abschnitt wird die Verwendung von SQL-Prozeduren in
Embedded SQL beschrieben.
Einfache gespeicherte Prozeduren verwenden
Sie können gespeicherte Prozeduren in Embedded SQL erstellen und
aufrufen.
Eine CREATE PROCEDURE-Anweisung kann wie jede andere
Datendefinitions-Anweisung, z.B. CREATE TABLE, eingebettet werden.
Sie können auch eine CALL-Anweisung einbetten, um eine gespeicherte
Prozedur auszuführen. Das folgende Code-Fragment veranschaulicht das
Erstellen und Ausführen einer gespeicherten Prozedur in Embedded SQL
EXEC SQL CREATE PROCEDURE pettycash( IN amount
DECIMAL(10,2) )
BEGIN
UPDATE account
SET balance = balance - amount
WHERE name = ’bank’;
UPDATE account
SET balance = balance + amount
WHERE name = ’pettycash expense’;
END;
EXEC SQL CALL pettycash( 10.72 );
Wenn Sie Werte von Hostvariablen an eine gespeicherte Prozedur
weitergeben oder die Ausgabevariable abrufen wollen, bereiten Sie eine
CALL-Anweisung vor und führen Sie sie aus. Das folgende Code-Fragment
veranschaulicht die Verwendung von Hostvariablen. Sowohl die USING als
auch die INTO-Klausel werden in der EXECUTE-Anweisung benutzt.
EXEC SQL BEGIN DECLARE SECTION;
double hv_expense;
double hv_balance;
EXEC SQL END DECLARE SECTION;
243

Gespeicherte Prozeduren verwenden
244
// hier Code schreiben
EXEC SQL CREATE PROCEDURE pettycash(
IN expense DECIMAL(10,2),
OUT endbalance DECIMAL(10,2) )
BEGIN
UPDATE account
SET balance = balance - expense
WHERE name = ’bank’;
UPDATE account
SET balance = balance + expense
WHERE name = ’pettycash expense’;
SET endbalance = ( SELECT balance FROM account
WHERE name = ’bank’ );
END;
EXEC SQL PREPARE S1 FROM ’CALL pettycash( ?, ? )’;
EXEC SQL EXECUTE S1 USING :hv_expense INTO :hv_balance;
$ Weitere Hinweise finden Sie unter "EXECUTE-Anweisung [ESQL]"
auf Seite 449 der Dokumentation ASA SQL-Referenzhandbuch und
"PREPARE-Anweisung [ESQL]" auf Seite 533 der Dokumentation ASA
SQL-Referenzhandbuch.
Gespeicherte Prozeduren mit Ergebnismengen
Eine Datenbankprozedur kann auch eine SELECT-Anweisung enthalten. Die
Prozedur wird mit einer RESULT-Klausel deklariert, um Anzahl, Name und
Typen der Spalten in der Ergebnismenge zu spezifizieren. Die Spalten einer
Ergebnismenge unterscheiden sich von den Ausgabeparametern. In einer
Prozedur mit Ergebnismenge kann die CALL-Anweisung an Stelle der
SELECT-Anweisung in der Cursordeklaration verwendet werden:
EXEC SQL BEGIN DECLARE SECTION;
char hv_name[100];
EXEC SQL END DECLARE SECTION;
EXEC SQL CREATE PROCEDURE female_employees()
RESULT( name char(50) )
BEGIN
SELECT emp_fname || emp_lname FROM employee
WHERE sex = ’f’;
END;
EXEC SQL PREPARE S1 FROM ’CALL female_employees()’;
EXEC SQL DECLARE C1 CURSOR FOR S1;
EXEC SQL OPEN C1;
for(;;) {

Dynamische
Cursor für CALL-
Anweisungen
Kapitel 6 Programmieren mit Embedded SQL
EXEC SQL FETCH C1 INTO :hv_name;
if( SQLCODE != SQLE_NOERROR ) break;
printf( "%s\\n", hv_name );
}
EXEC SQL CLOSE C1;
In diesem Beispiel wurde die Prozedur mit einer OPEN-Anweisung statt
einer EXECUTE-Anweisung aufgerufen. Nach der OPEN-Anweisung wird
die Prozedur ausgeführt, bis sie eine SELECT-Anweisung erreicht. Zu
diesem Zeitpunkt ist C1 ein Cursor für die SELECT-Anweisung innerhalb
der Datenbankprozedur. Sie können alle Arten des FETCH-Befehls
verwenden (rückwärts und vorwärts scrollen) solange Sie sie benötigen. Die
CLOSE-Anweisung beendet die Ausführung der Prozedur.
Nach der SELECT-Anweisung wird in der Prozedur keine weitere
Anweisung ausgeführt. Um Anweisungen nach dem SELECT auszuführen,
benutzen Sie den Befehl RESUME Cursorname. Der RESUME-Befehl gibt
entweder die Warnung SQLE_PROCEDURE_COMPLETE zurück oder
SQLE_NOERROR, und zeigt damit an, dass es noch einen weiteren Cursor
gibt. Das folgende Beispiel zeigt eine zweifache Auswahlprozedur:
EXEC SQL CREATE PROCEDURE people()
RESULT( name char(50) )
BEGIN
SELECT emp_fname || emp_lname
FROM employee;
SELECT fname || lname
FROM customer;
END;
EXEC SQL PREPARE S1 FROM ’CALL people()’;
EXEC SQL DECLARE C1 CURSOR FOR S1;
EXEC SQL OPEN C1;
while( SQLCODE == SQLE_NOERROR ) {
for(;;) {
EXEC SQL FETCH C1 INTO :hv_name;
if( SQLCODE != SQLE_NOERROR ) break;
printf( "%s\\n", hv_name );
}
EXEC SQL RESUME C1;
}
EXEC SQL CLOSE C1;
Diese Beispiele haben statische Cursor verwendet. Dynamische Cursor
können auch für die CALL-Anweisung verwendet werden.
$ Eine Beschreibung von dynamischen Cursorn finden Sie unter "Die
dynamische SELECT-Anweisung" auf Seite 226.
245

Gespeicherte Prozeduren verwenden
DESCRIBE ALL
Mehrfache
Ergebnismengen
246
Die DESCRIBE-Anweisung funktioniert ohne Einschränkung für
Prozeduraufrufe. DESCRIBE OUTPUT erzeugt einen SQLDA-Bereich mit
einer Beschreibung für jede Spalte der Ergebnismenge.
Hat die Prozedur keine Ergebnismenge, enthält der SQLDA-Bereich eine
Beschreibung für jeden INOUT- oder OUT-Parameter der Prozedur. Eine
DESCRIBE INPUT-Anweisung erzeugt einen SQLDA-Bereich mit einer
Beschreibung für jeden IN- oder INOUT-Parameter der Prozedur.
DESCRIBE ALL beschreibt IN-, INOUT-, OUT- und RESULT-Parameter.
DESCRIBE ALL benutzt die Indikatorvariablen im SQLDA-Bereich, um
zusätzliche Information zu liefern.
Die Bits für DT_PROCEDURE_IN und DT_PROCEDURE_OUT werden in
den Indikatorvariablen gesetzt, wenn eine CALL-Anweisung beschrieben
wird. DT_PROCEDURE_IN gibt einen IN- oder INOUT-Parameter an, und
DT_PROCEDURE_OUT gibt einen INOUT- oder OUT-Parameter an. In
RESULT-Spalten von Prozeduren sind beide Bits bereinigt.
Nach einem Beschreibungs-OUTPUT können diese Bits benutzt werden, um
zwischen Anweisungen zu unterscheiden, die Ergebnismengen haben
(müssen OPEN, FETCH, RESUME, CLOSE benutzen), und Anweisungen,
die keine Ergebnismengen haben (müssen EXECUTE benutzen).
$ Eine vollständige Beschreibung finden Sie unter "DESCRIBE-
Anweisung [ESQL]" auf Seite 426 der Dokumentation ASA SQL-
Referenzhandbuch.
Haben Sie eine Prozedur, die mehrere Ergebnismengen zurückgibt, müssen
Sie sie nach jeder RESUME-Anweisung neu beschreiben, falls sich die Form
der Ergebnismengen ändert.
Sie müssen den Cursor beschreiben, nicht die Anweisung, um die aktuelle
Position des Cursors neu zu beschreiben.

Kapitel 6 Programmieren mit Embedded SQL
Programmiertechniken für Embedded SQL
´Dieser Abschnitt enthält eine Reihe von Tipps für Entwickler von
Programmen mit Embedded SQL.
Anforderungs-Management implementieren
Sicherungsfunktionen
Das voreingestellte Verhalten der Schnittstellen-DLL für Anwendungen
beinhaltet es, zu warten, bis eine Anforderung an die Datenbank ausgeführt
wurde und erst dann andere Funktionen auszuführen. Dieses Verhalten
können Sie mit Hilfe der Funktionen für die Anforderungsverwaltung
ändern. Zum Beispiel ist bei Interactive SQL das Betriebssystem weiterhin
aktiv, während Interactive SQL auf eine Antwort der Datenbank wartet und
inzwischen andere Aufgaben ausführt.
Sie können eine Anwendung aktivieren, während eine Anforderung an die
Datenbank abgearbeitet wird, indem Sie eine Callback-Funktion zur
Verfügung stellen. In dieser Callback-Funktion setzen Sie eine weitere
Datenbankanforderung - keine db_cancel_request - ab. Sie können die
Funktion db_is_working in Ihren Message-Handlers verwenden, um
festzustellen, ob gerade eine Anforderung an die Datenbank abgearbeitet
wird.
Die Funktion db_register_a_callback wird verwendet, um die Callback-
Funktionen Ihrer Anwendung zu registrieren:
$ Weitere Hinweise finden Sie im Folgenden.
♦ "db_register_a_callback-Funktion" auf Seite 261
♦ "db_cancel_request-Funktion" auf Seite 257
♦ "db_is_working-Funktion" auf Seite 260
Die Funktion db_backup unterstützt online-Sicherungen in Anwendungen
mit Embedded SQL. Das Sicherungsdienstprogramm setzt diese Funktion
ein. Sie brauchen nur dann ein Programm zu schreiben, das diese Funktion
verwendet, falls Ihre Sicherungsanforderungen die Leistung des
Sicherungsdienstprogramms von Adaptive Server Anywhere übersteigen.
247

Programmiertechniken für Embedded SQL
248
BACKUP-Anweisung wird empfohlen
Obwohl diese Funktion ein Möglichkeit bietet, einer Anwendung
Sicherungsfunktionen hinzuzufügen, wird empfohlen, diese Aufgabe über
die BACKUP-Anweisung zu auszuführen. Weitere Hinweise finden Sie
unter "BACKUP-Anweisung" auf Seite 268 der Dokumentation ASA
SQL-Referenzhandbuch.
$ Sie können mit der Funktion DBBackup der Datenbank-Tools auch
direkt auf das Sicherungsdienstprogramm zugreifen. Weitere Hinweise über
diese Funktion finden Sie im Abschnitt "DBBackup-Funktion" auf Seite 323.
$ Weitere Hinweise finden Sie unter "db_backup-Funktion" auf
Seite 254.

SQL-Präprozessor
Syntax
Siehe auch:
Kapitel 6 Programmieren mit Embedded SQL
Der SQL-Präprozessor bearbeitet ein C- oder C++-Programm, das
Embedded SQL-Code enthält, bevor der Compiler gestartet wird.
sqlpp [ Parameter ] SQL-Dateiname [ Ausgabedateiname ]
Parameter Beschreibung
–c
"Schlüsselwort=Wert;..."
–d Bevorzugte Datengröße
Referenzparameter für die Datenbankverbindung
bereitstellen [UltraLite]
–e Ebene Nicht-konforme SQL-Syntax als Fehler kennzeichnen
–f Das Schlüsselwort "far" in erzeugte statische Daten
schreiben
-g UltraLite-Warnungen nicht anzeigen
–h Zeilenbreite Maximale Zeilenlänge der Ausgabe begrenzen
–k Benutzerdeklarationation von SQLCODE einfügen
-m Version Versionsnamen für generierte Synchronisationsskripten
angeben
–n Zeilennummern
–o Betriebssys Ziel-Betriebssystem.
–p Projekt UltraLite-Projektname
–q Stiller Modus: Keinen Vorspann ausgeben
–r Wieder-eintretender Code
–s Zeichenfolgenlänge Maximale Zeichenfolgenlänge für den Compiler
–w Ebene Nicht-konforme SQL-Syntax als Warnung
kennzeichnen
–x Mehrbyte-SQL-Zeichenfolgen in Escapesequenzen
umwandeln
–z Sequenz Sortierfolge angeben
"Überblick" auf Seite 182
249

SQL-Präprozessor
Beschreibung
Optionen
250
Der SQL-Präprozessor bearbeitet ein C- oder C++-Programm, das
Embedded SQL-Code enthält, bevor der Compiler gestartet wird. SQLPP
übersetzt die SQL-Anweisungen in Eingabedatei in Quellcode der Sprache
C, der in Ausgabedatei gelegt wird. Die normale Dateinamenerweiterung für
Quelldateien mit Embedded SQL ist .sqc. Der voreingestellte Name für die
Ausgabedatei ist der Name der SQL-Datei mit der Erweiterung .c. Falls der
Name der SQL-Datei bereits die Erweiterung .c hat, erhält die Ausgabedatei
standardmäßig die Erweiterung .cc.
–c Erforderlich, wenn Dateien, die Teil einer UltraLite-Anwendung sind, mit
dem Präprozessor bearbeitet werden. Die Verbindungszeichenfolge muss
dem SQL-Präprozessor Zugriff zum Lesen und Ändern Ihrer
Referenzdatenbank geben.
–d Code erzeugen, der die Größe des Datenbereichs reduziert.
Datenstrukturen werden vor der Verwendung zur Ausführungszeit wieder
benutzt und initialisiert. Dies erhöht die Code-Größe.
–e Diese Option kennzeichnet Embedded SQL-Code, der nicht Teil eines
bestimmten Sets von SQL/92 ist, als Fehler.
Die zulässigen Werte von Ebene und ihre Bedeutung sind wie folgt:
♦ e Kennzeichnet Syntax, die nicht Einstiegsebene-SQL/92-Syntax ist
♦ i Kennzeichnet Syntax, die nicht Zwischenebene-SQL/92-Syntax ist
♦ f Kennzeichnet Syntax, die nicht vollständige SQL/92-Syntax ist
♦ t Nicht-Standard-Hostvariablentypen markieren
♦ u Kennzeichnet Syntax, die nicht von UltraLite unterstützt wird
♦ w Lässt die gesamte unterstützte Syntax zu
-g Keine Warnungen im Hinblick auf die Erzeugung von UltraLite-Code
–h Begrenzt die maximale Länge von Ausgabezeilen durch sqlpp auf
Zeilenbreite. Das Fortsetzungszeichen ist ein Rückstrich (\) und der
Mindestwert von Zeilenbreite ist zehn.
–k Teilt dem Präprozessor mit, dass das zu kompilierende Programm eine
Benutzerdeklaration von SQLCODE enthält
-m Geben Sie den Versionsnamen für die erzeugten Synchronisationsskripts
an. Die erzeugten Synchronisationsskripts können in einer MobiLinkkonsolidierten
Datenbank für einfache Synchronisation verwendet werden.

Kapitel 6 Programmieren mit Embedded SQL
–n Erzeugt Zeilennummerinformationen in der C-Datei. Diese umfassen
#line-Direktiven an den betreffenden Stellen im erzeugten C-Code. Wenn
der von Ihnen verwendete Compiler die Anweisung #line unterstützt, lässt
diese Option den Compiler Fehler in Zeilennummern in der SQC-Datei
protokollieren (der Datei mit Embedded SQL), und zwar im Gegensatz zum
Protokollieren von Fehlern in Zeilennummern in der C-Datei, die vom SQL-
Präprozessor erzeugt wird. Ebenso werden die #line-Anweisungen indirekt
vom Source Level Debugger verwendet, sodass Sie bei der Fehlersuche
gleichzeitig die SQC-Quelldatei sehen können.
–o Geben Sie das Ziel-Betriebssystem an. Beachten Sie, dass diese Option
mit dem Betriebssystem übereinstimmen muss, auf dem das Programm
ausgeführt werden soll. In Ihrem Programm wird eine Referenz auf ein
bestimmtes Symbol erzeugt. Dieses Symbol ist in der
Schnittstellenbibliothek definiert. Wenn Sie die falsche Betriebssystem-
Spezifikation oder die falsche Bibliothek verwenden, wird vom Linker ein
Fehler erkannt. Folgende Betriebssysteme werden unterstützt:
♦ WINDOWS Windows 95/98/Me, Windows CE
♦ WINNT Microsoft Windows NT/2000/XP
♦ NETWARE Novell NetWare
♦ UNIX UNIX
–p Kennzeichnet das UltraLite-Projekt, zu dem die Embedded SQL-Dateien
gehören. Diese Option kann nur verwendet werden, wenn Dateien verarbeitet
werden, die Teil einer UltraLite-Anwendung sind.
–q Kein Banner drucken.
–r Weitere Hinweise zum reentrant-Code finden Sie unter "SQLCA-
Verwaltung für Code mit mehreren Threads oder "reentrant"-Code" auf
Seite 211.
–s Setzt die maximale Größe für Zeichenfolgen fest, die der Präprozessor in
die C-Datei ausgibt. Zeichenfolgen, die länger als dieser Wert sind, werden
mit Hilfe einer Liste von Zeichen initialisiert (’a’,’b’,’c’ usw.). Die meisten C-
Compiler sind in der Größe der Zeichenfolgenliterale begrenzt, die Sie
handhaben können. Mit dieser Option wird die obere Grenze festgesetzt. Der
Standardwert ist 500.
–w Diese Option kennzeichnet jeden Embedded SQL-Code als Warnung, der
nicht Teil eines bestimmten Sets von SQL/92 ist.
Die zulässigen Werte von Ebene und ihre Bedeutung sind wie folgt:
♦ e Kennzeichnet Syntax, die nicht Einstiegsebene-SQL/92-Syntax ist
251

SQL-Präprozessor
252
♦ i Kennzeichnet Syntax, die nicht Zwischenebene-SQL/92-Syntax ist
♦ f Kennzeichnet Syntax, die nicht vollständige SQL/92-Syntax ist
♦ t Nicht-Standard-Hostvariablentypen markieren
♦ u Kennzeichnet Syntax, die nicht von UltraLite unterstützt wird
♦ w Lässt die gesamte unterstützte Syntax zu
–x Ändert Mehrbyte-Zeichenfolgen in Escape-Sequenzen, sodass sie vom
Compiler verarbeitet werden können.
–z Mit dieser Option wird die Kollatierungssequenz angegeben. Um eine
Liste mit den empfohlenen Kollatierungssequenzen zu erhalten, geben Sie
dbinit –l an der Eingabeaufforderung ein.
Die Kollatierungssequenz hilft dem Präprozessor, die Zeichen zu verstehen,
die im Quellcode oder Programm verwendet werden, z.B. bei der
Identifizierung von alphabetischen Zeichen, die für die Verwendung in
Bezeichnern geeignet sind. Wenn -z nicht angegeben wird, versucht der
Präprozessor, auf Grund des Betriebssystems und der Umgebungsvariablen
SQLLOCALE eine geeignete Kollatierung zu ermitteln.

Referenz der Bibliotheksfunktion
DLL-Eintrittspunkte
alloc_sqlda-Funktion
Prototyp
Beschreibung
alloc_sqlda_noind-Funktion
Prototyp
Beschreibung
Kapitel 6 Programmieren mit Embedded SQL
Der SQL-Präprozessor erzeugt Funktionsaufrufe in der
Schnittstellenbibliothek oder DLL. Zusätzlich zu den vom SQL-Präprozessor
erzeugten Funktionsaufrufen wird dem Benutzer eine Gruppe von
Bibliotheksfunktionen zur Verfügung gestellt, mit denen Datenbankvorgänge
leichter ausgeführt werden können. Prototypen dieser Funktionen werden
durch den Befehl EXEC SQL INCLUDE SQLCA eingefügt.
Dieser Abschnitt enthält eine Referenzbeschreibung der verschiedenen
Funktionen, geordnet nach Kategorien.
Die DLL-Eintrittspunkte sind gleich, abgesehen davon, dass die Prototypen
einen für DLLs passenden Zusatz haben.
Sie können die Eintrittspunkte auf portierbare Weise unter Verwendung von
_esqlentry_ deklarieren, was in sqlca.h definiert ist. Es wird in den Wert
__stdcall aufgelöst:
SQLDA *alloc_sqlda( unsigned numvar );
Diese Funktion weist einen SQLDA-Bereich mit Deskriptoren für die
numvar zu. Das Feld sqln des SQLDA-Bereichs wird mit der numvar
initialisiert. Den Indikatorvariablen wird Speicherplatz zugewiesen, die
Indikatorzeiger werden auf diesen Speicherplatz gesetzt und der
Indikatorwert wird mit 0 (Null) initialisiert. Ein Null-Zeiger wird
zurückgegeben, falls kein Speicher zugewiesen werden konnte. Es wird
empfohlen, dass Sie diese Funktion an Stelle der Funktion
alloc_sqlda_noind verwenden.
SQLDA *alloc_sqlda_noind( unsigned numvar );
Diese Funktion weist einen SQLDA-Bereich mit Deskriptoren für die
numvar zu. Das Feld sqln des SQLDA-Bereichs wird mit der numvar
initialisiert. Den Indikatorvariablen wird kein Speicherplatz zugewiesen; die
Indikatorzeiger werden auf den Null-Zeiger gesetzt. Ein Null-Zeiger wird
zurückgegeben, falls kein Speicher zugewiesen werden konnte.
253

Referenz der Bibliotheksfunktion
db_backup-Funktion
Prototyp
Zugriffs-
Berechtigung
Beschreibung
254
void db_backup(
SQLCA * sqlca,
int op,
int file_num,
unsigned long page_num,
SQLDA * sqlda);
Um die Sicherungsfunktionen benutzen zu können, müssen Sie mit einer
Benutzer-ID mit DBA-Berechtigung oder mit REMOTE DBA-Berechtigung
(SQL Remote) verbunden sein.
BACKUP-Anweisung wird empfohlen
Obwohl diese Funktion ein Möglichkeit bietet, einer Anwendung
Sicherungsfunktionen hinzuzufügen, wird empfohlen, diese Aufgabe über
die BACKUP-Anweisung zu auszuführen. Weitere Hinweise finden Sie
unter "BACKUP-Anweisung" auf Seite 268 der Dokumentation ASA
SQL-Referenzhandbuch.
Welche Aktion ausgeführt wird, hängt vom Wert des Parameters op ab:
♦ DB_BACKUP_START Muß aufgerufen werden, bevor eine Sicherung
beginnen kann. Zu einem Zeitpunkt kann immer nur eine Sicherung auf
einem gegebenen Datenbankserver laufen. Datenbank-Checkpoints sind
deaktiviert, bis die Sicherung vollständig ist (db_backup wird mit dem
Wert op für DB_BACKUP_END aufgerufen). Kann die Sicherung nicht
starten, wird der SQLCODE mit SQLE_BACKUP_NOT_STARTED
belegt. Andernfalls wird das Feld SQLCOUNT des sqlca mit der Größe
der Datenbankseiten belegt. (Sicherungen werden Seite für Seite
durchgeführt.)
Die Parameter file_num, page_num und sqlda werden nicht beachtet.
♦ DB_BACKUP_OPEN_FILE Öffnet die mit file_num angegebene
Datenbankdatei, sodass Seiten der angegebenen Datei mit
DB_BACKUP_READ_PAGE gesichert werden können. Gültige
Dateinummern sind 0 (Null) bis DB_BACKUP_MAX_FILE für die
Stamm-Datenbankdateien, DB_BACKUP_TRANS_LOG_FILE für die
Transaktionslogdatei und DB_BACKUP_WRITE_FILE für die
Datenbank-Write-Datei, falls sie existiert. Falls die angegebene Datei
nicht existiert, wird SQLCODE mit SQLE_NOTFOUND belegt.
Andernfalls enthält SQLCOUNT die Anzahl der Seiten in der Datei,
SQLIOESTIMATE enthält einen 32-Bit-Wert (POSIX time_t), der die
Zeit angibt, zu der die Datenbankdatei erstellt wurde, der Name der
Betriebssystemdatei befindet sich im Feld sqlerrmc des SQLCA-
Bereichs.

Kapitel 6 Programmieren mit Embedded SQL
Die Parameter page_num und sqlda werden nicht beachtet.
♦ DB_BACKUP_READ_PAGE Eine Seite der Datenbankdatei lesen, die
mit file_num angegeben wird. page_num sollte einen Wert von 0 bis 1
weniger als die Seitenanzahl haben, die von einem erfolgreichen Aufruf
von db_backup mit dem Vorgang DB_BACKUP_OPEN_FILE in
SQLCOUNT zurückgegeben wurde. Andernfalls wird SQLCODE mit
SQLE_NOTFOUND belegt. Der sqlda-Deskriptor sollte mit einer
Variablen vom Typ DT_BINARY eingerichtet werden, die auf einen
Puffer zeigt. Der Puffer sollte groß genug sein, um Binärdaten in der
Größe zu speichern, wie sie im Feld SQLCOUNT beim Aufruf von
db_backup mit dem Vorgang DB_BACKUP_START zurückgegeben
werden.
Die Daten in DT_BINARY enthalten eine 2 Byte lange Längenangabe,
gefolgt von den eigentlichen Binärdaten, sodass der Puffer mindestens 2
Byte länger sein muss als die Seitengröße.
Die Anwendung muss den Puffer speichern
Dieser Aufruf erzeugt eine der angegebenen Datenbankseiten im
Puffer, aber es bleibt der Anwendung überlassen, den Pufferinhalt auf
einem Sicherungsdatenträger zu speichern.
♦ DB_BACKUP_READ_RENAME_LOG Die gleiche Aktion wie bei
DB_BACKUP_READ_PAGE, außer dass nach der letzten Seite das
Transaktionslog zurückgegeben wurde; der Datenbankserver das
bestehende Transaktionslog umbenennt und ein ein neues startet
Falls der Datenbankserver nicht in der Lage ist, das Log zu diesem
Zeitpunkt umzubenennen (z.B. können in Datenbanken der Version 7.x
oder älter unvollständige Transaktionen auftreten) tritt der Fehler
SQLE_BACKUP_CANNOT_RENAME_LOG_YET auf. In diesem Fall
benutzen Sie nicht die zurückgegebene Seite, sondern erneuern Sie die
Anforderung, bis Sie SQLE_NOERROR erhalten und schreiben Sie
dann die Seite. Fahren Sie mit dem Lesen der Seiten fort, bis Sie den
Zustand SQLE_NOTFOUND erhalten.
Die Fehlermeldung
SQLE_BACKUP_CANNOT_RENAME_LOG_YET kann mehrere
Male und für mehrere Seiten auftreten. In Ihrer Wiederholungsschleife
sollten Sie eine Verzögerung einbauen, um den Server nicht mit zu
vielen Anforderungen zu verlangsamen.
Erhalten Sie die Bedingung SQLE_NOTFOUND, wurde das
Transaktionslog erfolgreich gesichert und die Datei umbenannt. Der
Name der alten Transaktiondatei wird im Feld sqlerrmc des SQLCA-
Bereichs zurückgegeben.
255

Referenz der Bibliotheksfunktion
256
Den Wert von sqlda->sqlvar[0].sqlind sollten Sie überprüfen,
nachdem Sie db_backup aufgerufen haben. Ist dieser Wert größer als 0
(Null), wurde die letzte Logseite geschrieben und die Logdatei wurde
umbenannt. Der neue Name befindet sich nach wie vor in
sqlca.sqlerrmc, aber der Wert von SQLCODE ist SQLE_NOERROR.
Danach sollten Sie db_backup nicht nochmals aufrufen, außer Sie
möchten Dateien schließen und die Sicherung beenden. Falls Sie das
tun, erhalten Sie eine zweite Kopie Ihrer gesicherten Logdatei und
SQLE_NOTFOUND.
♦ DB_BACKUP_CLOSE_FILE Muss aufgerufen werden, wenn die
Bearbeitung einer Datei abgeschlossen ist, um die mit file_num
angegebene Datenbankdatei zu schließen.
Die Parameter page_num und sqlda werden nicht beachtet.
♦ DB_BACKUP_END Muß beim Beenden der Sicherung aufgerufen
werden. Keine andere Sicherung kann beginnen, bevor die letzte beendet
wurde. Checkpoints werden wieder aktiviert.
Die Parameter file_num, page_num und sqlda werden nicht beachtet.
Das Programm dbbackup verwendet folgenden Algorithmus. Beachten Sie,
dass es sich nicht um C-Code handelt, und dass keine Fehlerüberprüfung
enthalten ist.
db_backup( ... DB_BACKUP_START ... )
allocate page buffer based on page size in SQLCODE
sqlda = alloc_sqlda( 1 )
sqlda->sqld = 1;
sqlda->sqlvar[0].sqltype = DT_BINARY
sqlda->sqlvar[0].sqldata = allocated buffer
for file_num = 0 to DB_BACKUP_MAX_FILE
db_backup( ... DB_BACKUP_OPEN_FILE, file_num ... )
if SQLCODE == SQLE_NO_ERROR
/* Datei vorhanden */
num_pages = SQLCOUNT
file_time = SQLE_IO_ESTIMATE
open backup file with name from sqlca.sqlerrmc
for page_num = 0 to num_pages - 1
db_backup( ... DB_BACKUP_READ_PAGE,
file_num, page_num, sqlda )
write page buffer out to backup file
next page_num
close backup file
db_backup( ... DB_BACKUP_CLOSE_FILE, file_num ... )
end if
next file_num
backup up file DB_BACKUP_WRITE_FILE as above
backup up file DB_BACKUP_TRANS_LOG_FILE as above
free page buffer

db_cancel_request-Funktion
Prototyp
Beschreibung
db_delete_file-Funktion
Prototyp
Zugriffs-
Berechtigung
Beschreibung
Kapitel 6 Programmieren mit Embedded SQL
db_backup( ... DB_BACKUP_END ... )
int db_cancel_request( SQLCA *sqlca );
Diese Funktion bricht die gerade aktive Anforderung an den
Datenbankserver ab. Sie überprüft, ob die Anforderung an den
Datenbankserver aktiv ist, bevor sie die Abbruchsanforderung sendet. Wenn
die Funktion 1 zurückgibt, wurde die Abbruchsanforderung gesendet; wenn
sie 0 zurückgibt, wurde keine Anforderung gesendet.
Ein Rückgabewert ungleich 0 bedeutet nicht, dass die Anforderung
abgebrochen wurde. Es gibt einige kritische zeitliche Überschneidungen,
wenn sich die Abbruchsanforderung und die Antwort von der Datenbank
oder vom Server überschneiden. In diesen Fällen findet einfach kein
Abbruch statt, obwohl die Funktion weiterhin TRUE zurückgibt.
Die Funktion db_cancel_request kann asynchron aufgerufen werden. Diese
und die Funktion db_is_working sind die einzigen Funktionen in der
Schnittstellenbibliothek der Datenbank, die asynchron aufgerufen werden
können, weil sie einen SQLCA-Bereich benutzen, der schon von einer
anderen Anforderung verwendet werden könnte.
Wenn Sie eine Anforderung abbrechen, die eine Cursoroperation durchführt,
ist die Position des Cursors unbestimmt. Sie müssen den Cursor entweder
mit seiner absoluten Position festlegen oder ihn nach dem Abbrechen
schließen.
void db_delete_file(
SQLCA * sqlca,
char * filename );
Um die Sicherungsfunktionen benutzen zu können, müssen Sie mit einer
Benutzer-ID mit DBA-Berechtigung oder mit REMOTE DBA-Berechtigung
(SQL Remote) verbunden sein.
Die Funktion db_delete_file fordert vom Datenbankserver das Löschen der
Datei namens filename an. Diese Funktion kann nach dem Sichern und
Umbenennen des Transaktionslogs verwendet werden (siehe oben,
DB_BACKUP_READ_RENAME_LOG in "db_backup-Funktion" auf
Seite 254), um das alte Transaktionslog zu löschen. Sie müssen mit einer
Benutzer-ID mit DBA-Berechtigung verbunden sein.
257

Referenz der Bibliotheksfunktion
db_find_engine-Funktion
Prototyp
Beschreibung
db_fini-Funktion
Prototyp
Beschreibung
Siehe auch:
db_get_property-Funktion
Prototyp
258
unsigned short db_find_engine(
SQLCA *sqlca,
char *name );
Diese Funktion gibt eine kurze Ganzzahl ohne Vorzeichen zurück, die
Statusinformationen über den Datenbankserver namens name anzeigt. Falls
kein Server mit dem angegebenen Namen gefunden werden kann, ist der
Rückgabewert 0 (Null). Ein Rückgabewert ungleich 0 bedeutet, dass der
angegebene Server gerade läuft.
Jedes Bit des Rückgabewert enthält eine spezifische Information. Die
Header-Datei sqldef.h definiert Konstanten für diese Informationen. Falls ein
Null-Zeiger für name angegeben wird, gibt die Funktion Information über
die voreingestellte Datenbank zurück.
unsigned short db_fini( *sqlca );
Diese Funktion gibt Ressourcen frei, die von der Datenbankschnittstelle
benutzt wurden. Nachdem Sie db_fini aufgerufen haben, sind keine weiteren
Bibliotheksaufrufe und keine weiteren Embedded SQL-Befehle erlaubt.
Wenn während der Verarbeitung ein Fehler auftritt, wird der Fehlercode in
SQLCA eingestellt und die Funktion gibt 0 zurück. Wenn es keine Fehler
gegeben hat, wird ein Nicht-Nullwert zurückgegeben.
Sie müssen db_fini einmal für jeden benutzten SQLCA-Bereich aufrufen.
Vorsicht
Wird unter NetWare nicht db_fini für jedes db_init aufgerufen, kann das
den Datenbankserver und den NetWare-Dateiserver zum Absturz bringen.
Hinweise über die Verwendung von db_fini in UltraLite-Anwendungen
finden Sie unter "db_fini-Funktion" auf Seite 247 der Dokumentation
UltraLite Benutzerhandbuch.
unsigned int db_get_property(
SQLCA * sqlca,
a_db_property property,
char * value_buffer,
int value_buffer_size );

Beschreibung
Siehe auch:
db_init-Funktion
Prototyp
Beschreibung
Kapitel 6 Programmieren mit Embedded SQL
Diese Funktion wird verwendet, um die Adressen der Server zu erhalten, zu
denen derzeit eine Verbindung besteht. Sie wird vom Dienstprogramm
dbping verwendet, um die Serveradresse auszudrucken.
Die Funktion kann auch benutzt werden, um den Wert der
Datenbankeigenschaften zu erhalten. Datenbankeigenschaften können auch
auf eine schnittstellenunabhängige Weise abgerufen werden, nämlich durch
Ausführen einer SELECT-Anweisung, siehe "Eigenschaften von
Datenbanken" auf Seite 690 der Dokumentation ASA
Datenbankadministration.
Es gelten die folgenden Argumente:
♦ a_db_property Ein enum mit dem Wert
DB_PROP_SERVER_ADDRESS. DB_PROP_SERVER_ADDRESS
ruft die Servernetzwerkadresse der derzeitigen Verbindung als
ausdruckbare Zeichenfolge zurück. Gemeinsamer Speicher und
NamedPipes-Protokolle geben immer die leere Zeichenfolge für die
Adresse zurück. TCP/IP- und SPX-Protokolle geben nicht-leere
Zeichenfolgeadressen zurück.
♦ value_buffer Dieses Argument wird mit dem Eigenschaftswert als
Zeichenfolge mit einer abschließenden Null gefüllt.
♦ value_buffer_size Die maximale Länge der Zeichenfolge value_buffer,
einschließlich des abschließenden Nullzeichens.
"Eigenschaften von Datenbanken" auf Seite 690 der Dokumentation ASA
Datenbankadministration
unsigned short db_init( SQLCA *sqlca );
Diese Funktion initialisiert die Schnittstellenbibliothek der Datenbank. Diese
Funktion muss aufgerufen werden, bevor ein anderer Bibliotheksaufruf
erfolgen kann und bevor ein Embedded SQL-Befehl ausgeführt wird. Die
Ressourcen, die die Schnittstellenbibliothek für Ihr Programm braucht,
werden bei diesem Aufruf zugewiesen und initialisiert.
Geben Sie mit db_fini am Ende Ihres Programms die Ressourcen frei. Falls
während der Prozessverarbeitung Fehler auftreten, werden sie im SQLCA-
Bereich zurückgegeben und der Rückgabewert ist 0 (Null). Treten keine
Fehler auf, ist der Rückgabewert ungleich 0 (Null) und Sie können beginnen,
Embedded SQL-Befehle und -Funktionen zu benutzen.
259

Referenz der Bibliotheksfunktion
Siehe auch:
db_is_working-Funktion
Prototyp
Beschreibung
db_locate_servers-Funktion
Prototyp
Beschreibung
260
In den meisten Fällen sollte diese Funktion nur einmal aufgerufen werden,
um die Adresse der globalen Variable sqlca weiterzugeben, die in der
Header-Datei sqlca.h definiert ist. Falls Sie mit Embedded SQL eine DLL
oder eine Anwendung schreiben, die mehrfache Threads hat, rufen Sie
db_init einmal für jeden SQLCA-Bereich auf, der benutzt wird.
$ Weitere Hinweise finden Sie unter "SQLCA-Verwaltung für Code mit
mehreren Threads oder "reentrant"-Code" auf Seite 211.
Vorsicht
Wenn Sie unter NetWare db_fini nicht für jedes db_init aufrufen, kann
dies einen Absturz des Datenbankservers und des NetWare-Dateiservers
verursachen.
Hinweise über die Verwendung von db_init in UltraLite-Anwendungen
finden Sie unter "db_init-Funktion" auf Seite 247 der Dokumentation
UltraLite Benutzerhandbuch.
unsigned db_is_working( SQLCA *sqlca );
Diese Funktion gibt 1 zurück, falls eine Datenbankanforderung Ihrer
Anwendung läuft, die den angegebenen sqlca benutzt. Sie gibt 0 (Null)
zurück, falls keine Anwendung läuft, die den angegebenen sqlca benutzt.
Diese Funktion kann asynchron aufgerufen werden. Diese und die Funktion
db_cancel_request sind die einzigen Funktionen in der
Schnittstellenbibliothek der Datenbank, die asynchron aufgerufen werden
können, weil sie einen SQLCA-Bereich benutzen, der schon von einer
anderen Anforderung verwendet werden könnte.
unsigned int db_locate_servers(
SQLCA *sqlca,
SQL_CALLBACK_PARM callback_address,
void *callback_user_data );
Bietet Zugriff auf die vom Befehlszeilen-Dienstprogramm dblocate
angezeigten Daten und listet alle Adaptive Server Anywhere-
Datenbankserver mit TCP/IP-Anschluss im lokalen Netzwerk auf.
Die Callback-Funktion muss folgende Syntax haben:

int (*)( SQLCA *sqlca,
a_server_address *server_addr,
void *callback_user_data );
db_register_a_callback-Funktion
Prototyp
Beschreibung
Kapitel 6 Programmieren mit Embedded SQL
Die Callback-Funktion wird für jeden gefundenen Server ausgeführt. Wenn
die Callback-Funktion den Wert 0 zurückgibt, stoppt db_locate_servers die
Suche nach Servern.
Die an die Callback-Funktion übergebenen Parameter sqlca und
callback_user_data sind dieselben Parameter, die an db_locate_servers
übergeben werden. Der zweite Parameter ist ein Zeiger auf eine
a_server_address-Struktur. a_server_address wird mit folgender
Definition in sqlca.h festgelegt:
typedef struct a_server_address {
a_SQL_uint32 port_type;
a_SQL_uint32 port_num;
char *name;
char *address;
} a_server_address;
♦ port_type Ist hier immer PORT_TYPE_TCP (laut Definition 6 in
sqlca.h)
♦ port_num Ist die TCP-Portnummer, die der Server abhört
♦ name Zeigt auf einen Puffer, der den Servernamen enthält
♦ address Zeigt auf einen Puffer, der die IP-Adresse des Servers enthält
$ Weitere Hinweise finden Sie unter "Das Serverposition-
Dienstprogramm" auf Seite 554 der Dokumentation ASA
Datenbankadministration.
void db_register_a_callback(
SQLCA *sqlca,
a_db_callback_index index,
( SQL_CALLBACK_PARM ) callback );
Diese Funktion registriert Callback-Funktionen:
Falls Sie keine Callback-Funktion DB_CALLBACK_WAIT registrieren, ist
die voreingestellte Reaktion, nichts zu tun. Ihre Anwendung ist blockiert,
wartet auf die Antwort von der Datenbank und Windows zeigt den Cursor als
Sanduhr an.
Um einen Callback zu löschen, übergeben Sie einen Null-Zeiger als
callback-Funktion.
261

Referenz der Bibliotheksfunktion
262
Die folgenden Werte sind für den Parameter index erlaubt:
♦ DB_CALLBACK_DEBUG_MESSAGE Die bereitgestellte Funktion wird
für jede Fehlersuchmeldung einmal aufgerufen. Ihr wird eine auf Null
endende Zeichenfolge übergeben, die den Text der Debug-Meldung
enthält. Die Zeichenfolge enthält gewöhnlich eine Zeilenendmarke (\n)
unmittelbar vor dem beendenden Nullwertzeichen. Der Prototyp der
Callback-Funktion lautet folgendermaßen:
void SQL_CALLBACK debug_message_callback(
SQLCA *sqlca,
char * message_string );
♦ DB_CALLBACK_START Der Callback-Prototyp sieht wie folgt aus:
void SQL_CALLBACK start_callback( SQLCA *sqlca );
Diese Funktion wird unmittelbar vor dem Absenden einer
Datenbankanforderung an den Server aufgerufen.
DB_CALLBACK_START wird nur unter Windows verwendet.
♦ DB_CALLBACK_FINISH Der Callback-Prototyp sieht wie folgt aus:
void SQL_CALLBACK finish_callback( SQLCA * sqlca );
Diese Funktion wird aufgerufen, nachdem die Antwort auf eine
Datenbankanforderung von der Schnittstellen-DLL empfangen wurde.
DB_CALLBACK_FINISH wird nur unter Windows-Betriebssystemen
verwendet.
♦ DB_CALLBACK_CONN_DROPPED Die Syntax sieht wie folgt aus:
void SQL_CALLBACK conn_dropped_callback (
SQLCA *sqlca,
char *conn_name );
Diese Funktion wird aufgerufen, wenn der Datenbankserver im Begriff
ist, die Verbindung aufgrund einer Zeitüberschreitung zu verlieren, von
einer DROP CONNECTION-Anweisung oder weil der Server
heruntergefahren wird. Der Verbindungsname conn_name wird
übergeben, sodass Sie zwischen den Verbindungen unterscheiden
können. Wenn die Verbindung nicht benannt war, hat sie den Wert
NULL.
♦ DB_CALLBACK_WAIT Der Callback-Prototyp sieht wie folgt aus:
void SQL_CALLBACK wait_callback( SQLCA *sqlca );
Diese Funktion wird wiederholt von der Schnittstellenbibliothek
aufgerufen, während der Datenbankserver oder die Clientbibliothek mit
dem Abarbeiten Ihrer Datenbankanforderung beschäftigt sind.
So würden Sie diesen Callback registrieren:

db_start_database-Funktion
Prototyp
Argumente
Kapitel 6 Programmieren mit Embedded SQL
db_register_a_callback( &sqlca,
DBCALLBACK_WAIT,
(SQL_CALLBACK_PARM)&db_wait_request );
♦ DB_CALLBACK_MESSAGE Diese Funktion ermöglicht es der
Anwendung, Nachrichten vom Server zu verarbeiten, während sie eine
Anforderung abarbeitet.
Der Callback-Prototyp sieht wie folgt aus:
void SQL_CALLBACK message_callback(
SQLCA* sqlca,
unsigned short msg_type,
an_SQL_code code,
unsigned length,
char* msg
);
Der msg_type-Parameter gibt an, wie wichtig die Nachricht ist und
mehrere unterschiedliche Nachrichtentypen können unterschiedlich
behandelt werden. Die möglichen Nachrichtentypen sind
MESSAGE_TYPE_INFO, MESSAGE_TYPE_WARNING,
MESSAGE_TYPE_ACTION und MESSAGE_TYPE_STATUS. Diese
Konstanten sind in sqldef.h definiert. Das code-Feld ist ein
Identifizierer. Das Längen-Feld gibt an, wie lang die Nachricht ist. Die
Meldung ist nicht mit Nullwert abgeschlossen.
Zum Beispiel zeigt die Interactive SQL Callback-Funktion STATUSund
INFO-Nachrichten in einem Nachrichtenfenster an, während
Nachrichten vom Typ ACTION und WARNING in einem Dialogfenster
erscheinen. Wenn eine Anwendung diese Callback-Funktion nicht
registriert, gibt es eine Standard-Callback-Funktion, die alle Nachrichten
in die Serverlogdatei schreibt (wenn der Debug-Modus eingestellt und
eine Logdatei angegeben ist). Zusätzlich werden Nachrichten vom Typ
MESSAGE_TYPE_WARNING und MESSAGE_TYPE_ACTION
betriebssystemabhängig auffälliger dargestellt.
unsigned int db_start_database( SQLCA * sqlca, char * parms );
sqlca Ein Zeiger auf eine SQLCA-Struktur. Hinweise dazu finden Sie unter
"SQL-Kommunikationsbereich (SQLCA)" auf Seite 208.
parms Eine auf NULL endende Zeichenfolge, die eine Semikolon-getrennte
Liste mit Parametereinstellungen enhält, und zwar in der Form
STICHWORT=Wert. Zum Beispiel:
"UID=DBA;PWD=SQL;DBF=c:\\db\\MeineDatenbank.db"
263

Referenz der Bibliotheksfunktion
Beschreibung
db_start_engine-Funktion
Prototyp
Argumente
Beschreibung
264
$ Eine Liste der Verbindungsparameter finden Sie unter
"Verbindungsparameter" auf Seite 182 der Dokumentation ASA
Datenbankadministration.
Diese Funktion startet eine Datenbank auf einem vorhandenen Server, falls
die Datenbank nicht bereits läuft. Die Schritte, die zum Starten einer
Datenbank ausgeführt werden, sind unter "Personal Server starten" auf
Seite 88 der Dokumentation ASA Datenbankadministration beschrieben.
Der Rückgabewert ist wahr, falls die Datenbank bereits lief oder erfolgreich
gestartet werden konnte. Informationen über Fehler werden im SQLCA-
Bereich zurückgegeben.
Falls eine Benutzer-ID und ein Kennwort in den Parametern übergeben
wurden, werden sie ignoriert.
$ Die Berechtigung zum Starten und Stoppen einer Datenbank wird in der
Serverbefehlszeile gesetzt. Weitere Hinweise finden Sie unter "Der
Datenbankserver" auf Seite 134 der Dokumentation ASA
Datenbankadministration.
unsigned int db_start_engine( SQLCA * sqlca, char * parms );
sqlca Ein Zeiger auf eine SQLCA-Struktur. Hinweise dazu finden Sie unter
"SQL-Kommunikationsbereich (SQLCA)" auf Seite 208.
parms Eine auf NULL endende Zeichenfolge, die eine durch Semikolons
getrennte Liste mit Parametereinstellungen enhält, und zwar in der Form
STICHWORT=Wert. Zum Beispiel:
"UID=DBA;PWD=SQL;DBF=c:\\db\\MeineDatenbank.db"
$ Eine Liste der Verbindungsparameter finden Sie unter
"Verbindungsparameter" auf Seite 182 der Dokumentation ASA
Datenbankadministration.
Mit dieser Funktion wird der Datenbankserver gestartet, falls er nicht bereits
läuft. Die Schritte, die diese Funktion ausführt, sind dieselben, wie sie unter
"Personal Server starten" auf Seite 88 der Dokumentation ASA
Datenbankadministration beschrieben sind.
Der Rückgabewert ist gültig, falls der Datenbankserver gefunden wurde oder
falls er erfolgreich gestartet werden konnte. Informationen über Fehler
werden im SQLCA-Bereich zurückgegeben.

Kapitel 6 Programmieren mit Embedded SQL
Der folgende Aufruf von db_start_engine startet den Datenbankserver und
nennt ihn asademo, er lädt nicht die Datenbank, trotz des DBF-
Verbindungsparameters:
db_start_engine( &sqlca, "DBF=c:\\asa8\\asademo.db;
Start=dbeng8" );
Falls Sie nach dem Server auch eine Datenbank starten wollen, fügen Sie die
Datenbankdatei in den Verbindungsparameter START ein:
db_start_engine( &sqlca,"ENG=eng_name;START=dbeng8
c:\\asa\\asademo.db" );
Dieser Aufruf startet den Server, nennt ihn eng_name und startet die
Datenbank asademo auf diesem Server.
Die Funktion db_start_engine versucht, eine Verbindung zu einem Server
herzustellen, bevor einer gestartet wird, um zu verhindern, dass ein Server
gestartet wird, der bereits läuft.
Der Verbindungsparameter FORCESTART wird nur von der Funktion
db_start_engine verwendet. Wenn er auf YES gesetzt wird, wird nicht
versucht, eine Verbindung zu einem Server herzustellen, bevor einer
gestartet wird. Dadurch kann das folgende Befehlspaar wie erwartet arbeiten:
1 Starten eines Datenbankservers mit dem Namen server_1:
start dbeng8 -n server_1 asademo.db
2 Der Start eines neuen Servers wird erzwungen und es wird eine
Verbindung zu ihm hergestellt:
db_start_engine( &sqlda, "START=dbeng8 -n server_2 asademo.db;ForceStart=YES" )
db_stop_database-Funktion
Prototyp
Argumente
Wenn FORCESTART nicht oder ohne ENG-Parameter verwendet wurde,
hätte der zweite Befehl versucht, eine Verbindung zu server_1 herzustellen.
Der Servername wird von der Funktion db_start_engine nicht vom
Parameter des START-Parameters ermittelt.
unsigned int db_stop_database( SQLCA * sqlca, char * parms );
sqlca Ein Zeiger auf eine SQLCA-Struktur. Hinweise dazu finden Sie unter
"SQL-Kommunikationsbereich (SQLCA)" auf Seite 208.
parms Eine auf NULL endende Zeichenfolge, die eine durch Semikolons
getrennte Liste mit Parametereinstellungen enhält, und zwar in der Form
STICHWORT=Wert. Zum Beispiel:
"UID=DBA;PWD=SQL;DBF=c:\\db\\MeineDatenbank.db"
265

Referenz der Bibliotheksfunktion
Beschreibung
db_stop_engine-Funktion
Prototyp
Argumente
Beschreibung
266
$ Eine Liste der Verbindungsparameter finden Sie unter
"Verbindungsparameter" auf Seite 182 der Dokumentation ASA
Datenbankadministration.
Diese Funktion beendet die Datenbank namens DatabaseName auf dem
Server namens EngineName. Falls der EngineName nicht angegeben ist,
bezieht sich die Funktion auf den voreingestellten Server.
Als Voreinstellung beendet diese Funktion eine Datenbank nicht, solange
noch eine Verbindung zu dieser Datenbank offen ist. Falls Unconditional
mit yes belegt ist, wird die Datenbank beendet, auch wenn noch
Verbindungen offen sind.
Ist der Rückgabewert TRUE, sind keine Fehler aufgetreten.
$ Die Berechtigung zum Starten und Stoppen einer Datenbank wird in der
Serverbefehlszeile gesetzt. Weitere Hinweise finden Sie unter "Der
Datenbankserver" auf Seite 134 der Dokumentation ASA
Datenbankadministration.
unsigned int db_stop_engine( SQLCA * sqlca, char * parms );
sqlca Ein Zeiger auf eine SQLCA-Struktur. Hinweise dazu finden Sie unter
"SQL-Kommunikationsbereich (SQLCA)" auf Seite 208.
parms Eine auf NULL endende Zeichenfolge, die eine durch Semikolons
getrennte Liste mit Parametereinstellungen enhält, und zwar in der Form
STICHWORT=Wert. Zum Beispiel:
"UID=DBA;PWD=SQL;DBF=c:\\db\\MeineDatenbank.db"
$ Eine Liste der Verbindungsparameter finden Sie unter
"Verbindungsparameter" auf Seite 182 der Dokumentation ASA
Datenbankadministration.
Diese Funktion fährt den Datenbankserver herunter. Folgende Schritte
werden von dieser Funktion ausgeführt:
♦ Sie sucht den Datenbankserver, dessen Name dem Wert des Parameters
EngineName entspricht. Falls EngineName nicht angegeben wurde,
sucht sie nach dem voreingestellten lokalen Datenbankserver.
♦ Falls kein passender Server gefunden wird, schlägt die Funktion fehl.
♦ Die Funktion sendet eine Anforderung an den Server, alle Datenbanken
zu finden und zu beenden.
♦ Sie entlädt den Datenbankserver.

db_string_connect-Funktion
Prototyp
Argumente
Beschreibung
db_string_disconnect-Funktion
Prototyp
Kapitel 6 Programmieren mit Embedded SQL
Als Voreinstellung beendet diese Funktion einen Datenbankserver nicht,
solange noch eine Verbindung zu dieser Datenbank offen ist. Falls
Unconditional mit yes belegt ist, wird der Datenbankserver beendet, auch
wenn noch Verbindungen offen sind.
Ein C-Programm kann diese Funktion nutzen anstatt DBSTOP aufzurufen.
Ist der Rückgabewert TRUE, sind keine Fehler aufgetreten.
Die Verwendung von db_stop_engine hängt von den Berechtigungen ab, die
mit der Serveroption -gk festgelegt wurden.
$ Weitere Hinweise finden Sie unter "–gk-Serveroption" auf Seite 157
der Dokumentation ASA Datenbankadministration.
unsigned int db_string_connect( SQLCA * sqlca, char * parms );
sqlca Ein Zeiger auf eine SQLCA-Struktur. Hinweise dazu finden Sie unter
"SQL-Kommunikationsbereich (SQLCA)" auf Seite 208.
parms Eine auf NULL endende Zeichenfolge, die eine durch Semikolons
getrennte Liste mit Parametereinstellungen enhält, und zwar in der Form
STICHWORT=Wert. Zum Beispiel:
"UID=DBA;PWD=SQL;DBF=c:\\db\\MeineDatenbank.db"
$ Eine Liste der Verbindungsparameter finden Sie unter
"Verbindungsparameter" auf Seite 182 der Dokumentation ASA
Datenbankadministration.
Liefert zusätzliche Funktionalität über den Embedded SQL-Befehl
CONNECT hinaus. Diese Funktion führt eine Verbindung aus, wobei der
Algorithmus verwendet wird, der in "Fehlerbehandlung bei Verbindungen"
auf Seite 82 der Dokumentation ASA Datenbankadministration beschrieben
wird.
Der Rückgabewert ist wahr (ungleich Null), falls eine Verbindung
zustandekam, andernfalls ist er falsch (Null). Informationen über Fehler beim
Starten des Servers, beim Starten der Datenbank oder beim
Verbindungsaufbau werden im SQLCA-Bereich zurückgegeben.
unsigned int db_string_disconnect( SQLCA * sqlca, char * parms );
267

Referenz der Bibliotheksfunktion
Argumente
Beschreibung
db_string_ping_server-Funktion
Prototyp
Beschreibung
268
sqlca Ein Zeiger auf eine SQLCA-Struktur. Hinweise dazu finden Sie unter
"SQL-Kommunikationsbereich (SQLCA)" auf Seite 208.
parms Eine auf NULL endende Zeichenfolge, die eine durch Semikolons
getrennte Liste mit Parametereinstellungen enhält, und zwar in der Form
STICHWORT=Wert. Zum Beispiel:
"UID=DBA;PWD=SQL;DBF=c:\\db\\MeineDatenbank.db"
$ Eine Liste der Verbindungsparameter finden Sie unter
"Verbindungsparameter" auf Seite 182 der Dokumentation ASA
Datenbankadministration.
Diese Funktion trennt die Verbindung, die mit dem Parameter
ConnectionName angegeben wurde. Alle anderen Parameter werden
ignoriert.
Falls der Parameter ConnectionName in der Zeichenfolge fehlt, wird die
unbenannte Verbindung getrennt. Dies entspricht dem Embedded SQL-
Befehl DISCONNECT. Der Boolesche Rückgabewert ist wahr, falls eine
Verbindung erfolgreich getrennt wurde. Informationen über Fehler werden
im SQLCA-Bereich zurückgegeben.
Diese Funktion fährt die Datenbank herunter, falls sie mit dem Parameter
AutoStop=yes gestartet wurde, und falls keine anderen Verbindungen mit
der Datenbank bestehen. Es beendet auch den Serverbetrieb, falls der Server
mit dem Parameter AutoStop=yes gestartet wurde, und falls keine weitere
Datenbank mehr auf dem Server läuft.
unsigned int db_string_ping_server(
SQLCA * sqlca,
char * connect_string,
unsigned int connect_to_db );
connect_string ist eine normale Verbindungszeichenfolge, die eventuell
Server- und Datenbankinformationen enthält.
Wenn connect_to_db nicht gleich Null (d.h. wahr) ist, dann versucht die
Funktion eine Verbindung zu einer Datenbank auf einem Server herzustellen.
Es wird nur ein Wert ungleich Null (d.h. wahr) zurückgegeben, wenn die
Verbindungszeichenfolge ausreicht, um eine Verbindung zu einer benannten
Datenbank auf dem benannten Server herzustellen.

fill_s_sqlda-Funktion
Prototyp
Beschreibung
fill_sqlda-Funktion
Prototyp
Beschreibung
free_filled_sqlda-Funktion
Prototyp
Beschreibung
Kapitel 6 Programmieren mit Embedded SQL
Wenn connect_to_db gleich Null ist, versucht die Funktion lediglich, die
Position eines Servers zu ermitteln. Es wird nur ein Wert ungleich Null
zurückgegeben, wenn die Verbindungszeichenfolge ausreicht, um die
Position eines Servers zu ermitteln. Es wird nicht versucht, eine Verbindung
zur Datenbank herzustellen.
struct sqlda * fill_s_sqlda(
struct sqlda * sqlda,
unsigned int maxlen );
Diese Funktion entspricht fill_sqlda,, abgesehen davon, dass sie alle
Datentypen in sqlda in den Datentyp DT_STRING umwandelt. Es wird
genügend Speicherplatz zugewiesen, um die eine Repräsentation des
Datentyps als Zeichenfolge zu speichern, der ursprünglich im SQLDA-
Bereich angegeben wurde, und zwar bis zu maximal maxlen Byte. Die
Längenfelder im SQLDA-Bereich (sqllen) werden dementsprechend
geändert. Die Funktion gibt im Erfolgsfall sqlda zurück und den Null-Zeiger,
falls nicht genügend Speicherplatz zur Verfügung stand.
struct sqlda * fill_sqlda( struct sqlda * sqlda );
Diese Funktion weist alle Variable, die in den Deskriptoren von sqlda
beschrieben sind, Speicherplatz zu und ordnet die Speicheradressen dem
Feld sqldata des entsprechenden Deskriptors zu. Es wird genügend
Speicherplatz zugewiesen für den im Deskriptor angegebenen Datenbanktyp
und die angegebene Länge. Die Funktion gibt im Erfolgsfall sqlda zurück
und den Null-Zeiger, falls nicht genügend Speicherplatz zur Verfügung
stand.
void free_filled_sqlda( struct sqlda * sqlda );
Diese Funktion gibt den Speicherplatz frei, der einem sqldata-Zeiger und
dem SQLDA-Bereich selbst zugewiesen war. Null-Zeiger werden nicht
freigegeben.
Durch Aufrufen dieser Funktion wird automatisch auch free_sqlda
aufgerufen und alle Deskriptoren, die durch alloc_sqlda zugewiesen waren,
freigegeben.
269

Referenz der Bibliotheksfunktion
free_sqlda-Funktion
Prototyp
Beschreibung
free_sqlda_noind-Funktion
Prototyp
Beschreibung
sql_needs_quotes-Funktion
Prototyp
Beschreibung
270
void free_sqlda( struct sqlda *sqlda );
Diese Funktion gibt Speicherplatz, der diesem sqlda zugewiesen wurde, und
den Speicherplatz der Indikatorvariablen, der in fill_sqlda zugewiesen
wurde, frei. Sie sollten den von den sqldata -Zeigern referenzierten
Speicherplatz nicht freigeben.
void free_sqlda_noind( struct sqlda * sqlda );
Diese Funktion gibt den Speicherplatz frei, der dem sqlda zugewiesen war.
Sie sollten den von den sqldata -Zeigern referenzierten Speicherplatz nicht
freigeben. Die Indikatorvariablen-Zeiger werden nicht beachtet.
"Eigenschaften von Datenbanken" auf Seite 690 der Dokumentation ASA
Datenbankadministration
"Das Ping-Dienstprogramm" auf Seite 550 der Dokumentation ASA
Datenbankadministration
unsigned int sql_needs_quotes( SQLCA *sqlca, char *str );
Diese Funktion gibt einen Booleschen Wert zurück, der anzeigt, ob eine
Zeichenfolge mit Anführungszeichen eingeschlossen werden muss, wenn sie
als SQL-Name (identifier) benutzt wird. Sie formuliert eine Anforderung an
den Datenbankserver, um festzustellen, ob Anführungszeichen nötig sind.
Die relevante Information wird im Feld sqlcode gespeichert.
Wir unterscheiden drei unterschiedliche Kombinationen von Rückgabewert
und Code:
♦ return = FALSE, sqlcode = 0 In diesem Fall braucht die Zeichenfolge
mit Sicherheit keine Anführungszeichen.
♦ return = TRUE In diesem Fall ist sqlcode immer mit SQLE_WARNING
belegt und die Zeichenfolge braucht mit Sicherheit Anführungszeichen.
♦ return = FALSE Falls sqlcode mit etwas anderem als
SQLE_WARNING belegt ist, ist das Testergebnis unklar.

sqlda_storage-Funktion
Prototyp
Beschreibung
sqlda_string_length-Funktion
Prototyp
Beschreibung
sqlerror_message-Funktion
Prototyp
Beschreibung
Kapitel 6 Programmieren mit Embedded SQL
unsigned long sqlda_storage( struct sqlda *sqlda, int varno );
Die Funktion gibt die Speichergröße zurück, die erforderlich wäre, um jeden
möglichen Wert der in sqlda->sqlvar[varno] beschriebenen Variable zu
speichern.
unsigned long sqlda_string_length( SQLDA *sqlda, int varno );
Diese Funktion gibt die Länge zurück, die eine C-Zeichenfolge (Typ
DT_STRING) haben müsste, um die Variable sqlda->sqlvar[varno]
aufzunehmen (unabhängig vom Datentyp).
char *sqlerror_message( SQLCA *sqlca, char * buffer, int max );
Diese Funktion gibt einen Zeiger auf eine Zeichenfolge zurück, die eine
Fehlermeldung enthält. Die Fehlermeldung enthält den Text für den
Fehlercode im SQLCA-Bereich. Wurde kein Fehler gemeldet, wird ein Null-
Zeiger zurückgegeben. Die Fehlermeldung wird in dem gelieferten Puffer
gespeichert, falls erforderlich, gekürzt auf die Länge max.
271

Befehlszusammenfassung für Embedded SQL
Befehlszusammenfassung für Embedded SQL
272
Alle Embedded SQL Anweisungen beginnen mit EXEC SQL und
enden mit einem Semikolon (;).
Es gibt zwei Gruppen von Embedded SQL-Befehlen: Standard-SQL-Befehle
werden benutzt, indem sie einfach in ein C-Programm geschrieben werden,
eingeschlossen von EXEC SQL und einem Semikolon (;). CONNECT,
DELETE, SELECT, SET und UPDATE haben zusätzliche Formate, die nur
in Embedded SQL zur Verfügung stehen. Die zusätzlichen Formate gehören
zur zweiten Gruppe der Embedded SQL-spezifischen Befehle.
$ Eine Beschreibung der Standard-SQL-Befehle finden Sie unter "SQL-
Anweisungen" auf Seite 217 der Dokumentation ASA SQL-
Referenzhandbuch.
Mehrere SQL-Befehle sind spezifisch für Embedded SQL und können nur
innerhalb eines C-Programms benutzt werden.
$ Weitere Hinweise über die Embedded SQL-Befehle finden Sie unter
"SQL-Sprachelemente" auf Seite 3 der Dokumentation ASA SQL-
Referenzhandbuch.
Standardmäßige Datenbearbeitung und Datendefinitions-Anweisungen
können von Embedded SQL-Anwendungen verwendet werden. Darüber
hinaus gelten die folgenden Anweisungen speziell für die Programmierung
von Embedded SQL:
♦ ALLOCATE DESCRIPTOR Speicher für einen Deskriptor zuweisen
$ Siehe "ALLOCATE DESCRIPTOR-Anweisung [ESQL]" auf
Seite 222 der Dokumentation ASA SQL-Referenzhandbuch
♦ CLOSE Einen Cursor schließen
$ Siehe "CLOSE-Anweisung [ESQL] [GP]" auf Seite 285 der
Dokumentation ASA SQL-Referenzhandbuch
♦ CONNECT Mit der Datenbank verbinden
$ Siehe "CONNECT-Anweisung [ESQL] [Interactive SQL]" auf
Seite 292 der Dokumentation ASA SQL-Referenzhandbuch
♦ DEALLOCATE DESCRIPTOR Speicher freigeben, der für einen
Deskriptor reserviert war
$ Siehe "DEALLOCATE DESCRIPTOR-Anweisung [ESQL]" auf
Seite 410 der Dokumentation ASA SQL-Referenzhandbuch

Kapitel 6 Programmieren mit Embedded SQL
♦ Deklarationsabschnitt Hostvariable für die Kommunikation mit der
Datenbank deklarieren
$ Siehe "Deklarationsabschnitt [ESQL]" auf Seite 421 der
Dokumentation ASA SQL-Referenzhandbuch
♦ DECLARE CURSOR Einen Cursor deklarieren
$ Siehe "DECLARE CURSOR-Anweisung [ESQL] [GP]" auf
Seite 412 der Dokumentation ASA SQL-Referenzhandbuch
♦ DELETE (positioniert) Die Zeilen an der aktuellen Cursorposition
löschen
$ Siehe "DELETE-Anweisung (positionsbasiert) [ESQL] [GP]" auf
Seite 424 der Dokumentation ASA SQL-Referenzhandbuch
♦ DESCRIBE Die Hostvariable für eine bestimmte SQL-Anweisung
deklarieren
$ Siehe "DESCRIBE-Anweisung [ESQL]" auf Seite 426 der
Dokumentation ASA SQL-Referenzhandbuch
♦ DISCONNECT Die Verbindung mit dem Datenbankserver lösen
$ Siehe "DISCONNECT-Anweisung [ESQL] [Interactive SQL]" auf
Seite 430 der Dokumentation ASA SQL-Referenzhandbuch
♦ DROP STATEMENT Ressourcen freigeben, die von einem Prepared-
Statement benutzt werden
$ Siehe "DROP STATEMENT-Anweisung [ESQL]" auf Seite 439
der Dokumentation ASA SQL-Referenzhandbuch
♦ EXECUTE Eine bestimmte SQL-Anweisung ausführen
$ Siehe "EXECUTE-Anweisung [ESQL]" auf Seite 449 der
Dokumentation ASA SQL-Referenzhandbuch
♦ EXPLAIN Die Strategie zur Optimierung eines bestimmten Cursors
erklären
$ Siehe "EXPLAIN-Anweisung [ESQL]" auf Seite 456 der
Dokumentation ASA SQL-Referenzhandbuch
♦ FETCH Eine Zeile aus einem Cursor abrufen
$ Siehe "FETCH-Anweisung [ESQL] [GP]" auf Seite 458 der
Dokumentation ASA SQL-Referenzhandbuch
♦ GET DATA Lange Werte aus einem Cursor abrufen
$ Siehe "GET DATA-Anweisung [ESQL]" auf Seite 471 der
Dokumentation ASA SQL-Referenzhandbuch
273

Befehlszusammenfassung für Embedded SQL
274
♦ GET DESCRIPTOR Angaben zu einer Variablen in einen SQLDA-
Bereich abrufen.
$ Siehe "GET DESCRIPTOR-Anweisung [ESQL]" auf Seite 473 der
Dokumentation ASA SQL-Referenzhandbuch
♦ GET OPTION Die Einstellung einer bestimmten Datenbankoption
abholen
$ Siehe "GET OPTION-Anweisung [ESQL]" auf Seite 475 der
Dokumentation ASA SQL-Referenzhandbuch
♦ INCLUDE Eine Datei ins SQL-Preprocessing einschließen
$ Siehe "INCLUDE-Anweisung [ESQL]" auf Seite 495 der
Dokumentation ASA SQL-Referenzhandbuch
♦ OPEN Einen Cursor öffnen
$ Siehe "OPEN-Anweisung [ESQL] [GP]" auf Seite 523 der
Dokumentation ASA SQL-Referenzhandbuch
♦ PREPARE Eine bestimmte SQL-Anweisung vorbereiten
$ Siehe "PREPARE-Anweisung [ESQL]" auf Seite 533 der
Dokumentation ASA SQL-Referenzhandbuch
♦ PUT Eine Zeile in einen Cursor einfügen
$ Siehe "PUT-Anweisung [ESQL]" auf Seite 538 der Dokumentation
ASA SQL-Referenzhandbuch
♦ SET CONNECTION Die aktive Verbindung ändern
$ Siehe "SET CONNECTION-Anweisung [Interactive SQL]" auf
Seite 578 der Dokumentation ASA SQL-Referenzhandbuch
♦ SET DESCRIPTOR Die Variablen in einem SQLDA-Bereich
beschreiben und Daten im SQLDA-Bereich ablegen
$ Siehe "SET DESCRIPTOR-Anweisung [ESQL]" auf Seite 579 der
Dokumentation ASA SQL-Referenzhandbuch
♦ SET SQLCA Einen anderen als den global voreingestellten SQLCA-
Bereich benutzen
$ Siehe "SET SQLCA-Anweisung [ESQL]" auf Seite 588 der
Dokumentation ASA SQL-Referenzhandbuch
♦ UPDATE (positioniert) Die Zeile an der aktuellen Cursorposition
aktualisieren
$ Siehe "UPDATE-Anweisung (positionsbasiert) [ESQL] [GP]" auf
Seite 626 der Dokumentation ASA SQL-Referenzhandbuch

Kapitel 6 Programmieren mit Embedded SQL
♦ WHENEVER Angeben, welche Aktionen bei Fehlern in SQL-
Anweisungen erfolgen sollen
$ Siehe "WHENEVER-Anweisung [ESQL]" auf Seite 636 der
Dokumentation ASA SQL-Referenzhandbuch
275

Befehlszusammenfassung für Embedded SQL
276

KAPITEL 7
ODBC-Programmierung
Über dieses
Kapitel
Inhalt
In diesem Kapitel finden Sie Hinweise zum Entwickeln von Anwendungen,
die die ODBC-Programmierschnittstelle direkt aufrufen.
Die primäre Dokumentation für die Entwicklung von ODBC-Anwendungen
ist die Microsoft ODBC SDK Documentation, die als Teil des Microsoft
Data Access Components (MDAC) SDK verfügbar ist. Dieses Kapitel
enthält einführende Unterlagen sowie eine Beschreibung der spezifischen
Funktionen für Adaptive Server Anywhere. Sie ist jedoch keine umfassende
Anleitung für die Entwicklung von ODBC-Anwendungen.
Einige Tools zur Entwicklung von Anwendungen, die bereits ODBC
unterstützen, haben eine eigene Programmierschnittstelle, die die ODBC-
Schnittstelle verbirgt. Dieses Kapitel richtet sich nicht an die Benutzer dieser
Tools.
Thema Seite
Einführung in ODBC 278
ODBC-Anwendungen erstellen 280
ODBC-Beispiele 285
ODBC-Handles 287
Verbindung mit einer Datenquelle herstellen 290
SQL-Anweisungen ausführen 294
Mit Ergebnismengen arbeiten 299
Gespeicherte Prozeduren aufrufen 304
Umgang mit Fehlern 306
277

Einführung in ODBC
Einführung in ODBC
Unterstützte
Plattformen
ODBC-Übereinstimmung
Stufen der ODBC-
Unterstützung
Von Adaptive
Server Anywhere
unterstützte
Funktionen
278
Open Database Connectivity (ODBC) ist eine Programmierschnittstelle,
die von der Microsoft Corporation als Standardschnittstelle für Datenbank-
Managementsysteme in Windows-Betriebssystemen definiert wurde. ODBC
ist eine aufrufbasierte Schnittstelle.
Um ODBC-Anwendungen für Adaptive Server Anywhere zu entwickeln,
brauchen Sie:
♦ Adaptive Server Anywhere.
♦ Einen C-Compiler, mit dem Sie Programme in Ihrer
Betriebssystemumgebung erstellen können
♦ Das Microsoft ODBC Software Development Kit. Sie finden es im
Microsoft Developer Network. Es umfasst Dokumentation und Tools,
um ODBC-Anwendungen zu testen.
Adaptive Server Anywhere unterstützt die ODBC API außer unter Windows
auch unter UNIX und Windows CE. Die plattformunabhängige ODBC-
Unterstützung erleichtert die Entwicklung portabler
Datenbankanwendungen.
$ Weitere Informationen zur Auflistung von ODBC-Treibern in verteilten
Transaktionen finden Sie unter "Dreischichtige Datenverarbeitung und
verteilte Transaktionen" auf Seite 399.
Adaptive Server Anywhere bietet Unterstützung für ODBC 3.52.
ODBC-Funktionen werden nach Kompatibilitätsstufen eingeordnet. Eine
Funktion ist entweder Kern, Stufe 1, oder Stufe 2, wobei Stufe 2 den
Standard am besten unterstützt. Diese Funktionen sind aufgeführt in der
Dokumentation ODBC Programmer’s Reference, die von der Microsoft
Corporation als Teil des ODBC Software Development Kits bzw. von der
Microsoft Website unter
http://msdn.microsoft.com/library/default.asp?url=/library/enus/odbc/htm/odbcabout_this_manual.asp
bezogen werden kann.
Der Adaptive Server Anywhere unterstützt die ODBC 3,52 Spezifikation.
♦ Kernübereinstimmung Der Adaptive Server Anywhere unterstützt alle
Kernfunktionen.

ODBC-Rückwärts-
Kompatibilität
Der ODBC-Treiber-
Manager
Kapitel 7 ODBC-Programmierung
♦ Übereinstimmung mit Stufe 1 Adaptive Server Anywhere unterstützt
alle Funktionen der Stufe 1, abgesehen von der asynchronen Ausführung
von ODBC-Funktionen.
Adaptive Server Anywhere unterstützt die gemeinsame Nutzung einer
Verbindung durch mehrfache Threads. Die Anforderungen von
verschiedenen Threads werden von Adaptive Server Anywhere
serialisiert.
♦ Übereinstimmung mit Stufe 2 Adaptive Server Anywhere unterstützt
alle Funktionen der Stufe 2, mit Ausnahme der folgenden:
♦ Dreiteilige Namen von Tabellen und Ansichten. Dies ist auf
Adaptive Server Anywhere nicht anwendbar.
♦ Asynchrone Ausführung von ODBC-Funktionen für bestimmte
einzelne Anweisungen
♦ Die Fähigkeit, Login-Anforderungen und SQL-Anforderungen nach
einer gegebenen Zeit abzubrechen (time out)
Anwendungen, die mit älteren Versionen von ODBC entwickelt wurden,
sind weiter kompatibel mit Adaptive Server Anywhere und dem neueren
ODBC-Treiber-Manager. Die neuen ODBC Funktionen stehen in den älteren
Anwendungen nicht zur Verfügung.
Der ODBC-Treiber-Manager gehört zu der mit Adaptive Server Anywhere
ausgelieferten ODBC-Software. ODBC-Treiber-Manager Version 3 hat eine
neue Schnittstelle für die Konfiguration von ODBC-Datenquellen.
279

ODBC-Anwendungen erstellen
ODBC-Anwendungen erstellen
ODBC-Header-Datei einbeziehen
280
In diesem Abschnitt wird beschrieben, wie einfache ODBC-Anwendungen
kompiliert und gelinkt werden.
Jede C-Quelldatei, die ODBC-Funktionen aufruft, muss eine
plattformspezifische ODBC-Header-Datei einbeziehen. Jede
plattformspezifische Header-Datei schließt die wichtigste ODBC-Header-
Datei odbc.h ein, die alle Funktionen, Datentypen und Konstanten definiert,
die erforderlich sind, um ein ODBC-Programm zu schreiben.
v So wird die ODBC-Header-Datei in eine C-Quelldatei einbezogen:
1 Fügen Sie eine Include-Zeile hinzu, die die betreffende
plattformspezifische Header-Datei referenziert. Folgende Zeilen müssen
benutzt werden:
Betriebssystem Include-Zeile
Windows #include "ntodbc.h"
UNIX #include "unixodbc.h"
Windows CE #include "ntodbc.h"
2 Fügen Sie das Verzeichnis, das die Header-Datei enthält, dem Include-
Pfad Ihres Compilers hinzu.
Die plattformspezifischen Header-Dateien und odbc.h werden im
Unterverzeichnis h Ihres SQL Anywhere-Verzeichnisses installiert.
ODBC-Anwendungen unter Windows verknüpfen
Dieser Abschnitt betrifft nicht Windows CE. Weitere Hinweise finden Sie
unter "ODBC-Anwendungen unter Windows CE verknüpfen" auf Seite 281.
Wenn Sie Ihre Anwendung linken, müssen Sie diese mit der geeigneten
Importbibliothekdatei verbinden. Damit ist der Zugriff auf die ODBC-
Funktionen gewährleistet: Mit der Importbibliothek werden Eintrittspunkte
für den ODBC Driver Manager odbc32.dll definiert. Der Treiber-Manager
seinerseits lädt den Adaptive Server Anywhere-ODBC-Treiber dbodbc8.dll.

Kapitel 7 ODBC-Programmierung
Separate Importbibliotheken werden für Microsoft-, Watcom- und Borland-
Compiler angeboten.
v So wird eine ODBC-Anwendung verknüpft (Windows):
♦ Fügen Sie das Verzeichnis mit der plattformspezifischen
Importbibliothek der Liste der Bibliothekenverzeichnisse hinzu.
Die Importbibliotheken werden im Unterverzeichnis lib des
Verzeichnisses mit den ausführbaren Dateien von Adaptive Server
Anywhere gespeichert und tragen die folgenden Bezeichnungen:
Betriebssystem Compiler Importbibliothek
Windows 95/98 und
Windows NT
Windows 95/98 und
Windows NT
Windows 95/98 und
Windows NT
Microsoft odbc32.lib
Watcom
C/C++
wodbc32.lib
Borland bodbc32.lib
Windows CE Microsoft dbodbc8.lib
ODBC-Anwendungen unter Windows CE verknüpfen
In Windows CE-Betriebssystemen gibt es keinen ODBC-Treiber-Manager.
Mit der Importbibliothek (dbodbc8.lib) werden die Eintrittspunkte direkt in
den Adaptive Server Anywhere-ODBC-Treiber dbodbc8.dll definiert.
Für die verschiedenen Chips, auf denen Windows CE verfügbar ist, werden
separate Versionen dieser DLL zur Verfügung gestellt. Die Dateien befinden
sich in betriebssystemspezifischen Unterverzeichnissen des Verzeichnisses
ce in Ihrem SQL Anywhere-Verzeichnis. Zum Beispiel befindet sich der
ODBC-Treiber für Windows CE mit dem SH3-Chip an folgendem
Speicherort:
C:\Programme\Sybase\SQL Anywhere 8\ce\SH3
$ Eine Liste der unterstützten Versionen von Windows CE finden Sie
unter "Erforderliche Systemausstattung für Adaptive Server Anywhere" auf
Seite 31 der Dokumentation ASA Erste Schritte.
v So wird eine ODBC-Anwendung gelinkt (Windows CE):
1 Fügen Sie das Verzeichnis mit der plattformspezifischen
Importbibliothek der Liste der Bibliothekenverzeichnisse hinzu.
281

ODBC-Anwendungen erstellen
Windows CE und
Unicode
282
Die Importbibliothek trägt den Namen dbodbc8.lib und ist an einem
betriebssystemabhängigen Ort im Verzeichnis ce in Ihrem
SQL Anywhere-Verzeichnis gespeichert. Zum Beispiel befindet sich die
Importbibliothek für Windows CE mit dem SH3-Chip an folgendem
Speicherort:
C:\Programme\Sybase\SQL Anywhere 8\ce\SH3\lib
2 Belegen Sie den Parameter DRIVER= in der Verbindungs-
Zeichenfolge, die an die Funktion SQLDriverConnect weitergegeben
wird.
szConnStrIn =
"driver=BSSuchpfad\dbodbc8.dll;dbf=c:\asademo.db"
wobei BSSuchpfad der vollständige Suchpfad bis zum Chip-spezifischen
Unterverzeichnis Ihres SQL Anywhere-Verzeichnisses auf dem
Windows CE-Gerät ist. Zum Beispiel:
\Programme\Sybase\SQL Anywhere 8\ce\SH3\lib
Das Beispielprogramm (odbc.c) verwendet eine Dateidatenquelle (FileDSN-
Verbindungsparameter) mit dem Namen ASA 8.0 Sample.dsn. Sie können
Dateidatenquellen auf Ihrem Desktopsystem aus dem ODBC-Treiber-
Manager erstellen und sie dann auf Ihr Windows CE-Gerät kopieren.
Adaptive Server Anywhere verwendet die Codierung UTF-8 ist; hierbei
handelt es sich um eine Mehrbyte-Zeichenkodierung, die für die Codierung
von Unicode verwendet werden kann.
Der Adaptive Server Anywhere ODBC-Treiber unterstützt entweder ASCII
(8-Bit)-Zeichenfolgen oder Unicode (Wide Character)-Zeichenfolgen. Das
UNICODE-Makro steuert, ob ODBC-Funktionen ASCII- oder Unicode-
Zeichenfolgen erwarten. Wenn Ihre Anwendung mit dem definierten
UNICODE-Makro erstellt werden muss, Sie aber die ASCII ODBC-
Funktionen nutzen möchten, müssen Sie ebenfalls das
SQL_NOUNICODEMAP-Makro definieren.
Die Beispieldatei Samples\ASA\C\odbc.c veranschaulicht, wie Sie die
Unicode ODBC-Funktionen anwenden.
ODBC-Anwendungen auf UNIX verknüpfen
Adaptive Server Anywhere umfasst keinen ODBC-Treiber-Manager, es gibt
jedoch Treiber-Manager von Drittherstellern. In diesem Abschnitt wird
beschrieben, wie ODBC-Anwendungen aufgebaut werden, die den ODBC-
Treiber-Manager nicht verwenden.

ODBC-Treiber
Datenquelleninformation
ODBC-Treiber-Manager unter UNIX
Kapitel 7 ODBC-Programmierung
Der ODBC-Treiber ist ein gemeinsam genutztes Objekt oder eine gemeinsam
genutzte Bibliothek. Separate Versionen der Adaptive Server Anywhere-
ODBC-Treiber werden für Anwendungen mit einfachem sowie mit mehreren
Threads angeboten.
Die ODBC-Treiber sind folgende Dateien:
Betriebssystem Tread-Modell ODBC-Treiber
Solaris/Sparc Ein Thread dbodbc8.so (dbodbc8.so.1)
Solaris/Sparc Mehrere Threads dbodbc_r.so (dbodbc_r.so.1)
Die Bibliotheken sind mit einer Versionsnummer (in Klammern) als
symbolische Verknüpfungen mit der gemeinsam benutzten Bibliothek
installiert.
v So wird eine ODBC-Anwendung gelinkt (UNIX):
1 Linken Sie Ihre Anwendung direkt mit dem geeigneten ODBC-Treiber.
2 Wenn Sie Ihre Anwendung bereitstellen, achten Sie darauf, dass der
geeignete ODBC-Treiber im Bibliotheks-Suchpfad des Benutzersystems
enthalten ist.
Wenn Adaptive Server Anywhere keinen ODBC-Treiber-Manager findet,
verwendet er die Datei ~/.odbc.ini als Datenquelleninformation.
ODBC-Treiber-Manager für UNIX werden von Drittherstellern angeboten.
Ein ODBC-Treiber-Manager beinhaltet die folgenden Dateien:
Betriebssystem Dateien
Solaris/Sparc libodbc.so (libodbc.so.1)
libodbcinst.so (libodbcinst.so.1)
Solaris/Sparc libodbc.so (libodbc.so.1)
libodbcinst.so (libodbcinst.so.1)
Wenn Sie eine Anwendung bereitstellen, die einen ODBC-Treiber-Manager
erfordert, und Sie keinen Treiber-Manager eines Drittanbieters benutzen,
erstellen Sie symbolische Verknüpfungen für die gemeinsam genutzten
Bibliotheken libodbc und libodbcinst zum Adaptive Server Anywhere-
ODBC-Treiber.
283

ODBC-Anwendungen erstellen
284
Wenn ein ODBC-Treiber-Manager vorhanden ist, fragt der Adaptive Server
Anywhere diesen und nicht ~/.odbc.ini nach Datenquelleninformationen ab
Standard-ODBC-Anwendungen werden im Allgemeinen nicht direkt an den
ODBC-Treiber gelinkt. Statt dessen gehen ODBC-Funktionsaufrufe über den
ODBC-Treiber-Manager. Bei UNIX- und Windows CE-Betriebssystemen
bezieht Adaptive Server Anywhere keinen ODBC-Treiber-Manager ein. Sie
können weiterhin ODBC-Anwendungen erstellen, indem Sie sie direkt an
den Adaptive Server Anywhere-ODBC-Treiber linken, jedoch können Sie
dann nur auf Adaptive Server Anywhere-Datenquellen zugreifen.

ODBC-Beispiele
Kapitel 7 ODBC-Programmierung
Mit Adaptive Server Anywhere werden mehrere Beispiele geliefert. Die
Beispiele finden Sie im Unterverzeichnis Samples\ASA Ihres
SQL Anywhere-Verzeichnisses. Standardmäßig ist dies
C:\Programme\Sybase\SQL Anywhere 8\Samples\ASA
Die Beispiele in Verzeichnissen, die mit ODBC beginnen, veranschaulichen
separate und einfache ODBC-Aufgaben, wie etwa eine Verbindung mit einer
Datenbank herstellen und Anweisungen ausführen. Ein vollständiges ODBC-
Beispielprogramm finden Sie unter Samples\ASA\C\odbc.c. Das Programm
führt dieselben Aktionen aus wie das Beispielprogramm für einen
dynamischen Cursor in Embedded SQL, das sich im gleichen Verzeichnis
befindet.
$ Eine Beschreibung des entsprechenden Embedded SQL-Programms
finden Sie unter "Beispielprogramme mit Embedded SQL" auf Seite 190.
ODBC-Beispielprogramm erstellen
Das ODBC-Beispielprogramm in Samples\ASA\C umfasst eine
Stapelverarbeitungsdatei (Shell-Skript für UNIX), die eingesetzt werden
kann, um die Beispielanwendung zu kompilieren und zu linken.
v So wird das ODBC-Beispielprogramm erstellt
1 Öffnen Sie eine Befehlszeile und wechseln Sie in das Unterverzeichnis
Samples\ASA\C Ihres SQL Anywhere-Verzeichnisses.
2 Führen Sie die Stapeldatei makeall oder das Shell-Skript aus.
Die Syntax des Befehls ist wie folgt:
makeall API Plattform Compiler
Die Parameter sind wie folgt:
♦ API Geben Sie odbc an, damit das ODBC-Beispiel kompiliert wird
und nicht eine Embedded SQL-Version der Anwendung.
♦ Plattform Geben Sie WINNT an wenn Sie für Windows-
Betriebssystem kompilieren wollen.
♦ Compiler Geben Sie den Compiler an, mit dem das Programm
kompiliert werden soll. Folgende Compiler sind möglich:
♦ WC - Watcom C/C++
♦ MC - Microsoft Visual C++
285

ODBC-Beispiele
286
♦ BC - Borland C++ Builder
ODBC-Beispielprogramm ausführen
Das Beispielprogramm odbc.c kann als Dienst laufen, wenn es für Windows-
Versionen kompiliert wurde, die Dienste unterstützen.
Die beiden Dateien, die den Beispielcode für Windows-Dienste enthalten,
sind die Quelldatei ntsvc.c und die Header-Datei ntsvc.h. Der Code
ermöglicht es, das damit gelinkte ausführbare Programm entweder als
normales Programm oder als Windows-Dienst auszuführen.
v So wird das ODBC-Beispiel ausgeführt:
1 Starten Sie das Programm:
♦ Führen Sie die Datei Samples\ASA\C\odbcwnt.exe aus.
2 Wählen Sie eine Tabelle:
♦ Wählen Sie eine der Tabellen in der Beispieldatenbank. Sie können
z.B. Customer oder Employee eingeben.
v Um das ODBC-Beispiel als Windows-Dienst auszuführen, gehen Sie
wie folgt vor:
1 Starten Sie Sybase Central und öffnen Sie den Ordner "Dienste".
2 Klicken Sie auf "Dienst hinzufügen". Folgen Sie den Anweisungen, um
das Beispielprogramm den NT-Diensten hinzuzufügen.
3 Rechtsklicken Sie auf das Dienstsymbol und klicken Sie auf "Start", um
den Dienst zu starten.
Wird das Programm als Dienst ausgeführt, zeigt es, falls dies möglich ist, die
normale Benutzeroberfläche. Es schreibt die Ausgabe in die Ereignisanzeige
unter der Rubrik "Anwendungen". Falls die Benutzeroberfläche nicht
gestartet werden kann, schreibt das Programm eine Seite in die
Ereignisanzeige und hält an.

ODBC-Handles
Kapitel 7 ODBC-Programmierung
ODBC-Anwendungen verwenden eine kleine Anzahl von Handles, um
grundlegende Funktionen wie Datenbankverbindungen und SQL-
Anweisungen zu definieren. Ein Handle ist ein 32-Bit-Wert.
Die folgenden Handles werden in nahezu allen ODBC-Anwendungen
eingesetzt.
♦ Umgebung Das Umgebungs-Handle liefert einen globalen Kontext, in
dem auf Daten zugegriffen wird. Jede ODBC-Anwendung muss beim
Start genau einen Umgebungs-Handle zuweisen und es bei Beendigung
wieder freigeben.
Der folgende Code veranschaulicht, wie ein Umgebungs-Handle
zugewiesen wird:
SQLHENV env;
SQLRETURN rc;
rc = SQLAllocHandle( SQL_HANDLE_ENV, SQL
_NULL_HANDLE, &env );
♦ Verbindung Ein Verbindungs-Handle wird von einem ODBC-Treiber
und einer Datenquelle angegeben. Eine Anwendung kann über mehrere,
ihrer Umgebung zugeordnete Verbindungen verfügen. Ein Verbindungs-
Handle zuzuweisen heißt nicht, eine Verbindung herzustellen. Ein
Verbindungs-Handle muss zunächst zugewiesen und dann verwendet
werden, wenn die Verbindung hergestellt ist.
Der folgende Code veranschaulicht, wie ein Verbindungs-Handle
zugewiesen wird:
SQLHDBC dbc;
SQLRETURN rc;
rc = SQLAllocHandle( SQL_HANDLE_DBC, env, &dbc );
♦ Anweisung Ein Anweisungs-Handle bietet Zugriff auf eine SQL-
Anweisung und damit verbundene Daten, wie etwa Ergebnisgruppen
und Parameter. Jede Verbindung kann mehrere Anweisungen haben.
Anweisungen werden sowohl für Cursorvorgänge (Daten abrufen) als
auch für die Ausführung einfacher Anweisungen benutzt (z.B. INSERT,
UPDATE und DELETE).
Der folgende Code veranschaulicht, wie ein Anweisungs-Handle
zugewiesen wird:
SQLHSTMT stmt;
SQLRETURN rc;
rc = SQLAllocHandle( SQL_HANDLE_STMT, dbc, &stmt );
287

ODBC-Handles
ODBC-Handles zuweisen
Beispiel
288
Die für ODBC-Programme erforderlichen Handle-Typen sind:
Element Handle-Typ
Umgebung SQLHENV
Verbindung SQLHDBC
Anweisung SQLHSTMT
Deskriptor SQLHDESC
v So wird ein ODBC-Handle verwendet:
1 Funktion SQLAllocHandle aufrufen.
SQLAllocHandle nimmt die folgenden Parameter an:
♦ Einen Bezeichner für den Typ des zuzuweisenden Elements
♦ Das Handle des übergeordneten Elements
♦ Einen Zeiger auf den Ort, an dem das Handle zugewiesen wird
$ Eine vollständige Beschreibung finden Sie unter SQLAllocHandle
in der Microsoft-Dokumentation ODBC Programmer’s Reference.
2 Das Handle in nachfolgenden Funktionsaufrufen verwenden.
3 Das Objekt mit SQLFreeHandle freisetzen.
SQLFreeHandle nimmt die folgenden Parameter an:
♦ Einen Bezeichner für den Typ des freizusetzenden Elements
♦ Das Handle des freizusetzenden Elements
$ Eine vollständige Beschreibung finden Sie unter SQLFreeHandle
in der Microsoft-Dokumentation ODBC Programmer's Reference.
Mit dem folgenden Codefragment wird ein Umgebungs-Handle zugewiesen
und freigesetzt:
SQLHENV env;
SQLRETURN retcode;
retcode = SQLAllocHandle( SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env );
if( retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO ) {
// Erfolg: Hier den Anwendungscode
}
SQLFreeHandle( SQL_HANDLE_ENV, env );
$ Weitere Hinweise zu Rückgabecodes und Fehlerbehandlung finden Sie
unter "Umgang mit Fehlern" auf Seite 306.

Ein erstes ODBC-Beispiel
#include
#include "ntodbc.h"
Kapitel 7 ODBC-Programmierung
Es folgt ein einfaches ODBC-Programm, dass eine Verbindung mit der
Adaptive Server Anywhere-Beispieldatenbank herstellt und diese sofort
wieder trennt.
$ Dieses Beispiel finden Sie als
Samples\ASA\ODBCConnect\odbcconnect.cpp in Ihrem SQL Anywhere-
Verzeichnis.
int main(int argc, char* argv[])
{
SQLHENV env;
SQLHDBC dbc;
SQLRETURN retcode;
retcode = SQLAllocHandle( SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env );
if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {
printf( "env allocated\n" );
/* Umgebungsattribut ODBC-Version setzen */
retcode = SQLSetEnvAttr( env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
retcode = SQLAllocHandle( SQL_HANDLE_DBC, env, &dbc );
if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {
printf( "dbc allocated\n" );
retcode = SQLConnect( dbc,
(SQLCHAR*) "ASA 8.0 Sample", SQL_NTS,
(SQLCHAR* ) "DBA", SQL_NTS,
(SQLCHAR*) "SQL", SQL_NTS );
if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {
printf( "Successfully connected\n" );
}
SQLDisconnect( dbc );
}
SQLFreeHandle( SQL_HANDLE_DBC, dbc );
}
SQLFreeHandle( SQL_HANDLE_ENV, env );
return 0;
}
289

Verbindung mit einer Datenquelle herstellen
Verbindung mit einer Datenquelle herstellen
290
In diesem Abschnitt wird beschrieben, wie ODBC-Funktionen zum
Herstellen einer Verbindung mit einer Adaptive Server Anywhere-
Datenbank eingesetzt werden.
Eine ODBC-Verbindungsfunktion wählen
ODBC bietet eine Reihe von Verbindungsfunktionen. Welche Sie
verwenden, hängt davon ab, wie Ihre Anwendung bereitgestellt und benutzt
werden soll:
♦ SQLConnect Die einfachste Verbindungsfunktion.
SQLConnect nimmt einen Datenquellennamen und eine fakultative
Benutzer-ID und ein fakultatives Benutzkennkennwort an. Verwenden
Sie SQLConnect, wenn Sie einen Datenquellennamen in Ihrer
Anwendung hartcodieren.
$ Weitere Hinweise finden Sie unter SQLConnect in der Microsoft
Dokumentation ODBC Programmer’s Reference.
♦ SQLDriverConnect Stellt mit Hilfe einer Verbindungszeichenfolge eine
Verbindung zu einer Datenquelle her.
Mit SQLDriverConnect kann die Anwendung Adaptive Server
Anywhere-spezifische Verbindungsdaten verwenden, die unabhängig
von der Datenquelle sind. Darüber hinaus können Sie
SQLDriverConnect benutzen, um anzufordern, dass der Adaptive
Server Anywhere-Treiber zur Eingabe von Verbindungsdaten auffordert.
SQLDriverConnect kann auch benutzt werden, um eine Verbindung
herzustellen, ohne dass eine Datenquelle angegeben wird.
$ Weitere Hinweise finden Sie unter SQLDriverConnect in der
Microsoft Dokumentation ODBC Programmer’s Reference.
♦ SQLBrowseConnect Stellt wie SQLDriverConnect mit Hilfe einer
Verbindungszeichenfolge eine Verbindung zu einer Datenquelle her.
Mit SQLBrowseConnect kann Ihre Anwendung eigene Dialogfelder
aufbauen, die zur Eingabe von Verbindungsdaten auffordern und nach
Datenquellen suchen, die von einem bestimmten Treiber verwendet
werden (in diesem Fall der Adaptive Server Anywhere-Treiber).
$ Weitere Hinweise finden Sie unter SQLBrowseConnect in der
Microsoft Dokumentation ODBC Programmer’s Reference.

Eine Verbindung herstellen
Kapitel 7 ODBC-Programmierung
In den Beispielen in diesem Kapitel wird hauptsächlich SQLDriverConnect
verwendet.
$ Eine vollständige Liste der Verbindungsparameter, die in
Verbindungszeichenfolgen eingesetzt werden können, finden Sie unter
"Verbindungsparameter" auf Seite 182 der Dokumentation ASA
Datenbankadministration.
Ihre Anwendung muss eine Verbindung herstellen, bevor sie
Datenbankvorgänge ausführen kann.
v So wird eine ODBC-Verbindung hergestellt:
1 ODBC-Umgebung zuweisen.
Zum Beispiel:
SQLHENV env;
SQLRETURN retcode;
retcode = SQLAllocHandle( SQL_HANDLE_ENV,
SQL_NULL_HANDLE, &env );
2 ODBC-Version deklarieren.
Wenn Sie deklarieren, dass die Anwendung ODBC Version 3 befolgen
soll, werden SLQSTATE-Werte und einige andere versionsabhängige
Funktionen auf das entsprechende Verhalten eingestellt. Zum Beispiel:
retcode = SQLSetEnvAttr( env,
SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
3 Falls erforderlich, die Datenquelle oder Verbindungszeichenfolge
zusammenstellen.
Je nach Ihrer Anweisung können Sie eine Datenquelle oder
Verbindungszeichenfolge hartcodieren oder sie für erhöhte Flexibilität
extern speichern.
4 Ein ODBC-Verbindungselement zuweisen.
Zum Beispiel:
retcode = SQLAllocHandle( SQL_HANDLE_DBC, env, &dbc
);
5 Diejenigen Verbindungsattribute festlegen, die vor dem Verbinden
eingerichtet sein müssen.
291

Verbindung mit einer Datenquelle herstellen
Hinweise
Verbindungsattribute festlegen
292
Einige Verbindungsattribute müssen festgelegt werden, bevor eine
Verbindung hergestellt wird, während andere vorher oder nachher
eingerichtet werden können. Zum Beispiel:
retcode = SQLSetConnectAttr( dbc,
SQL_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_OFF, 0
);
$ Weitere Hinweise finden Sie unter "Verbindungsattribute
festlegen" auf Seite 292.
6 ODBC-Verbindungsfunktion aufrufen.
Zum Beispiel:
if (retcode == SQL_SUCCESS || retcode ==
SQL_SUCCESS_WITH_INFO) {
printf( "dbc allocated\n" );
retcode = SQLConnect( dbc,
(SQLCHAR*) "ASA 8.0 Sample", SQL_NTS,
(SQLCHAR* ) "DBA", SQL_NTS,
(SQLCHAR*) "SQL", SQL_NTS );
if (retcode == SQL_SUCCESS
|| retcode == SQL_SUCCESS_WITH_INFO){
// Verbindung erfolgreich hergestellt.
$ Ein vollständiges Beispiel finden Sie in
Samples\ASA\ODBCConnect\odbcconnect.cpp in Ihrem SQL Anywhere-
Verzeichnis.
♦ SQL_NTS Jede Zeichenfolge, die an ODBC übergeben wird, hat eine
entsprechende Länge. Ist die Länge unbekannt, können Sie SQL_NTS
als Argument verwenden, um anzuzeigen, dass es sich um einen Null
Terminated String handelt, dessen Ende durch das Nullzeichen
gekennzeichnet ist (\0).
♦ SQLSetConnectAttr Voreingestellt arbeitet ODBC im Autocommit-
Modus. Dieser Modus wird abgeschaltet, indem SQL_AUTOCOMMIT
auf "false" gesetzt wird.
$ Weitere Hinweise finden Sie unter "Verbindungsattribute
festlegen" auf Seite 292.
Die Funktion SQLSetConnectAttr wird eingesetzt, um Verbindungsdetails zu
steuern. Zum Beispiel deaktiviert die folgende Anweisung das ODBC-
Autocommit-Verhalten.
retcode = SQLSetConnectAttr( dbc, SQL_AUTOCOMMIT,
(SQLPOINTER)SQL_AUTOCOMMIT_OFF, 0 );

Kapitel 7 ODBC-Programmierung
$ Weitere Hinweise sowie eine Liste der Verbindungsattribute finden Sie
unter SQLSetConnectAttr in der Microsoft Dokumentation ODBC
Programmer’s Reference .
Viele Aspekte der Verbindung können über die Verbindungsparameter
gesteuert werden. Hinweise finden Sie unter "Verbindungsparameter" auf
Seite 78 der Dokumentation ASA Datenbankadministration.
Threads und Verbindungen in ODBC-Anwendungen
Sie können ODBC-Anwendungen mit mehreren Threads für Adaptive Server
Anywhere entwickeln. Es wird empfohlen, dass Sie für jeden Thread eine
eigene Verbindung benutzen.
Sie können für mehrfache Threads eine einfache Verbindung benutzen. Der
Datenbankserver erlaubt allerdings nicht mehr als eine aktive Anforderung
für eine Verbindung zur gleichen Zeit. Falls ein Thread eine Anweisung
ausführt, die lange braucht, müssen alle anderen Threads warten, bis die
Anforderung abgeschlossen ist.
293

SQL-Anweisungen ausführen
SQL-Anweisungen ausführen
Anweisungen direkt ausführen
294
ODBC umfasst mehrere Funktionen zum Ausführen von SQL-Anweisungen:
♦ Direkte Ausführung Adaptive Server Anywhere führt eine syntaktische
Analyse der SQL-Anweisung durch, bereitet einen Zugriffsplan vor und
führt die Anweisung aus. Das syntaktische Analysieren und das
Vorbereiten des Zugriffsplans wird Vorbereitung der Anweisung
genannt.
♦ Vorbereitete Ausführung Die Vorbereitung der Anweisung erfolgt
getrennt von der Ausführung. Bei Anweisungen, die wiederholt
ausgeführt werden sollen wird damit vermieden, dass wiederholt
vorbereitet werden muss. Damit wird die Performance verbessert.
$ Siehe "Vorbereitete Anweisungen ausführen" auf Seite 297.
Mit der Funktion SQLExecDirect wird eine SQL-Anweisung vorbereitet
und ausgeführt. Die Anweisung kann auch Parameter enthalten.
Das folgende Codefragment veranschaulicht, wie eine Anweisung ohne
Parameter ausgeführt wird. Die Funktion SQLExecDirect nimmt ein
Anweisungs-Handle, eine SQL-Zeichenfolge und eine Länge bzw. ein
Abschlusszeichen an, falls ein Zeichenfolgeindikator mit
Nullabschlusszeichen erforderlich ist.
Das in diesem Abschnitt beschriebene Verfahren ist zwar einfach, aber
unflexibel. Die Anweisung kann keine Benutzereingabe zur Änderung der
Anweisung annehmen. Flexiblere Methoden zum Aufbau von Anweisungen
finden Sie unter "Anweisungen mit gebundenen Parametern ausführen" auf
Seite 295.
v So wird eine SQL-Anweisung in einer ODBC-Anwendung
ausgeführt:
1 Der Anweisung mit SQLAllocHandle ein Handle zuweisen.
Mit der folgenden Anweisung wird z.B. bei einer Verbindung mit dem
Handle dbc ein Handle vom Typ SQL_HANDLE_STMT mit dem Namen
stmt zugewiesen:
SQLAllocHandle( SQL_HANDLE_STMT, dbc, &stmt );
2 Funktion SQLExecDirect aufrufen und die Anweisung ausführen:

Kapitel 7 ODBC-Programmierung
Mit den folgenden Zeilen wird z.B. eine Anweisung deklariert und
ausgeführt. Die Deklaration von deletestmt würde normalerweise am
Anfang der Funktion auftreten:
SQLCHAR deletestmt[ STMT_LEN ] =
"DELETE FROM department WHERE dept_id = 201";
SQLExecDirect( stmt, deletestmt, SQL_NTS) ;
$ Ein vollständiges Beispiel mit Fehlerprüfung finden Sie unter
Samples\ASA\ODBCExecute\odbcexecute.cpp.
$ Weitere Hinweise zu SQLExecDirect finden Sie unter SQLExecDirect
in der Microsoft-Dokumentation ODBC Programmer’s Reference.
Anweisungen mit gebundenen Parametern ausführen
In diesem Abschnitt wird beschrieben, wie eine SQL-Anweisung aufgebaut
und ausgeführt wird, bei der zum Festlegen der Werte von
Anweisungsparametern gebundene Parameter eingesetzt werden.
v So wird eine SQL-Anweisung mit gebundenen Parametern in einer
ODBC-Anwendung ausgeführt:
1 Der Anweisung mit SQLAllocHandle ein Handle zuweisen.
Mit der folgenden Anweisung wird z.B. bei einer Verbindung mit dem
Handle dbc ein Handle vom Typ SQL_HANDLE_STMT mit dem Namen
stmt zugewiesen:
SQLAllocHandle( SQL_HANDLE_STMT, dbc, &stmt );
2 Anweisungsparameter mit SQLBindParameter binden.
Zum Beispiel werden mit den folgenden Zeilen Variable deklariert, die
Werte für Abteilungs-ID, Abteilungsname und Manager-ID, sowie die
Anweisungszeichenfolge selbst enthalten sollen. Als Nächstes werden
Parameter an den ersten, zweiten und dritten Parameter einer Anweisung
gebunden, die mit dem Anweisungs-Handle stmt ausgeführt wird.
295

SQL-Anweisungen ausführen
296
#defined DEPT_NAME_LEN 20
SQLINTEGER cbDeptID = 0,
cbDeptName = SQL_NTS, cbManagerID = 0;
SQLCHAR deptname[ DEPT_NAME_LEN ];
SQLSMALLINT deptID, managerID;
SQLCHAR insertstmt[ STMT_LEN ] =
"INSERT INTO department "
"( dept_id, dept_name, dept_head_id )"
"VALUES (?, ?, ?,)";
SQLBindParameter( stmt, 1, SQL_PARAM_INPUT,
SQL_C_SSHORT, SQL_INTEGER, 0, 0,
&deptID, 0, &cbDeptID);
SQLBindParameter( stmt, 2, SQL_PARAM_INPUT,
SQL_C_CHAR, SQL_CHAR, DEPT_NAME_LEN, 0,
deptname, 0,&cbDeptName);
SQLBindParameter( stmt, 3, SQL_PARAM_INPUT,
SQL_C_SSHORT, SQL_INTEGER, 0, 0,
&managerID, 0, &cbManagerID);
3 Den Parametern Werte zuweisen.
Mit den folgenden Zeilen werden z.B. den Parametern im Fragment von
Schritt 2 Werte zugewiesen.
deptID = 201;
strcpy( (char * ) deptname, "Sales East" );
managerID = 902;
Im Allgemeinen werden diese Variablen als Reaktion auf eine
Benutzerhandlung festgelegt.
4 Führen Sie die Anweisung mit SQLExecDirect aus.
Mit der folgenden Zeile wird z.B. eine Anweisungszeichenfolge
ausgeführt, die sich in insertstmt im Anweisungs-Handle stmt
befindet.
SQLExecDirect( stmt, insertstmt, SQL_NTS) ;
Gebundene Parameter werden auch mit vorbereiteten Anweisungen
verwendet, um die Performance von Anweisungen zu steigern, die mehr als
einmal ausgeführt werden sollen. Weitere Hinweise finden Sie unter
"Vorbereitete Anweisungen ausführen" auf Seite 297.
$ Die obigen Codefragmente enthalten keine Fehlerprüfung. Ein
vollständiges Beispiel mit Fehlerprüfung finden Sie unter
Samples\ASA\ODBCExecute\odbcexecute.cpp.
$ Weitere Hinweise zu SQLExecDirect finden Sie unter SQLExecDirect
in der Microsoft-Dokumentation ODBC Programmer’s Reference.

Vorbereitete Anweisungen ausführen
Kapitel 7 ODBC-Programmierung
Vorbereitete Anweisungen bieten Performance-Vorteile bei häufig benutzten
Anweisungen. ODBC bietet eine vollständige Menge von Funktionen für
vorbereitete Anweisungen.
$ Eine Einführung in vorbereitete Anweisungen finden Sie unter
"Anweisungen vorbereiten" auf Seite 12.
v So wird eine vorbereitete Anweisung ausgeführt:
1 Die Anweisung mit SQLPrepare vorbereiten.
Das folgende Codefragment veranschaulicht z.B., wie eine INSERT-
Anweisung vorbereitet wird:
SQLRETURN retcode;
SQLHSTMT stmt;
retcode = SQLPrepare( stmt,
"INSERT INTO department
( dept_id, dept_name, dept_head_id )
VALUES (?, ?, ?,)",
SQL_NTS);
In diesem Beispiel gilt:
♦ retcode Enthält einen Rückgabecode, der auf Erfolg oder
Fehlschlag des Vorgangs überprüft werden sollte
♦ stmt Liefert ein Handle zu der Anweisung, sodass sie später
referenziert werden kann.
♦ ? Die Fragezeichen sind Platzhalter für Anweisungsparameter.
2 Mit SQLBindParameter Anweisungsparameter mit Werten belegen.
Der folgende Funktionsaufruf zum Beispiel belegt den Wert der
Variablen dept_id:
SQLBindParameter( stmt,
1,
SQL_PARAM_INPUT,
SQL_C_SSHORT,
SQL_INTEGER,
0,
0,
&sDeptID,
0,
&cbDeptID);
In diesem Beispiel gilt:
♦ stmt ist das Anweisungs-Handle
297

SQL-Anweisungen ausführen
298
♦ 1 zeigt an, dass dieser Aufruf den ersten Platzhalter mit einem Wert
belegt.
♦ SQL_PARAM_INPUT zeigt an, dass der Parameter eine
Eingabeanweisung ist.
♦ SQL_C_SHORT zeigt den C-Datentyp an, der in der Anwendung
verwendet wird.
♦ SQL_INTEGER zeigt den SQL-Datentyp an, der in der Datenbank
verwendet wird.
♦ Die nächsten beiden Parameter zeigen die Spaltengröße und die
Anzahl der Dezimalstellen an: beide sind mit 0 (Null) für
Ganzzahlen belegt.
♦ &sDeptID ist ein Zeiger auf einen Puffer für den Parameterwert.
♦ 0 gibt die Länge des Puffers in Byte an.
♦ &cbDeptID ist ein Zeiger auf einen Puffer für die Länge des
Parameterwerts.
3 Die beiden anderen Parameter binden und sDeptId Werte zuordnen.
4 Die Anweisung ausführen:
retcode = SQLExecute( stmt);
Schritte 2 bis 4 können mehrfach ausgeführt werden.
5 Anweisung löschen.
Das Löschen der Anweisung setzt die der Anweisung zugewiesenen
Ressourcen frei. Anweisungen werden mit SQLFreeHandle gelöscht.
$ Ein vollständiges Beispiel mit Fehlerprüfung finden Sie unter
Samples\ASA\ODBCPrepare\odbcprepare.cpp.
$ Weitere Hinweise zu SQLPrepare finden Sie unter SQLPrepare in der
Microsoft-Dokumentation ODBC Programmer’s Reference.

Mit Ergebnismengen arbeiten
Cursor-Eigenschaften wählen
Kapitel 7 ODBC-Programmierung
ODBC-Anwendungen verwenden Cursor zum Bearbeiten und Aktualisieren
von Ergebnismengen. Adaptive Server Anywhere bietet umfassende
Unterstützung für verschiedene Arten von Cursorn und Cursorvorgängen.
$ Eine Einführung zu Cursorn finden Sie unter "Mit Cursorn arbeiten"
auf Seite 20.
ODBC-Funktionen, die Anweisungen ausführen und Ergebnismengen
verarbeiten, verwenden für diese Aufgaben Cursor. Anwendungen öffnen
implizit einen Cursor, wenn sie eine Funktion SQLExecute oder
SQLExecDirect ausführen.
Bei Anwendungen, die sich nur vorwärts durch eine Ergebnismenge
bewegen und sie nicht aktualisieren, ist das Cursor-Verhalten recht einfach.
Standardmäßig erwarten ODBC-Anwendungen dieses Verhalten. ODBC
definiert einen Nur-Lesen-Cursor, der nur vorwärts liest und Adaptive Server
Anywhere liefert einen Cursor, der für diesen Fall auf Performance optimiert
ist.
$ Ein einfaches Beispiel für einen nur vorwärts lesenden Cursor finden
Sie unter "Daten abrufen" auf Seite 300.
Bei Anwendungen, die sowohl vorwärts als auch rückwärts durch die
Ergebnismenge blättern müssen, wie etwa Anwendungen mit grafischer
Benutzeroberfläche, ist das Cursor-Verhalten komplexer. Wie reagiert die
Anwendung, wenn sie eine Zeile zurückgibt, die von einer anderen
Anwendung aktualisiert wurde? ODBC definiert eine Reihe von
abrollenden Cursorn, damit Sie das gewünschte Verhalten in Ihre
Anwendung einbauen können. Adaptive Server Anywhere liefert eine
vollständige Gruppe von Cursorn, die mit den abrollenden ODBC-
Cursortypen übereinstimmen.
Die erforderlichen Cursor-Merkmale werden mit der Funktion
SQLSetStmtAttr gesetzt, die die Anweisungsattribute definiert. Sie müssen
SQLSetStmtAttr aufrufen, bevor Sie eine Anweisung ausführen, die eine
Ergebnismenge erzeugt.
Viele Cursor-Merkmale können mit SQLSetStmtAttr festgelegt werden.
Folgende Merkmale bestimmen den von Adaptive Server Anywhere
gelieferten Cursortyp:
299

Mit Ergebnismengen arbeiten
Beispiel
Daten abrufen
300
♦ SQL_ATTR_CURSOR_SCROLLABLE Für einen abrollenden Cursor
auf SQL_SCROLLABLE setzen und auf SQL_NONSCROLLABLE für
Vorwärts-Cursor. SQL_NONSCROLLABLE ist der Standardwert.
♦ SQL_ATTR_CONCURRENCY Auf einen der folgenden Werte setzen:
♦ SQL_CONCUR_READ_ONLY Aktualisierungen deaktivieren.
SQL_CONCUR_READ_ONLY ist der Standardwert.
♦ SQL_CONCUR_LOCK Verwenden Sie die niedrigste Sperrstufe,
die ausreicht, um eine Zeile zu aktualisieren.
♦ SQL_CONCUR_ROWVER Verwenden Sie optimistische
Parallelitätssteuerung, bei der Zeilenversionen verglichen werden,
wie z.B. SQLBase ROWID oder Sybase TIMESTAMP.
♦ SQL_CONCUR_VALUES Verwenden Sie optimistische
Parallelitätssteuerung, bei der Werte verglichen werden.
$ Weitere Hinweise finden Sie unter SQLSetStmtAttr in der Microsoft-
Dokumentation ODBC Programmer’s Reference.
Für das folgende Fragment ist ein abrollender Nur-Lesen-Cursor
erforderlich:
SQLAllocHandle( SQL_HANDLE_STMT, dbc, &stmt );
SQLSetStmtAttr( stmt, SQL_ATTR_CURSOR_SCROLLABLE,
SQL_SCROLLABLE, 0 );
Um Zeilen aus einer Datenbank abzurufen, führen Sie mit SQLExecute oder
SQLExecDirect eine SELECT-Anweisung aus. Damit wird ein Cursor für
die Anweisung geöffnet. Als Nächstes verwenden Sie SQLFetch oder
SQLExtendedFetch, damit über den Cursor Zeilen abgerufen werden.
Wenn eine Anwendung die Anweisung mit Hilfe von SQLFreeHandle
freigibt, wird der Cursor geschlossen.
Um Werte von einem Cursor abzurufen, kann die Anwendung entweder
SQLBindCol oder SQLGetData verwenden. Falls Sie SQLBindCol
benutzen, werden die Werte mit jedem Abruf (fetch) abgeholt. Falls Sie
SQLGetData benutzen, müssen Sie sie für jede Spalte nach jedem Abruf
(fetch) aufrufen.
SQLGetData wird benutzt, um Werte in Teilen für Spalten wie LONG
VARCHAR oder LONG BINARY einzulesen. Alternativ können Sie das
SQL_MAX_LENGTH-Anweisungsattribut auf einen Wert setzen, der groß
genug ist, um den Wert für die gesamte Spalte aufzunehmen. Der
Standardwert für SQL_ATTR_MAX_LENGTH ist 256 KByte.

Kapitel 7 ODBC-Programmierung
Mit dem folgenden Codefragment wird ein Cursor für eine Abfrage geöffnet
und Daten über den Cursor abgerufen. Auf eine Fehlerüberprüfung wurde
verzichtet, um das Beispiel leichter lesbar zu halten. Das Fragment stammt
aus dem vollständigen Beispiel Samples\ASA\ODBCSelect\odbcselect.cpp.
SQLINTEGER cbDeptID = 0, cbDeptName = SQL_NTS, cbManagerID = 0;
SQLCHAR deptname[ DEPT_NAME_LEN ];
SQLSMALLINT deptID, managerID;
SQLHENV env;
SQLHDBC dbc;
SQLHSTMT stmt;
SQLRETURN retcode;
SQLAllocHandle( SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env );
SQLSetEnvAttr( env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
SQLAllocHandle( SQL_HANDLE_DBC, env, &dbc );
SQLConnect( dbc,
(SQLCHAR*) "ASA 8.0 Sample", SQL_NTS,
(SQLCHAR*) "DBA", SQL_NTS,
(SQLCHAR*) "SQL", SQL_NTS );
SQLAllocHandle( SQL_HANDLE_STMT, dbc, &stmt );
SQLBindCol( stmt, 1, SQL_C_SSHORT, &deptID, 0, &cbDeptID);
SQLBindCol( stmt, 2, SQL_C_CHAR, deptname, sizeof(deptname),
&cbDeptName);
SQLBindCol( stmt, 3, SQL_C_SSHORT, &managerID, 0, &cbManagerID);
SQLExecDirect( stmt, (SQLCHAR * )
"SELECT dept_id, dept_name, dept_head_id FROM DEPARTMENT "
"ORDER BY dept_id", SQL_NTS );
while( ( retcode = SQLFetch( stmt ) ) != SQL_NO_DATA ){
printf( "%d %20s %d\n", deptID, deptname, managerID );
}
SQLFreeHandle( SQL_HANDLE_STMT, stmt );
SQLDisconnect( dbc );
SQLFreeHandle( SQL_HANDLE_DBC, dbc );
SQLFreeHandle( SQL_HANDLE_ENV, env );
Die Anzahl der Zeilenpositionen, die Sie mit einem Fetch-Vorgang abrufen
können, wird durch die Größe einer Ganzzahl bestimmt. Mit einem Fetch-
Vorgang können Sie Zeilen bis zu Nummer 2147483646 abrufen, wobei es
sich um die größtmögliche Ganzzahl minus 1 handelt. Wenn Sie negative
Werte verwenden (Zeilen in Bezug auf das Ende), können Sie Fetch-
Vorgänge nach unten bis zum niedrigsten negativen Wert, der in einer
Ganzzahl möglich ist, plus 1 ausführen.
301

Mit Ergebnismengen arbeiten
Zeilen über einen Cursor aktualisieren und löschen
302
Im Dokument "Microsoft ODBC Programmer’s Reference" wird empfohlen,
dass Sie SELECT ... FOR UPDATE benutzen, um anzuzeigen, dass eine
Abfrage mit positionierten Vorgängen aktualisierbar ist. In Adaptive Server
Anywhere brauchen Sie die Klausel FOR UPDATE nicht zu benutzen:
SELECT-Anweisungen können automatisch aktualisiert werden, sofern die
folgenden Bedingungen erfüllt sind:
♦ Die zu Grunde liegende Abfrage unterstützt Aktualisierungen.
Unter der Voraussetzung, dass eine Datenänderungsanweisung für die
Spalten im Ergebnis sinnvoll ist, kann also die
Datenänderungsanweisung im Cursor ausgeführt werden.
Die Datenbankoption ANSI_UPDATE_CONSTRAINTS schränkt den
Typ aktualisierbarer Abfragen ein.
$ Weitere Hinweise finden Sie unter
"ANSI_UPDATE_CONSTRAINTS" auf Seite 615 der Dokumentation
ASA Datenbankadministration.
♦ Der Cursortyp unterstützt Aktualisierungen.
Wenn Sie einen Nur-Lese-Cursor verwenden, können Sie die
Ergebnismenge nicht aktualisieren.
Es gibt in ODBC zwei Alternativen, um positionsbasierte Updates und
positionsbasiertes Löschen durchzuführen.
♦ Die Funktion SQLSetPos.
Abhängig von den angegebenen Parametern (SQL_POSITION,
SQL_REFRESH, SQL_UPDATE, SQL_DELETE) legt SQLSetPos die
Cursorposition fest und ermöglicht es der Anwendung, die Darstellung
der Daten in der Ergebnismenge oder die Daten selbst zu aktualisieren
oder die Daten zu löschen.
Diese Methode muss bei Adaptive Server Anywhere angewendet
werden.
♦ Mit Hilfe von SQLExecute positionsbasierte UPDATE- und DELETE-
ANWEISUNGEN senden. Diese Methode darf nicht bei Adaptive
Server Anywhere angewendet werden.

Bookmarks verwenden
Kapitel 7 ODBC-Programmierung
ODBC bietet Bookmarks, die benutzt werden, um Zeilen in einem Cursor zu
identifizieren. Adaptive Server Anywhere unterstützt Lesezeichen
(Bookmarks, Textmarken) für alle Arten von Cursorn, mit Ausnahme von
dynamischen Cursorn.
Vor der ODBC-Version 3.0 konnte eine Datenbank nur angeben, ob sie
Bookmarks unterstützt oder nicht: Es gab keine Schnittstelle, die diese
Informationen für jeden Cursortyp bereitstellte. Der Datenbankserver hatte
keine Möglichkeit, anzugeben, welche Typen von Cursor-Bookmarks
unterstützt werden. Für ODBC 2-Anwendungen gibt Adaptive Server
Anywhere nur zurück, dass er Bookmarks unterstützt. ODBC wird Sie also
nicht an dem Versuch hindern, Bookmarks mit dynamischen Cursorn zu
benutzen; Sie sollten diese Kombination allerdings vermeiden.
303

Gespeicherte Prozeduren aufrufen
Gespeicherte Prozeduren aufrufen
Prozeduren und
Ergebnismengen
Beispiel
304
In diesem Abschnitt wird beschrieben, wie gespeicherte Prozeduren
aufgerufen und die Ergebnisse in einer ODBC-Anwendung bearbeitet
werden.
$ Eine vollständige Beschreibung von gespeicherten Prozeduren und
Triggern finden Sie unter "Prozeduren, Trigger und Anweisungsfolgen
verwenden" auf Seite 565 der Dokumentation ASA SQL-Benutzerhandbuch.
Es gibt zwei Arten von Prozeduren: Prozeduren, die Ergebnismengen
zurückgeben und solche, die keine zurückgeben. Sie können
SQLNumResultCols verwenden, um den Unterschied festzustellen: die
Anzahl der Ergebnisspalten ist 0 (Null), falls die Prozedur keine
Ergebnismenge zurückgibt. Falls eine Ergebnismenge zurückgegeben wird,
können Sie die Werte mit SQLFetch oder SQLExtendedFetch abrufen, wie
bei jedem anderen Cursor.
Parameter müssen an Prozeduren mit Parametermarkierungen (Fragezeichen)
übergeben werden. Verwenden Sie SQLBindParameter, um jeder
Parametermarkierung einen Speicherbereich zuzuweisen: INPUT, OUTPUT
oder INOUT.
Um mehrfache Ergebnismengen verarbeiten zu können, muss ODBC den
aktuell ausgeführten Cursor beschreiben, und nicht die von der Prozedur
definierte Ergebnismenge. Deshalb bezeichnet ODBC die Spaltennamen
nicht immer so, wie sie in der RESULT-Klausel der gespeicherten Prozedur
definiert sind. Um dieses Problem zu vermeiden, können Sie im
Ergebnismengencursor Ihrer Prozedur einen Spaltenalias verwenden.
Mit diesem Beispiel wird eine Prozedur erstellt und aufgerufen, die keine
Ergebnismenge zurückgibt. Die Prozedur übernimmt einen INOUT-
Parameter und erhöht seinen Wert. Im Beispiel wird die Variable num_col
den Wert 0 (Null) haben, denn die Prozedur gibt keine Ergebnismenge
zurück. Auf eine Fehlerüberprüfung wurde verzichtet, um das Beispiel
leichter lesbar zu halten.
HDBC dbc;
HSTMT stmt;
long i;
SWORD num_col;
/* Prozedur erstellen */
SQLAllocStmt( dbc, &stmt );
SQLExecDirect( stmt,
"CREATE PROCEDURE Increment( INOUT a INT )" \
" BEGIN" \
" SET a = a + 1" \
" END", SQL_NTS );

Beispiel
Kapitel 7 ODBC-Programmierung
/* Prozedur zur Erhöhung von 'i' aufrufen */
i = 1;
SQLBindParameter( stmt, 1, SQL_C_LONG, SQL_INTEGER, 0,
0, &i, NULL );
SQLExecDirect( stmt, "CALL Increment( ? )",
SQL_NTS );
SQLNumResultCols( stmt, &num_col );
do_something( i );
Mit dem folgenden Beispiel wird eine Prozedur aufgerufen, die eine
Ergebnismenge zurückgibt. Im Beispiel hat die Variable num_col den Wert
2, denn die Prozedur gibt eine Ergebnismenge mit zwei Spalten zurück. Auf
eine Fehlerüberprüfung wurde auch hier verzichtet, um das Beispiel leichter
lesbar zu halten.
HDBC dbc;
HSTMT stmt;
SWORD num_col;
RETCODE retcode;
char emp_id[ 10 ];
char emp_lame[ 20 ];
/* Prozedur erstellen */
SQLExecDirect( stmt,
"CREATE PROCEDURE employees()" \
" RESULT( emp_id CHAR(10), emp_lname CHAR(20))"\
" BEGIN" \
" SELECT emp_id, emp_lame FROM employee" \
" END", SQL_NTS );
/* Prozedur aufrufen - Ergebnisse ausgeben */
SQLExecDirect( stmt, "CALL employees()", SQL_NTS );
SQLNumResultCols( stmt, &num_col );
SQLBindCol( stmt, 1, SQL_C_CHAR, &emp_id,
sizeof(emp_id), NULL );
SQLBindCol( stmt, 2, SQL_C_CHAR, &emp_lname,
sizeof(emp_lname), NULL );
for( ;; ) {
retcode = SQLFetch( stmt );
if( retcode == SQL_NO_DATA_FOUND ) {
retcode = SQLMoreResults( stmt );
if( retcode == SQL_NO_DATA_FOUND ) break;
} else {
do_something( emp_id, emp_lname );
}
}
305

Umgang mit Fehlern
Umgang mit Fehlern
306
Fehler in ODBC werden mit dem Rückgabewert jedes einzelnen ODBC-
Funktionsaufrufs und entweder mit der Funktion SQLError oder der
Funktion SQLGetDiagRec gemeldet. Die Funktion SQLError wurde in
ODBC-Versionen bis Version 3 (ausschließlich Version 3) verwendet. Ab
Version 3 wird die Funktion SQLError nicht mehr weiter entwickelt und
durch die Funktion SQLGetDiagRec ersetzt.
Jede ODBC-Funktion gibt einen SQLRETURN zurück, der einen der
folgenden Statuscodes annehmen kann:
Statuscode Beschreibung
SQL_SUCCESS Kein Fehler.
SQL_SUCCESS_WITH_INFO Die Funktion wurde vollständig ausgeführt, aber
ein Aufruf von SQLError zeigt eine Warnung an.
Der häufigste Grund für diesen Status ist, dass ein
Wert zurückgegeben wurde, der für den von der
Anwendung zur Verfügung gestellten Puffer zu
lang ist.
SQL_ERROR Die Funktion wurde wegen eines Fehlers nicht
vollständig ausgeführt. Sie können SQLError
ausführen, um mehr Informationen über das
Problem zu erhalten.
SQL_INVALID_HANDLE Ein ungültiger Umgebungs-, Verbindungs- oder
Statement-Handle wurden als Argument
übergeben.
Dies passiert häufig, wenn ein Handle benutzt
wird, nachdem es freigegeben wurde, oder falls
das Handle ein Null-Zeiger ist.
SQL_NO_DATA_FOUND Keine Hinweise verfügbar.
Der häufigste Grund für diesen Staus ist, dass -
beim Abrufen von einem Cursor - keine weiteren
Zeilen mehr in dem Cursor waren.
SQL_NEED_DATA Für einen Parameter werden Daten benötigt.
Dies ist eine erweiterte Funktion, die in der
Hilfedatei unter SQLParamData und
SQLPutData beschrieben wird.

Beispiel 1
Kapitel 7 ODBC-Programmierung
Mit jeder Umgebung, jeder Verbindung und jedem Statement-Handle können
ein oder mehrere Fehler oder Warnungen verbunden sein. Jeder Aufruf von
SQLError oder SQLGetDiagRec gibt Hinweise für einen Fehler zurück
und entfernt die Hinweise über diesen Fehler. Falls Sie SQLError oder
SQLGetDiagRec nicht aufrufen, um alle Fehlermeldungen zu entfernen,
werden die Fehlermeldungen beim nächsten Funktionsaufruf entfernt, der
das gleiche Handle als Parameter übergibt.
Jeder Aufruf von SQLError kann drei Handles für Umgebung, Verbindung
und Anweisung übergeben. Der erste Aufruf benutzt SQL_NULL_HSTMT,
um den mit einer Verbindung zusammenhängenden Fehler zu erhalten. Auf
die gleiche Weise gibt ein Aufruf mit SQL_NULL_DBC und
SQL_NULL_HSTMT alle mit dem Umgebungshandle zusammenhängenden
Fehler zurück.
Jeder Aufruf von SQLGetDiagRec kann entweder ein Umgebungs-,
Verbindungs- oder Anweisungshandle übergeben. Der erste Aufruf benutzt
SQL_HANDLE_DBC, um den mit einer Verbindung zusammenhängenden
Fehler zurückzugeben. Der zweite Aufruf benutzt SQL_HANDLE_STMT,
um den mit der soeben ausgeführten Anweisung zusammenhängenden Fehler
zurückzugeben.
SQLError und SQLGetDiagRec geben SQL_SUCCESS zurück, falls ein
Fehler zu melden ist (nicht SQL_ERROR), und SQL_NO_DATA_FOUND,
falls keine weiteren Fehler zu melden sind.
Das folgende Programmfragment benutzt SQLError und gibt
Rückgabecodes zurück:
307

Umgang mit Fehlern
Beispiel 2
308
/* Erforderliche Variable deklarieren */
SQLHDBC dbc;
SQLHSTMT stmt;
SQLRETURN retcode;
UCHAR errmsg[100];
/* Hier wurde Code ausgelassen */
retcode = SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt );
if( retcode == SQL_ERROR ){
SQLError( env, dbc, SQL_NULL_HSTMT, NULL, NULL,
errmsg, sizeof(errmsg), NULL );
/* Annahme: print_error ist definiert.
print_error( "Failed SQLAllocStmt", errmsg );
return;
}
/* Artikel für Auftrag 2015 löschen */
retcode = SQLExecDirect( stmt,
"delete from sales_order_items where id=2015",
SQL_NTS );
if( retcode == SQL_ERROR ) {
SQLError( env, dbc, stmt, NULL, NULL,
errmsg, sizeof(errmsg), NULL );
/* Annahme: print_error ist definiert.
print_error( "Elemente konnten nicht gelöscht
werden", errmsg );
return;
Die Beispiele übergeben den Null-Zeiger für einige der Parameter von
SQLError. Die ODBC-Dokumentation enthält eine vollständige
Beschreibung von SQLError und all seinen Parametern.
Der folgende Auszug aus einem Beispielcode benutzt SQLGetDiagRec und
Rückgabecodes:
/* Erforderliche Variablen deklarieren */
SQLHDBC dbc;
SQLHSTMT stmt;
SQLRETURN retcode;
SQLSMALLINT errmsglen;
SQLINTEGER errnative;
UCHAR errmsg[255];
UCHAR errstate[5];
/* Hier wurde Code weggelassen */
retcode = SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt );
if( retcode == SQL_ERROR ){
SQLGetDiagRec(SQL_HANDLE_DBC, dbc, 1, errstate,
&errnative, errmsg, sizeof(errmsg), &errmsglen);
/* Annahme: print_error ist definiert */
print_error( "Allocation failed", errstate,
errnative, errmsg );
return;

}
/* Artikel für Auftrag 2015 löschen */
Kapitel 7 ODBC-Programmierung
retcode = SQLExecDirect( stmt,
"delete from sales_order_items where id=2015",
SQL_NTS );
if( retcode == SQL_ERROR ) {
SQLGetDiagRec(SQL_HANDLE_STMT, stmt, recnum,
errstate,
&errnative, errmsg, sizeof(errmsg), &errmsglen);
/* Annahme: print_error ist definiert*/
print_error("Failed to delete items", errstate,
errnative, errmsg );
return;
}
309

Umgang mit Fehlern
310

KAPITEL 8
Die DBTools-Schnittstelle
Über dieses
Kapitel
Inhalt
In diesem Kapitel wird beschrieben, wie die DBTools-Bibliothek benutzt
wird, die zum Lieferumfang von Adaptive Server Anywhere gehört und Coder
C++-Anwendungen zusätzlich mit Funktionen der
Datenbankverwaltung ausstattet.
Thema Seite
Einführung in die DBTools-Schnittstelle 312
DBTools-Schnittstelle verwenden 314
DBTools-Funktionen 323
DBTools-Strukturen 335
DBTools-Aufzählungstypen 367
311

Einführung in die DBTools-Schnittstelle
Einführung in die DBTools-Schnittstelle
Unterstützte
Plattformen
Windows CE
Die dbtools.h-
Header-Datei
312
Mit dem Sybase Adaptive Server Anywhere wird Sybase Central und eine
Serie von Dienstprogrammen mitgeliefert, die für die Verwaltung von
Datenbanken verwendet werden können. Diese Dienstprogramme für die
Datenbankverwaltung übernehmen bestimmte Aufgaben, wie etwa das
Sichern und Erstellen von Datenbanken, die Übersetzung von
Transaktionslogs in SQL, usw.
Alle Dienstprogramme für die Datenbankverwaltung benutzen eine
gemeinsame Bibliothek, die DBTools-Bibliothek. Sie wird für die
Betriebssysteme Windows Windows 95/98 und Windows NT mitgeliefert.
Der Name der Bibliothek lautet dbtool8.dll.
Sie können Ihre eigenen Dienstprogramme für die Datenbankverwaltung
entwickeln oder Funktionen der Datenbankverwaltung in Ihre Anwendungen
einbauen, indem Sie die DBTools-Bibliothek aufrufen. In diesem Kapitel
wird die Schnittstelle zur DBTools-Bibliothek beschrieben. Wenn Sie dieses
Kapitel lesen, sollten Sie mit der Methode vertraut sein, mit der die von
Ihnen benutzte Entwicklungsumgebung DLLs aufruft.
Die DBTools-Bibliothek hat Funktionen oder Eintrittspunkte für jedes
einzelne Dienstprogramm zur Datenbankverwaltung. Außerdem müssen
Funktionen vor dem Aufruf anderer DBTools-Funktionen, sowie im
Anschluss an die Verwendung anderer DBTools-Funktionen aufgerufen
werden.
Die Bibliothek dbtool8.dll wird für Windows CE geliefert, enthält aber nur
Programmeinstiegspunkte für DBToolsInit, DBToolsFini, DBRemoteSQL
und DBSynchronizeLog. Andere Tools werden für Windows CE nicht
bereitgestellt.
Die DBTools-Header-Datei, die mit dem Adaptive Server Anywhere
mitgeliefert wird, enthält eine Liste der Eintrittspunkte zur DBTools-
Bibliothek und liefert die Strukturen, die benutzt werden, um Daten an die
Bibliothek zu übergeben und von ihr zu beziehen. Die Datei dbtools.h wird
im Unterverzeichnis h im Installationsverzeichnis eingerichtet. In der Datei
dbtools.h finden Sie die neuesten Informationen über die Eintrittspunkte und
die Strukturbestandteile.
Die Header-Datei dbtools.H enthält zwei andere Dateien:
♦ sqlca.h Diese Datei ist für die Auflösung diverser Makros, nicht für
SQLCA selbst, vorgesehen.
♦ dllapi.h Diese Datei definiert Präprozessor-Makros für
betriebssystemabhängige und sprachenabhängige Makros.

Kapitel 8 Die DBTools-Schnittstelle
Die Header-Datei sqldef.h enthält außerdem Fehler-Rückgabewerte.
313

DBTools-Schnittstelle verwenden
DBTools-Schnittstelle verwenden
Importbibliotheken verwenden
Unterstützte
Plattformen
314
Dieser Abschnitt enthält einen Überblick über die Entwicklung von
Anwendungen, die die DBTools-Schnittstelle für die Verwaltung der
Datenbanken verwenden.
Damit die DBTools-Funktionen verwendet werden können, müssen Sie Ihre
Anwendung mit einer DBTools Importbibliothek verknüpfen, die die
erforderlichen Funktionsdefinitionen enthält.
Importbibliotheken sind Compiler-spezifisch und werden für Windows-
Betriebssysteme mit Ausnahme von Windows CE geliefert.
Importbibliotheken für die DBTools-Schnittstelle werden mit dem Adaptive
Server Anywhere mitgeliefert und können im Unterverzeichnis lib des
jeweiligen Betriebssystemverzeichnisses im Installationsverzeichnis
gefunden werden. Folgende DBTools-Importbibliotheken werden geliefert:
Compiler Bibliothek
Watcom win32\dbtlstw.lib
Microsoft win32\dbtlstM.lib
Borland win32\dbtlstB.lib
DBTools-Bibliothek starten und beenden
Bevor Sie andere DBTools-Funktionen verwenden, müssen Sie DBToolsInit
aufrufen. Wenn Sie die DBTools DLL nicht mehr verwenden, müssen Sie
DBToolsFini aufrufen.
Die Funktionen DBToolsInit und DBToolsFini bezwecken hauptsächlich,
der DBTools-DLL das Laden der Adaptive Server Anywhere Sprachen-DLL
zu ermöglichen. Die Sprachen-DLL enthält lokalisierte Versionen aller
Fehlermeldungen und Bedieneraufforderungen, die DBTools intern
verwendet. Wenn DBToolsFini nicht aufgerufen wird, kann die
Referenznummer der Sprachen-DLL nicht heruntergezählt werden, sodass
diese DLL nicht entladen wird. Achten Sie daher immer darauf, dass zu
jedem Aufruf von DBToolsInit als Gegenstück DBToolsFini aufgerufen
wird.

Kapitel 8 Die DBTools-Schnittstelle
Im folgenden Programmcodebeispiel wird gezeigt, wie DBTools aufgerufen
und wieder bereinigt werden:
// Deklarationen
a_dbtools_info info;
short ret;
DBTools-Funktionen aufrufen
//Initialisierung der a_dbtools_info-Struktur
memset( &info, 0, sizeof( a_dbtools_info) );
info.errorrtn = (MSG_CALLBACK)MyErrorRtn;
// Initialisierung von DBTools
ret = DBToolsInit( &info );
if( ret != EXIT_OKAY ) {
// DLL-Initialisierung fehlgeschlagen
…
}
// einige DBTools-Routinen aufrufen. . .
…
// DBTools dll bereinigen
DBToolsFini( &info );
Alle Tools werden aufgerufen, indem erst eine Struktur ausgefüllt und dann
eine Funktion (oder ein Eintrittspunkt) in der DBTools-DLL aufgerufen
wird. Jeder Eintrittspunkt nimmt einen Zeiger zu einer bestimmten Struktur
als Argument.
Im folgenden Beispiel wird gezeigt, wie die DBBackup-Funktion unter
einem Windows-Betriebssystem verwendet wird.
// Initialisierung der Struktur
a_backup_db backup_info;
memset( &backup_info, 0, sizeof( backup_info ) );
// Struktur ausfüllen
backup_info.version = DB_TOOLS_VERSION_NUMBER;
backup_info.output_dir = "C:\BACKUP";
backup_info.connectparms
="uid=DBA;pwd=SQL;dbf=asademo.db";
backup_info.startline = "dbeng8.EXE";
backup_info.confirmrtn = (MSG_CALLBACK) ConfirmRtn ;
backup_info.errorrtn = (MSG_CALLBACK) ErrorRtn ;
backup_info.msgrtn = (MSG_CALLBACK) MessageRtn ;
backup_info.statusrtn = (MSG_CALLBACK) StatusRtn ;
backup_info.backup_database = TRUE;
// Sicherung starten
DBBackup( &backup_info );
315

DBTools-Schnittstelle verwenden
316
$ Hinweise zu den Bestandteilen der DBTools-Strukturen finden Sie
unter "DBTools-Strukturen" auf Seite 335.
Rückgabecodes der Softwarekomponenten
Alle Datenbanktools werden als Eintrittspunkt in einer DLL geliefert. Diese
Eintrittspunkte verwenden die folgenden Rückgabecodes:
Program
mcode
Erklärung
0 Erfolg
1 Allgemeiner Ausfall
2 Ungültiges Dateiformat
3 Datei nicht gefunden, kann nicht geöffnet werden
4 Kein Speicher mehr
5 Beendet vom Benutzer
6 Fehlgeschlagene Kommunikationen
7 Erforderlicher Datenbankname fehlt
8 Falsches Client/Server-Protokoll
9 Keine Verbindung mit dem Datenbankserver möglich
10 Datenbankserver läuft nicht
11 Datenbankserver nicht gefunden
254 Stoppzeit erreicht
Callback-Funktionen verwenden
Nutzung der
Callback-
Funktionen
255 Ungültige Parameter in der Befehlszeile
Einige Elemente in der DBTools-Struktur sind vom Typ
MSG_CALLBACK. Es handelt sich dabei um Zeiger auf Callback-
Funktionen.
Mit Callback-Funktionen können DBTools-Funktionen die Kontrolle der
Verarbeitung an die aufrufende Anwendung des Benutzers zurückgeben. Die
DBTools-Bibliothek benutzt Callback-Funktionen zur Verarbeitung von
Nachrichten, die von den DBTools-Funktionen an den Benutzer gesandt
werden, für vier Zwecke:

Callback-Funktion
einer Struktur
zuordnen
Beispiel für eine
Callback-Funktion
mit Bestätigung
Beispiel für eine
Callback-Funktion
mit Fehlermeldung
Kapitel 8 Die DBTools-Schnittstelle
♦ Bestätigung Wird aufgerufen, wenn eine Aktion vom Benutzer bestätigt
werden muss. Falls zum Beispiel das Sicherungsverzeichnis nicht
vorhanden ist, fragt die Tools-DLL, ob es erzeugt werden soll.
♦ Fehlermeldung Wird aufgerufen, um eine Nachricht zu bearbeiten,
wenn ein Fehler auftritt, zum Beispiel, wenn ein Vorgang nicht
genügend Speicherplatz hat
♦ Informationsnachricht Wird aufgerufen, um den Benutzer zu
informieren, wie zum Beispiel eine Nachricht mit den Namen der
Tabelle, die gerade gesichert wird
♦ Statusinformation Wird aufgerufen, um den Status eines Vorgangs
anzuzeigen, wie zum Beispiel, wie viel Prozent einer Tabelle entladen
sind
Sie können der Struktur direkt eine Callback-Routine zuordnen. Die folgende
Anweisung ist ein Beispiel für die Verwendung einer Sicherungsstruktur:
backup_info.errorrtn = (MSG_CALLBACK) MyFunction
MSG_CALLBACK ist in der Header-Datei dllapi.h definiert, die im
Adaptive Server Anywhere enthalten ist. Tools-Routinen können
Nachrichten in die aufrufende Anwendung übergeben, die dann in der
passenden Benutzeroberfläche dargestellt werden sollten; das kann eine
Fensterumgebung sein, die Standardausgabe eines zeichenbasierten Systems
oder andere Benutzeroberflächen.
Im folgenden Beispiel fragt eine Routine den Benutzer nach einer
Bestätigung mit YES oder NO und gibt die Antwort des Benutzers zurück:
extern short _callback ConfirmRtn(
char far * question )
{
int ret;
if( question != NULL ) {
ret = MessageBox( HwndParent, question,
"Confirm", MB_ICONEXCLAMTION|MB_YESNO );
}
return( 0 );
}
Im folgenden Beispiel zeigt eine Routine zur Behandlung einer
Fehlermeldung die Fehlermeldung in einer Meldungsbox an.
extern short _callback ErrorRtn(
char far * errorstr )
{
if( errorstr != NULL ) {
ret = MessageBox( HwndParent, errorstr,
"Backup Error", MB_ICONSTOP|MB_OK );
}
317

DBTools-Schnittstelle verwenden
Beispiel für eine
Callback-Funktion
mit Nachricht
Beispiel für eine
Callback-Funktion
mit Statusmeldung
318
}
return( 0 );
Eine typische Implementierung einer Callback-Funktion, die eine Nachricht
am Bildschirm ausgibt:
extern short _callback MessageRtn(
char far * errorstr )
{
if( messagestr != NULL ) {
OutputMessageToWindow( messagestr );
}
return( 0 );
}
Eine Status-Callback-Routine wird aufgerufen, wenn die Tools den Status
eines Vorgangs anzeigen müssen (zum Beispiel wie viel Prozent einer
Tabelle entladen sind). Im folgenden Beispiel sehen Sie eine typische
Implementierung, die lediglich die Nachricht am Bildschirm ausgibt:
extern short _callback StatusRtn(
char far * statusstr )
{
if( statusstr == NULL ) {
return FALSE;
}
OutputMessageToWindow( statustr );
return TRUE;
}
Versionsnummern und Kompatibilität
Jede Struktur enthält ein Element, das die Versionsnummer angibt. Sie
sollten dieses Versionselement benutzen, um die Version der DBTools-
Bibliothek zu speichern, für die Ihre Anwendung entwickelt wurde. Die
aktuelle Version der DBTools-Bibliothek ist als Konstante in der Header-
Datei dbtools.h enthalten.
v Um einer Struktur die aktuelle Versionsnummer zuzuordnen, gehen
Sie wie folgt vor:
♦ Ordnen Sie die Versionskonstante dem Versionselement der Struktur zu,
bevor Sie die DBTools-Funktion aufrufen. Die folgende Zeile ordnet die
aktuelle Version einer Sicherungsstruktur zu:
backup_info.version = DB_TOOLS_VERSION_NUMBER;

Kompatibilität
Bit-Felder benutzen
Ein Beispiel für DBTools
Kapitel 8 Die DBTools-Schnittstelle
Die Versionsnummer ermöglicht es der Anwendung, auch in Zukunft mit
neueren Versionen der DBTools-Bibliothek weiterzuarbeiten. Die DBTools-
Funktionen sorgen mit Hilfe der Versionsnummern, die von Ihrer
Anwendung zur Verfügung gestellt werden, dafür, dass Ihre Anwendung
auch dann weiterarbeiten kann, wenn neue Elemente zur DBTools-Struktur
hinzugefügt wurden.
Anwendungen arbeiten nicht mit älteren Versionen der DBTools-Bibliothek
zusammen.
Viele DBTools-Strukturen benutzen Bit-Felder, um Boolesche Informationen
kompakt zu speichern. Die Sicherungsstruktur zum Beispiel hat folgende
Bit-Felder:
a_bit_field backup_database : 1;
a_bit_field backup_logfile : 1;
a_bit_field backup_writefile: 1;
a_bit_field no_confirm : 1;
a_bit_field quiet : 1;
a_bit_field rename_log : 1;
a_bit_field truncate_log : 1;
a_bit_field rename_local_log: 1;
Jedes Bit-Feld ist ein Bit lang, angezeigt durch eine 1 rechts neben dem
Doppelpunkt in der Strukturdeklaration. Der hier verwendete Datentyp hängt
vom Wert ab, der am Anfang von dbtools.h a_bit_field zugeordnet wurde,
und ist abhängig vom Betriebssystem.
Sie ordnen dem Bit-Feld einen Wert von 0 (Null) oder 1 zu, um einen
Booleschen Wert an die Struktur zu übergeben.
Dieses Beispiel sowie Hinweise zum Kompilieren finden Sie im
Unterverzeichnis Samples\ASA\DBTools Ihres SQL Anywhere-
Verzeichnisses. Das Beispielprogramm selbst ist
Samples\ASA\DBTools\main.c. Das Beispiel veranschaulicht, wie die
DBTools-Bibliothek zum Sichern der Datenbank eingesetzt werden kann.
# define WINNT
319

DBTools-Schnittstelle verwenden
320
#include
#include "windows.h"
#include "string.h"
#include "dbtools.h"
extern short _callback ConfirmCallBack(char far * str){
if( MessageBox( NULL, str, "Backup",
MB_YESNO|MB_ICONQUESTION ) == IDYES ) {
return 1;
}
return 0;
}
extern short _callback MessageCallBack( char far * str){
if( str != NULL ) {
fprintf( stdout, "%s", str );
fprintf( stdout, "\n" );
fflush( stdout );
}
return 0;
}
extern short _callback StatusCallBack( char far * str ){
if( str != NULL ) {
fprintf( stdout, "%s", str );
fprintf( stdout, "\n" );
fflush( stdout );
}
return 0;
}
extern short _callback ErrorCallBack( char far * str ){
if( str != NULL ) {
fprintf( stdout, "%s", str );
fprintf( stdout, "\n" );
fflush( stdout );
}
return 0;
}
// Haupteintrittspunkt in das Programm.
int main( int argc, char * argv[] ){
a_backup_db backup_info;
a_dbtools_info dbtinfo;
char dir_name[ _MAX_PATH + 1];
char connect[ 256 ];
HINSTANCE hinst;
FARPROC dbbackup;
FARPROC dbtoolsinit;
FARPROC dbtoolsfini;

Kapitel 8 Die DBTools-Schnittstelle
// Immer mit 0 initialisieren, sodass neue Versionen
// der Struktur kompatibel sind.
memset( &backup_info, 0, sizeof( a_backup_db ) );
backup_info.version = DB_TOOLS_VERSION_8_0_00;
backup_info.quiet = 0;
backup_info.no_confirm = 0;
backup_info.confirmrtn =
(MSG_CALLBACK)ConfirmCallBack;
backup_info.errorrtn = (MSG_CALLBACK)ErrorCallBack;
backup_info.msgrtn = (MSG_CALLBACK)MessageCallBack;
backup_info.statusrtn = (MSG_CALLBACK)StatusCallBack;
if( argc > 1 ) {
strncpy( dir_name, argv[1], _MAX_PATH );
} else {
// DBTools erwartet nicht den
// nachgestellten Schraegstrich
strcpy( dir_name, "c:\\temp" );
}
backup_info.output_dir = dir_name;
if( argc > 2 ) {
strncpy( connect, argv[2], 255 );
} else {
// Annahme: die Engine läuft bereits.
strcpy( connect, "DSN=ASA 8.0 Sample" );
}
backup_info.connectparms = connect;
backup_info.startline = "";
backup_info.quiet = 0;
backup_info.no_confirm = 0;
backup_info.backup_database = 1;
backup_info.backup_logfile = 1;
backup_info.backup_writefile = 1;
backup_info.rename_log = 0;
backup_info.truncate_log = 0;
hinst = LoadLibrary( "dbtool8.dll" );
if( hinst == NULL ) {
// Fehlgeschlagen
return 0;
}
321

DBTools-Schnittstelle verwenden
322
}
dbtinfo.errorrtn = (MSG_CALLBACK)ErrorCallBack;
dbbackup = GetProcAddress( (HMODULE)hinst,
"_DBBackup@4" );
dbtoolsinit = GetProcAddress( (HMODULE)hinst,
"_DBToolsInit@4" );
dbtoolsfini = GetProcAddress( (HMODULE)hinst,
"_DBToolsFini@4" );
(*dbtoolsinit)( &dbtinfo );
(*dbbackup)( &backup_info );
(*dbtoolsfini)( &dbtinfo );
FreeLibrary( hinst );
return 0;

DBTools-Funktionen
DBBackup-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
Kapitel 8 Die DBTools-Schnittstelle
Dieser Abschnitt beschreibt die Funktionen in der DBTools-Bibliothek. Die
Funktionen sind alphabetisch aufgelistet.
Datenbanksicherungs-Funktion. Diese Funktion wird von dem Befehlszeilen-
Dienstprogramm dbbackup benutzt.
short DBBackup ( const a_backup_db * Sicherungsdatenbank );
Parameter Beschreibung
Sicherungsdatenbank
Zeiger auf eine "a_backup_db-Struktur" auf Seite 335
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
Die Funktion DBBackup verwaltet alle Datenbanksicherungs-Aufgaben.
$ Die Beschreibung dieser Aufgaben finden Sie unter "Das
Sicherungsdienstprogramm" auf Seite 484 der Dokumentation ASA
Datenbankadministration.
"a_backup_db-Struktur" auf Seite 335
DBChangeLogName-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Ändert den Namen der Transaktionslogdatei. Diese Funktion wird von dem
Befehlszeilen-Dienstprogramm dblog benutzt.
short DBChangeLogName ( const a_change_log * Änderungslog );
Parameter Beschreibung
Änderungslog Zeiger auf eine "a_change_log-Struktur" auf Seite 337
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
Die Option -t des Dienstprogramms dblog ändert den Namen des
Transaktionslogs. DBChangeLogName liefert eine Programmierschnittstelle
zu dieser Funktion.
323

DBTools-Funktionen
Siehe auch
DBChangeWriteFile-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
DBCollate-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
324
$ Eine Beschreibung des Dienstprogramms dblog finden Sie unter "Das
Transaktionslog-Dienstprogramm" auf Seite 564 der Dokumentation ASA
Datenbankadministration.
"a_change_log-Struktur" auf Seite 337
Ändert eine Write-Datei, sodass sie auf eine andere Datenbankdatei zugreift.
Diese Funktion wird von dem Dienstprogramm dbwrite benutzt, wenn die
Option -d angewendet wird.
short DBChangeWriteFile ( const a_writefile * Write-Datei );
Parameter Beschreibung
Write-Datei Zeiger auf eine "a_writefile-Struktur" auf Seite 364
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Write-Datei-Dienstprogramm und seine
Eigenschaften finden Sie unter "Das Write-Datei-Dienstprogramm" auf
Seite 592 der Dokumentation ASA Datenbankadministration.
"DBCreateWriteFile-Funktion" auf Seite 326
"DBStatusWriteFile-Funktion" auf Seite 329
"a_writefile-Struktur" auf Seite 364
Extrahiert eine Kollatierungssequenz aus einer Datenbank.
short DBCollate ( const a_db_collation * DB-Kollatierung );
Parameter Beschreibung
DB-Kollatierung Zeiger auf eine "a_db_collation-Struktur" auf Seite 344
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Kollatierungs-Dienstprogramm und seine
Eigenschaften finden Sie unter "Das Kollatierungs-Dienstprogramm" auf
Seite 489 der Dokumentation ASA Datenbankadministration

Siehe auch
DBCompress-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
DBCreate-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
"a_db_collation-Struktur" auf Seite 344
Kapitel 8 Die DBTools-Schnittstelle
Komprimiert eine Datenbankdatei. Diese Funktion wird von dem
Dienstprogramm dbshrink benutzt.
short DBCompress ( const a_compress_db * Komprimierte_DB );
Parameter Beschreibung
Komprimierte_DB
Zeiger auf eine "a_compress_db-Struktur" auf Seite 339
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Komprimierungs-Dienstprogramm und seine
Eigenschaften finden Sie unter "Das Komprimierungs-Dienstprogramm" auf
Seite 495 der Dokumentation ASA Datenbankadministration.
"a_compress_db-Struktur" auf Seite 339
Erstellt eine Datenbank. Diese Funktion wird von dem Dienstprogramm
dbinit benutzt.
short DBCreate ( const a_create_db * Erstellte_DB );
Parameter Beschreibung
Erstellte_DB Zeiger auf eine "a_create_db-Struktur" auf Seite 341
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Initialisierungsdienstprogramm finden Sie unter
"Das Initialisierungs-Dienstprogramm" auf Seite 515 der Dokumentation
ASA Datenbankadministration.
"a_create_db-Struktur" auf Seite 341
325

DBTools-Funktionen
DBCreateWriteFile-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
DBCrypt-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
326
Erstellt eine Write-Datei. Diese Funktion wird von dem Dienstprogramm
dbwrite benutzt, wenn die Option -c angewendet wird.
short DBCreateWriteFile ( const a_writefile * Write-Datei );
Parameter Beschreibung
Write-Datei Zeiger auf eine "a_writefile-Struktur" auf Seite 364
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Write-Datei-Dienstprogramm und seine
Eigenschaften finden Sie unter "Das Write-Datei-Dienstprogramm" auf
Seite 592 der Dokumentation ASA Datenbankadministration.
"DBChangeWriteFile-Funktion" auf Seite 324
"DBStatusWriteFile-Funktion" auf Seite 329
"a_writefile-Struktur" auf Seite 364
Dient zum Verschlüsseln einer Datenbankdatei. Diese Funktion wird von
dem Dienstprogramm dbinit benutzt, wenn die Option -e angewendet wird.
short DBCrypt ( const a_crypt_db * Verschlüsselte_DB );
Parameter Beschreibung
Verschlüsselte_DB
Zeiger auf eine "a_crypt_db-Struktur" auf Seite 343
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Weitere Hinweise zum Verschlüsseln von Datenbanken finden Sie
unter "Datenbank mit dem Befehlszeilenprogramm ""dbinit"" erstellen" auf
Seite 516 der Dokumentation ASA Datenbankadministration.
"a_crypt_db-Struktur" auf Seite 343

DBErase-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
DBExpand-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
DBInfo-Funktion
Funktion
Kapitel 8 Die DBTools-Schnittstelle
Löscht eine Datenbankdatei und/oder ein Transaktionslog. Diese Funktion
wird von dem Dienstprogramm dberase benutzt.
short DBErase ( const an_erase_db * Zu_löschende_DB );
Parameter Beschreibung
Zu_löschende_DB
Zeiger auf eine "an_erase_db-Struktur" auf Seite 349
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Lösch-Dienstprogramm und seine
Eigenschaften finden Sie unter "Das Dienstprogramm zum Löschen der
Datenbank" auf Seite 508 der Dokumentation ASA Datenbankadministration.
"an_erase_db-Struktur" auf Seite 349
Dekomprimiert eine Datenbankdatei. Diese Funktion wird von dem
Dienstprogramm dbexpand benutzt.
short DBExpand ( const an_expand_db * Zu_expandierende_DB );
Parameter Beschreibung
Zu_expandierende_DB
Zeiger auf eine "an_expand_db-Struktur" auf Seite 350
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Dekomprimierungs-Dienstprogramm und seine
Eigenschaften finden Sie unter "Das Dekomprimierungs-Dienstprogramm"
auf Seite 569 der Dokumentation ASA Datenbankadministration.
"an_expand_db-Struktur" auf Seite 350
Gibt Informationen über eine Datenbankdatei zurück. Diese Funktion wird
von dem Dienstprogramm dbinfo benutzt.
327

DBTools-Funktionen
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
DBInfoDump-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
DBInfoFree-Funktion
Funktion
Prototyp
328
short DBInfo ( const a_db_info * DB-Info );
Parameter Beschreibung
DB-Info Zeiger auf eine "a_db_info-Struktur" auf Seite 345
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Informations-Dienstprogramm und seine
Eigenschaften finden Sie unter "Das Informations-Dienstprogramm" auf
Seite 513 der Dokumentation ASA Datenbankadministration.
"DBInfoDump-Funktion" auf Seite 328
"DBInfoFree-Funktion" auf Seite 328
"a_db_info-Struktur" auf Seite 345
Gibt Informationen über eine Datenbankdatei zurück. Diese Funktion wird
von dem Dienstprogramm dbinfo benutzt, wenn die Option -u angewendet
wird.
short DBInfoDump ( const a_db_info * DB-Info );
Parameter Beschreibung
DB-Info Zeiger auf eine "a_db_info-Struktur" auf Seite 345
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Informations-Dienstprogramm und seine
Eigenschaften finden Sie unter "Das Informations-Dienstprogramm" auf
Seite 513 der Dokumentation ASA Datenbankadministration.
"DBInfo-Funktion" auf Seite 327
"DBInfoFree-Funktion" auf Seite 328
"a_db_info-Struktur" auf Seite 345
Wird aufgerufen, um nach dem Aufruf der Funktion DBInfoDump
Ressourcen freizugeben.
short DBInfoFree ( const a_db_info * DB-Info );

Parameter
Rückgabewert
Anwendung
Siehe auch
DBLicense-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
DBStatusWriteFile-Funktion
Funktion
Prototyp
Parameter
Parameter Beschreibung
Kapitel 8 Die DBTools-Schnittstelle
DB-Info Zeiger auf eine "a_db_info-Struktur" auf Seite 345
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Informations-Dienstprogramm und seine
Eigenschaften finden Sie unter "Das Informations-Dienstprogramm" auf
Seite 513 der Dokumentation ASA Datenbankadministration.
"DBInfo-Funktion" auf Seite 327
"DBInfoDump-Funktion" auf Seite 328
"a_db_info-Struktur" auf Seite 345
Wird aufgerufen, um die Lizenzdaten des Datenbankservers zu ändern oder
mitzuteilen.
short DBLicense ( const a_db_lic_info * DB-Liz.-Info );
Parameter Beschreibung
DB-Liz.-Info Zeiger auf eine "a_dblic_info-Struktur" auf Seite 348
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Informations-Dienstprogramm und seine
Eigenschaften finden Sie unter "Das Informations-Dienstprogramm" auf
Seite 513 der Dokumentation ASA Datenbankadministration.
"a_dblic_info-Struktur" auf Seite 348
Ruft den Status einer Write-Datei ab. Diese Funktion wird von dem
Dienstprogramm dbwrite benutzt, wenn die Option -s angewendet wird.
short DBStatusWriteFile ( const a_writefile * Write-Datei );
Parameter Beschreibung
Write-Datei Zeiger auf eine "a_writefile-Struktur" auf Seite 364
329

DBTools-Funktionen
Rückgabewert
Anwendung
Siehe auch
DBSynchronizeLog-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
DBToolsFini-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
330
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Write-Datei-Dienstprogramm und seine
Eigenschaften finden Sie unter "Das Write-Datei-Dienstprogramm" auf
Seite 592 der Dokumentation ASA Datenbankadministration.
"DBChangeWriteFile-Funktion" auf Seite 324
"DBCreateWriteFile-Funktion" auf Seite 326
"a_writefile-Struktur" auf Seite 364
Synchronisiert eine Datenbank mit einem MobiLink Synchronisationsserver.
short DBSynchronizeLog( const a _sync_db * Synchronisierte_DB );
Parameter Beschreibung
Synchronisierte_DB
Zeiger auf eine "a_sync_db-Struktur" auf Seite 352
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Weitere Informationen über diese Features finden Sie unter
"Synchronisation einleiten" auf Seite 149 der Dokumentation MobiLink
Benutzerhandbuch.
Vermindert den Zähler und gibt Ressourcen frei, nachdem eine Anwendung
die DBTools-Bibliothek nicht mehr benötigt.
short DBToolsFini ( const a_dbtools_info * DBTools-Info );
Parameter Beschreibung
DBTools-Info Zeiger auf eine "a_dbtools_info-Struktur" auf Seite 349
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
Die Funktion DBToolsFini muss am Ende jeder Anwendung aufgerufen
werden, die die DBTools-Schnittstelle benutzt. Falls diese Funktion nicht
aufgerufen wird, kann das zum Verlust von Speicherressourcen führen.

Siehe auch
DBToolsInit-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Beispiel
Siehe auch
"DBToolsInit-Funktion" auf Seite 331
"a_dbtools_info-Struktur" auf Seite 349
Bereitet die DBTools-Bibliothek für die Benutzung vor.
Kapitel 8 Die DBTools-Schnittstelle
short DBToolsInit t( const a_dbtools_info * DBTools-Info );
Parameter Beschreibung
DBTools-Info Zeiger auf eine "a_dbtools_info-Struktur" auf Seite 349
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
Der hauptsächliche Zweck der Funktion DBToolsInit ist es, die Sprach-DLL
von Adaptive Server Anywhere zu laden. Die Sprach-DLL enthält lokale
Versionen der Fehlermeldungen und Bedieneraufforderungen, die DBTools
intern verwendet.
Die Funktion DBToolsInit muss zu Beginn jeder Anwendung aufgerufen
werden, die die DBTools-Schnittstelle benutzt, bevor irgend eine andere
DBTools-Funktion benutzt wird.
♦ Das folgende Code-Beispiel zeigt, wie man DBTools initialisiert und
ordnungsgemäß beendet:
a_dbtools_info info;
short ret;
memset( &info, 0, sizeof( a_dbtools_info) );
info.errorrtn = (MSG_CALLBACK)MakeProcInstance(
(FARPROC)MyErrorRtn, hInst );
// Initialisierung von DBTools
ret = DBToolsInit( &info );
if( ret != EXIT_OKAY ) {
// DLL-Initialisierung fehlgeschlagen
…
}
// einige DBTools-Routinen aufrufen. . .
…
// DBTools dll bereinigen
DBToolsFini( &info );
"DBToolsFini-Funktion" auf Seite 330
"a_dbtools_info-Struktur" auf Seite 349
331

DBTools-Funktionen
DBToolsVersion-Funktion
Funktion
Prototyp
Rückgabewert
Anwendung
Siehe auch
DBTranslateLog-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
DBTruncateLog-Funktion
Funktion
Prototyp
Parameter
332
Gibt die Versionsnummer der DBTools-Bibliothek zurück.
short DBToolsVersion ( void );
Eine Ganzzahl (short integer), die die Versionsnummer der DBTools-
Bibliothek angibt
Verwenden Sie die Funktion DBToolsVersion, um zu überprüfen, dass die
DBTools-Bibliothek nicht älter ist als diejenige, mit der Ihre Anwendung
entwickelt wurde. Anwendungen können mit neueren Versionen von
DBTools laufen, nicht aber mit älteren Versionen.
"Versionsnummern und Kompatibilität" auf Seite 318
Übersetzt eine Transaktionslogdatei in SQL. Diese Funktion wird von dem
Dienstprogramm dbtran benutzt.
short DBTranslateLog ( const a_translate_log * Zu_übersetzendes_Log );
Parameter Beschreibung
Zu_übersetzendes_Log
Zeiger auf eine "a_translate_log-Struktur" auf Seite 357
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Logkonvertierungs-Dienstprogramm finden Sie
unter "Das Logkonvertierungs-Dienstprogramm" auf Seite 543 der
Dokumentation ASA Datenbankadministration.
"a_translate_log-Struktur" auf Seite 357
Kürzt eine Transaktionslogdatei. Diese Funktion wird von dem
Dienstprogramm dbbackup benutzt.
short DBTruncateLog ( const a_truncate_log * Zu_kürzendes_Log );
Parameter Beschreibung
Zu_kürzendes_Log
Zeiger auf eine "a_truncate_log-Struktur" auf Seite 358

Rückgabewert
Anwendung
Siehe auch
DBUnload-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
DBUpgrade-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Kapitel 8 Die DBTools-Schnittstelle
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Sicherungsdienstprogramm finden Sie unter
"Das Sicherungsdienstprogramm" auf Seite 484 der Dokumentation ASA
Datenbankadministration
"a_truncate_log-Struktur" auf Seite 358
Entlädt eine Datenbank. Diese Funktion wird von dem Dienstprogramm
dbunload wie auch von dem Dienstprogramm dbxtract für SQL Remote
benutzt.
short DBUnload ( const an_unload_db * Zu_entladende_DB );
Parameter Beschreibung
Zu_entladende_DB
Zeiger auf eine "an_unload_db-Struktur" auf Seite 359
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Entladungs-Dienstprogramm finden Sie unter
"Das Dienstprogramm UNLOAD zum Entladen der Datenbank" auf
Seite 572 der Dokumentation ASA Datenbankadministration.
"an_unload_db-Struktur" auf Seite 359
Installiert ein Upgrade für eine Datenbankdatei. Diese Funktion wird von
dem Dienstprogramm dbupgrade benutzt.
short DBUpgrade ( const an_upgrade_db * DB_für_Upgrade );
Parameter Beschreibung
DB_für_Upgrade Zeiger auf eine "an_upgrade_db-Struktur" auf Seite 361
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
333

DBTools-Funktionen
Anwendung
Siehe auch
DBValidate-Funktion
Funktion
Prototyp
Parameter
Rückgabewert
Anwendung
Siehe auch
334
$ Informationen über das Upgrade-Dienstprogramm finden Sie unter
"Das Upgrade-Dienstprogramm" auf Seite 582 der Dokumentation ASA
Datenbankadministration.
"an_upgrade_db-Struktur" auf Seite 361
Validiert eine Datenbank oder Teile einer Datenbank. Diese Funktion wird
von dem Dienstprogramm dbvalid benutzt.
short DBValidate ( const a_validate_db * Zu_validierende_DB );
Parameter Beschreibung
Zu_validierende_DB
Zeiger auf eine "a_validate_db-Struktur" auf Seite 363
Ein Rückgabecode wie in "Rückgabecodes der Softwarekomponenten" auf
Seite 316 beschrieben.
$ Informationen über das Validierungs-Dienstprogramm finden Sie unter
"Das Validierungs-Dienstprogramm" auf Seite 588 der Dokumentation ASA
Datenbankadministration.
"a_validate_db-Struktur" auf Seite 363

DBTools-Strukturen
a_backup_db-Struktur
Funktion
Syntax
Kapitel 8 Die DBTools-Schnittstelle
In diesem Abschnitt sind die Strukturen aufgeführt, mit deren Hilfe
Informationen mit der DBTools-Bibliothek ausgetauscht werden. Die
Strukturen sind alphabetisch aufgeführt.
Viele der Strukturelemente entsprechen Befehlszeilenoptionen des
entsprechenden Dienstprogramms. Einige Strukturen zum Beispiel haben ein
Element namens "quiet", das mit den Werten 0 oder 1 belegt sein kann.
Dieses Element entspricht der Befehlszeilenoption (-q) des Vorgangs
"quiet", der von vielen Dienstprogrammen benutzt wird.
Enthält die Informationen, die gebraucht werden, um Sicherungsaufgaben
mit der DBTools-Bibliothek auszuführen.
typedef struct a_backup_db {
unsigned short version;
const char * output_dir;
const char * connectparms;
const char * startline;
MSG_CALLBACK confirmrtn;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
MSG_CALLBACK statusrtn;
a_bit_field backup_database: 1;
a_bit_field backup_logfile : 1;
a_bit_field backup_writefile : 1;
a_bit_field no_confirm : 1;
a_bit_field quiet : 1;
a_bit_field rename_log : 1;
a_bit_field truncate_log : 1;
a_bit_field rename_local_log: 1;
const char * hotlog_filename;
char backup_interrupted;
} a_backup_db;
335

DBTools-Strukturen
Parameter
Siehe auch
336
Mitglied Beschreibung
Version DBTools-Versionsnummer
output_dir Suchpfad des Ausgabeverzeichnisses. Zum Beispiel:
"c:\backup"
connectparms Parameter für die Verbindung zur Datenbank. Sie haben
die Form von Zeichenfolgen, zum Beispiel:
"UID=DBA;PWD=SQL;DBF=c:\asa\asademo.db"
$ Alle Zeichenfolgen für die Verbindung finden Sie
unter "Verbindungsparameter" auf Seite 78 der
Dokumentation ASA Datenbankadministration
startline Befehlszeile zum Starten der Datenbank-Engine. Das
folgende Beispiel zeigt eine Startzeile:
"c:\asa\win32\dbeng8.exe"
Die standardmäßige Startzeile wird benutzt, wenn dieses
Element NULL ist.
confirmrtn Callback-Routine für die Bestätigung einer Aktion
errorrtn Callback-Routine für die Behandlung einer Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
statusrtn Callback-Routine für die Behandlung einer Statusmeldung
backup_database Datenbankdatei sichern (1) oder nicht (0)
backup_logfile Transaktionslogdatei sichern (1) oder nicht (0)
backup_writefile Datenbank-Write-Datei sichern (1) oder nicht (0), falls
eine Datenbank-Write-Datei benutzt wird
no_confirm Mit (0) oder ohne (1) Bestätigung arbeiten
quiet Ohne die Ausgabe von Nachrichten arbeiten (1) oder
Nachrichten ausgeben (0)
rename_log Transaktionslog umbenennen
truncate_log Transaktionslog löschen
rename_local_log Lokale Sicherung des Transaktionslogs umbenennen
hotlog_filename Dateiname für die gerade benutzte Sicherungsdatei
backup_interrupted Gibt an, dass der Vorgang unterbrochen wurde
"DBBackup-Funktion" auf Seite 323
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.

a_change_log-Struktur
Funktion
Syntax
Parameter
Kapitel 8 Die DBTools-Schnittstelle
Enthält die Informationen, die gebraucht werden, um dblog-Aufgaben mit
der DBTools-Bibliothek auszuführen.
typedef struct a_change_log {
unsigned short version;
const char * dbname;
const char * logname;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
a_bit_field query_only : 1;
a_bit_field quiet : 1;
a_bit_field mirrorname_present : 1;
a_bit_field change_mirrorname : 1;
a_bit_field change_logname : 1;
a_bit_field ignore_ltm_trunc : 1;
a_bit_field ignore_remote_trunc : 1;
a_bit_field set_generation_number : 1;
a_bit_field ignore_dbsync_trunc : 1;
const char * mirrorname;
unsigned short generation_number;
const char * key_file;
char * zap_current_offset;
char * sap_starting_offset;
char * encryption_key;
} a_change_log;
Mitglied Beschreibung
version DBTools-Versionsnummer
dbname Datenbankdateiname
logname Name der Transaktionslogdatei. Wenn dieser Wert
gleich NULL gesetzt wird, gibt es kein Log
errorrtn Callback-Routine für die Behandlung einer
Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
query_only Name des Transaktionslogs anzeigen. 0: Änderung des
Lognamens erlauben
quiet Ohne die Ausgabe von Nachrichten arbeiten (1) oder
Nachrichten ausgeben (0)
mirrorname_present Auf 1 setzen; zeigt an, dass die DBTools-Version neu
genug ist, um das Feld mirrorname zu unterstützen
change_mirrorname Änderung des Namens der Logspiegeldatei erlauben
change_logname Änderung des Transaktionslognamens erlauben.
337

DBTools-Strukturen
Siehe auch
338
Mitglied Beschreibung
ignore_ltm_trunc Wird der Log Transfer Manager verwandt, wird die
gleiche Funktion wie mit Funktion dbcc settrunc( ’ltm’,
'gen_id', n ) des Replication Server ausgeführt:
$ Weitere Informationen finden Sie in der
Dokumentation zum Replication Server.
ignore_remote_trunc Für SQL Remote. Setzt den Ausgangspunkt für die
Option DELETE_OLD_LOGS zurück, der es erlaubt,
ein Transaktionslog zu löschen, wenn es nicht länger
gebraucht wird.
set_generation_number Wird - falls der Log Transfer Manager benutzt wird -
nach der Wiederherstellung einer Sicherung verwendet,
um die Generierungsnummer zu setzen.
ignore_dbsync_trunc Wenn dbmlsync verwendet wird, wird hiermit der
Ausgangspunkt für die Option DELETE_OLD_LOGS
zurückgesetzt, mit dem ein Transaktionslog gelöscht
werden kann, wenn es nicht mehr gebraucht wird.
mirrorname Der neue Name des Transaktionslogspiegels
generation_number Die neue Generationsnummer. Wird zusammen mit
set_generation_number benutzt.
key_file Eine Datei mit dem Chiffrierschlüssel
zap_current_offset Aktuellen Ausgangspunkt auf den angegebenen Wert
ändern. Dies ist nur für das Zurücksetzen eines
Transaktionslogs nach Entladen und Aktualisieren zur
Abstimmung mit den Einstellungen für dbremote oder
dbmlsync vorgesehen.
zap_starting_offset Ausgangspunkt auf den angegebenen Wert ändern.
Dies ist nur für das Zurücksetzen eines
Transaktionslogs nach Entladen und Aktualisieren zur
Abstimmung mit den Einstellungen für dbremote oder
dbmlsync vorgesehen.
encryption_key Der Chiffrierschlüssel für die Datenbankdatei.
"DBChangeLogName-Funktion" auf Seite 323
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.

a_compress_db-Struktur
Funktion
Syntax
Parameter
Kapitel 8 Die DBTools-Schnittstelle
Enthält die Informationen, die gebraucht werden, um
Datenbank-Komprimierungsaufgaben mit der DBTools-Bibliothek
auszuführen.
typedef struct a_compress_db {
unsigned short version;
const char * dbname;
const char * compress_name;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
MSG_CALLBACK statusrtn;
a_bit_field display_free_pages : 1;
a_bit_field quiet : 1;
a_bit_field record_unchanged : 1;
a_compress_stats * stats;
MSG_CALLBACK confirmrtn;
a_bit_field noconfirm : 1;
const char * encryption_key
} a_compress_db;
Mitglied Beschreibung
version DBTools-Versionsnummer
dbname Name der zu komprimierenden Datenbank
compress_name Dateiname der komprimierten Datenbank
errorrtn Callback-Routine für die Behandlung einer
Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
statusrtn Callback-Routine für die Behandlung einer
Statusmeldung
display_free_pages Informationen über freie Seiten anzeigen
quiet Ohne die Ausgabe von Nachrichten arbeiten (1) oder
Nachrichten ausgeben (0)
339

DBTools-Strukturen
Siehe auch
a_compress_stats-Struktur
Funktion
Syntax
Parameter
340
Mitglied Beschreibung
record_unchanged Auf 1 gesetzt. Zeigt an, dass die Struktur
a_compress_stats neu genug ist, um das Element
unchanged zu haben
a_compress_stats Zeiger auf eine Struktur vom Typ a_compress_stats. Wird
belegt, wenn das Element nicht NULL ist und wenn
display_free_pages nicht 0 (Null) ist
confirmrtn Callback-Routine für die Bestätigung einer Aktion
noconfirm Mit (0) oder ohne (1) Bestätigung arbeiten
encryption_key Der Chiffrierschlüssel für die Datenbankdatei.
"DBCompress-Funktion" auf Seite 325
"a_compress_stats-Struktur" auf Seite 340
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.
Enthält statistische Informationen über komprimierte Datenbankdateien.
typedef struct a_compress_stats {
a_stats_line tables;
a_stats_line indices;
a_stats_line other;
a_stats_line free;
a_stats_line total;
a_sql_int32 free_pages;
a_sql_int32 unchanged;
} a_compress_stats;
Mitglied Beschreibung
tables Enthält Information zur Komprimierung von Tabellen
Indices Enthält Information zur Komprimierung von Indizes
Other Enthält weitere Information zur Komprimierung
Free Enthält Informationen über freien Speicherplatz
Total Enthält allgemeine Information zur Komprimierung
free_pages Enthält Informationen über freie Seiten
Unchanged Anzahl der Seiten, die der Komprimierungsalgorithmus nicht
schrumpfen konnte

Siehe auch
a_create_db-Struktur
Funktion
Syntax
"DBCompress-Funktion" auf Seite 325
"a_compress_db-Struktur" auf Seite 339
Kapitel 8 Die DBTools-Schnittstelle
Enthält die Informationen, die gebraucht werden, um eine Datenbank mit der
DBTools-Bibliothek zu erstellen.
typedef struct a_create_db {
unsigned short version;
const char * dbname;
const char * logname;
const char * startline;
short page_size;
const char * default_collation;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
short database_version;
char verbose;
a_bit_field blank_pad : 2;
a_bit_field respect_case : 1;
a_bit_field encrypt : 1;
a_bit_field debug : 1;
a_bit_field dbo_avail : 1;
a_bit_field mirrorname_present : 1;
a_bit_field avoid_view_collisions : 1;
short collation_id;
const char * dbo_username;
const char * mirrorname;
const char * encryption_dllname;
a_bit_field java_classes : 1;
a_bit_field jconnect : 1;
const char * data_store_type
const char * encryption_key;
const char * encryption_algorithm;
const char * jdK_version;
} a_create_db;
341

DBTools-Strukturen
Parameter
342
Mitglied Beschreibung
version DBTools-Versionsnummer
dbname Datenbankdateiname
logname Neuer Transaktionslogname
startline Befehlszeile zum Starten der Datenbank-Engine. Das
folgende Beispiel zeigt eine Startzeile:
"c:\asa\win32\dbeng8.exe"
Die standardmäßige Startzeile wird benutzt, wenn dieses
Element NULL ist.
page_size Die Seitengröße der Datenbank
default_collation Die Kollatierung für die Datenbank
errorrtn Callback-Routine für die Behandlung einer
Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
database_version Die Versionsnummer der Datenbank
verbose Im ausführlichen Darstellungsmodus ausführen
blank_pad Leerzeichen in Zeichenfolgevergleichen beachten und
entsprechende Indexinformationen speichern
respect_case Groß/Kleinschreibung in Zeichenfolgevergleichen
beachten und entsprechende Indexinformationen
speichern
encrypt Datenbank verschlüsseln
debug Reserviert
dbo_avail Auf 1 gesetzt. Der Benutzer dbo ist in dieser Datenbank
verfügbar.
mirrorname_present Auf 1 setzen; zeigt an, dass die DBTools-Version neu
genug ist, um das Feld mirrorname zu unterstützen
avoid_view_collisions Die Erzeugung der Watcom SQL-Kompatibilitäts-
Ansichten SYS.SYSCOLUMNS und
SYS.SYSINDEXES vermeiden
collation_id Kollatierungsname (identifier)
dbo_username Nicht mehr benutzt: auf NULL gesetzt
mirrorname Name des Transaktionslogspiegels
encryption_dllname Die zum Verschlüsseln der Datenbank verwendete DLL.
java_classes Für Java aktivierte Datenbank erstellen

Siehe auch
a_crypt_db-Struktur
Funktion
Syntax
Parameter
Mitglied Beschreibung
Kapitel 8 Die DBTools-Schnittstelle
jconnect Für jConnect erforderliche Systemprozeduren
einbeziehen
data_store_type Reserviert NULL benutzen
encryption_key Der Chiffrierschlüssel für die Datenbankdatei.
encryption_algorithm AESoder MDSR eingeben.
jdk_version Einer der Werte für die Option dbinit -jdk.
"DBCreate-Funktion" auf Seite 325
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316 .
Enthält die Informationen, die zum Verschlüsseln einer Datenbankdatei
verwendet werden, die auch das dbinit-Dienstprogramm benutzt.
typedef struct a_crypt_db {
const char _fd_ * dbname;
const char _fd_ * dllname;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
MSG_CALLBACK statusrtn;
char verbose;
a_bit_field quiet : 1;
a_bit_field debug : 1;
} a_crypt_db;
Mitglied Beschreibung
dbname Datenbankdateiname
dllname Der Name der DLL, die für die Ausführung der
Verschlüsselung verwendet wird
errorrtn Callback-Routine für die Behandlung einer Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
statusrtn Callback-Routine für die Behandlung einer Statusmeldung
verbose Im ausführlichen Darstellungsmodus ausführen
quiet Ohne Nachrichten arbeiten
debug Reserviert
343

DBTools-Strukturen
Siehe auch
a_db_collation-Struktur
Funktion
Syntax
Parameter
344
"DBCrypt-Funktion" auf Seite 326
"Datenbank mit dem Befehlszeilenprogramm ""dbinit"" erstellen" auf
Seite 516 der Dokumentation ASA Datenbankadministration
Enthält die Informationen, die gebraucht werden, um mit der DBTools-
Bibliothek eine Kollatierungssequenz aus der Datenbank zu extrahieren.
typedef struct a_db_collation {
unsigned short version;
const char * connectparms;
const char * startline;
const char * collation_label;
const char * filename;
MSG_CALLBACK confirmrtn;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
a_bit_field include_empty : 1;
a_bit_field hex_for_extended : 1;
a_bit_field replace : 1;
a_bit_field quiet : 1;
const char * input_filename;
const char _fd_ * mapping_filename;
} a_db_collation;
Mitglied Beschreibung
version DBTools-Versionsnummer
connectparms Parameter für die Verbindung zur Datenbank. Sie haben
die Form von Zeichenfolgen, zum Beispiel:
"UID=DBA;PWD=SQL;DBF=c:\asa\asademo.db"
$ Alle Zeichenfolgen für die Verbindung finden Sie
unter "Verbindungsparameter" auf Seite 78 der
Dokumentation ASA Datenbankadministration
startline Befehlszeile zum Starten der Datenbank-Engine. Das
folgende Beispiel zeigt eine Startzeile:
"c:\asa\win32\dbeng8.exe"
Die standardmäßige Startzeile wird benutzt, wenn dieses
Element NULL ist.
confirmrtn Callback-Routine für die Bestätigung einer Aktion
errorrtn Callback-Routine für die Behandlung einer Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht

Siehe auch
a_db_info-Struktur
Funktion
Mitglied Beschreibung
include_empty Leere Zuordnungen für Lücken in der
Kollatierungssequenz schreiben
Kapitel 8 Die DBTools-Schnittstelle
hex_for_extended Zweiziffrige Hexadezimalzahlen benutzen, um high-value-
Zeichen zu repräsentieren
replace Ohne Bestätigungsaktionen arbeiten
quiet Ohne Nachrichten arbeiten
input_filename Kollatierungsdefinition eingeben
mapping_filename Ausgabe von syscollationmapping
"DBCollate-Funktion" auf Seite 324
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.
Enthält die Informationen, die gebraucht werden, um dbinfo-Informationen
mit der DBTools-Bibliothek zurückzugeben.
345

DBTools-Strukturen
Syntax
Parameter
346
typedef struct a_db_info {
unsigned short version;
MSG_CALLBACK errorrtn;
const char * dbname;
unsigned short dbbufsize;
char * dbnamebuffer;
unsigned short logbufsize;
char * lognamebuffer;
unsigned short wrtbufsize;
char * wrtnamebuffer;
a_bit_field quiet : 1;
a_bit_field mirrorname_present : 1;
a_sysinfo sysinfo;
unsigned long free_pages;
a_bit_field compressed : 1;
const char * connectparms;
const char * startline;
MSG_CALLBACK msgrtn;
MSG_CALLBACK statusrtn;
a_bit_field page_usage : 1;
a_table_info * totals;
unsigned long file_size;
unsigned long unused_pages;
unsigned long other_pages;
unsigned short mirrorbufsize;
char * mirrornamebuffer;
char * unused_field;
char * collationnamebuffer;
unsigned short collationnamebufsize;
char * classesversionbuffer;
unsigned short classesversionbufsize;
} a_db_info;
Mitglied Beschreibung
version DBTools-Versionsnummer
errortrn Callback-Routine für die Behandlung einer
Fehlermeldung
dbname Datenbankdateiname
dbbufsize Länge des Elements dbnamebuffer
dbnamebuffer Datenbankdateiname
logbufsize Länge des Elements lognamebuffer
lognamebuffer Transaktionslog-Dateiname
wrtbufsize Länge des Elements wrtnamebuffer
wrtnamebuffer Name der Write-Datei

Mitglied Beschreibung
Kapitel 8 Die DBTools-Schnittstelle
quiet Ohne Bestätigungsnachrichten arbeiten
mirrorname_present Auf 1 setzen; zeigt an, dass die DBTools-Version neu
genug ist, um das Feld mirrorname zu unterstützen
sysinfo Zeiger auf eine a_sysinfo-Struktur
free_pages Anzahl der freien Seiten
compressed 1 falls komprimiert, sonst 0
connectparms Parameter für die Verbindung zur Datenbank. Sie haben
die Form von Zeichenfolgen, zum Beispiel:
"UID=DBA;PWD=SQL;DBF=c:\Programme
\Sybase\SQL Anywhere 8\asademo.db"
$ Alle Zeichenfolgen für die Verbindung finden Sie
unter "Verbindungsparameter" auf Seite 78 der
Dokumentation ASA Datenbankadministration
startline Befehlszeile zum Starten der Datenbank-Engine. Das
folgende Beispiel zeigt eine Startzeile:
"c:\asa\win32\dbeng8.exe"
Die standardmäßige Startzeile wird benutzt, wenn dieses
Element NULL ist.
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
statusrtn Callback-Routine für die Behandlung einer
Statusmeldung
page_usage 1, um Auskunft zu geben über Seitennutzungs-Statistiken,
sonst 0
totals Zeiger auf eine a_table_info-Struktur
file_size Größe der Datenbankdatei
unused_pages Anzahl der nicht genutzten Seiten
other_pages Anzahl der Seiten, die weder Tabellen- noch Indexseiten
sind
mirrorbufsize Länge des Elements mirrornamebuffer
mirrornamebuffer Name des Transaktionslogspiegels
347

DBTools-Strukturen
Siehe auch
a_dblic_info-Struktur
Funktion
Syntax
Parameter
348
Mitglied Beschreibung
collationnamebuffer Name und Bezeichnung der Datenbankkollatierung
(Maximum ist 128+1)
collationnamebufsize Länge des Elements collationnamebuffer
key_file Eine Datei mit dem Chiffrierschlüssel
classesversionbuffer Die JDK-Version der installierten Java-Klassen, wie z.B.
1.1.3, 1.1.8, 1.3 oder eine leere Zeichenfolge, falls Java-
Klassen nicht in der Datenbank installiert sind (die
maximale Größe beträgt 10+1)
classesversionbufsize Länge des Elements classesversionbuffer
"DBInfo-Funktion" auf Seite 327
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.
Enthält Angaben zu den Lizenzdaten. Sie dürfen diese Informationen nur
gemäß Ihrem Lizenzvertrag benutzen.
typedef struct a_dblic_info {
unsigned short version;
char * exename;
char * username;
char * compname;
char * platform_str;
a_sql_int32 nodecount;
a_sql_int32 conncount;
a_license_type type;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
a_bit_field quiet : 1;
a_bit_field query_only : 1;
} a_dblic_info;
Mitglied Beschreibung
version DBTools-Versionsnummer
exename Name der ausführbaren Datei
username Benutzername für die Lizenz
compname Name des Unternehmens für die Lizenz
platform_str Betriebssystem: WinNT oder NLM oder UNIX
nodecount Anzahl der Knotenlizenzen.

a_dbtools_info-Struktur
Funktion
Syntax
Parameter
Siehe auch
an_erase_db-Struktur
Funktion
Mitglied Beschreibung
conncount Muss 1000000L sein
type Werte finden Sie unter lictype.h
Kapitel 8 Die DBTools-Schnittstelle
errorrtn Callback-Routine für die Behandlung einer Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
quiet Ohne die Ausgabe von Nachrichten arbeiten (1) oder
Nachrichten ausgeben (0)
query_only Wenn 1, nur die Lizenzinformationen anzeigen. Wenn 0,
Änderung der Informationen zulassen.
Enthält die Informationen, die gebraucht werden, um die Arbeit mit der
DBTools-Bibliothek zu beginnen und zu beenden.
typedef struct a_dbtools_info {
MSG_CALLBACK errorrtn;
} a_dbtools_info;
Mitglied Beschreibung
errorrtn Callback-Routine für die Behandlung einer Fehlermeldung
"DBToolsFini-Funktion" auf Seite 330
"DBToolsInit-Funktion" auf Seite 331
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.
Enthält die Informationen, die gebraucht werden, um eine Datenbank mit der
DBTools-Bibliothek zu löschen.
349

DBTools-Strukturen
Syntax
Parameter
Siehe auch
an_expand_db-Struktur
Funktion
350
typedef struct an_erase_db {
unsigned short version;
const char * dbname;
MSG_CALLBACK confirmrtn;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
a_bit_field quiet : 1;
a_bit_field erase : 1;
const char * encryption_key;
} an_erase_db;
Mitglied Beschreibung
version DBTools-Versionsnummer
dbname Name der zu löschenden Datenbankdatei
confirmrtn Callback-Routine für die Bestätigung einer Aktion
errorrtn Callback-Routine für die Behandlung einer Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
quiet Ohne die Ausgabe von Nachrichten arbeiten (1) oder
Nachrichten ausgeben (0)
erase Ohne Bestätigung löschen (1) oder mit Bestätigung (0)
encryption_key Der Chiffrierschlüssel für die Datenbankdatei.
"DBErase-Funktion" auf Seite 327
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.
Enthält Informationen, die für die Datenbankdekomprimierung mit der
DBTools-Bibliothek gebraucht werden.

Syntax
Parameter
Siehe auch
a_name-Struktur
Funktion
Kapitel 8 Die DBTools-Schnittstelle
typedef struct an_expand_db {
unsigned short version;
const char * compress_name;
const char * dbname;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
MSG_CALLBACK statusrtn;
a_bit_field quiet : 1;
MSG_CALLBACK confirmrtn;
a_bit_field noconfirm : 1;
const char * key_file;
const char * encryption_key;
} an_expand_db;
Mitglied Beschreibung
version DBTools-Versionsnummer
compress_name Name der komprimierten Datenbankdatei
dbname Datenbankdateiname
errorrtn Callback-Routine für die Behandlung einer Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
statusrtn Callback-Routine für die Behandlung einer Statusmeldung
quiet Ohne die Ausgabe von Nachrichten arbeiten (1) oder
Nachrichten ausgeben (0)
confirmrtn Callback-Routine für die Bestätigung einer Aktion
noconfirm Mit (0) oder ohne (1) Bestätigung arbeiten
key_file Eine Datei mit dem Chiffrierschlüssel
encryption_key Der Chiffrierschlüssel für die Datenbankdatei.
"DBExpand-Funktion" auf Seite 327
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.
Enthält eine verkettete Liste von Namen. Wird von anderen Strukturen
benutzt, die Namenslisten erfordern.
351

DBTools-Strukturen
Syntax
Parameter
Siehe auch
a_stats_line-Struktur
Funktion
Syntax
Parameter
Siehe auch
a_sync_db-Struktur
Funktion
352
typedef struct a_name {
struct a_name * next;
char name[1];
} a_name, * p_name;
Mitglied Beschreibung
next Zeiger auf eine next a_name-Struktur in der Liste
Name Der Name
p_name Zeiger auf die vorangehende a_name-Struktur
"a_translate_log-Struktur" auf Seite 357
"a_validate_db-Struktur" auf Seite 363
"an_unload_db-Struktur" auf Seite 359
Enthält Informationen, welche für die Komprimierung und
Dekomprimierung der Datenbank mit der DBTools-Bibliothek gebraucht
werden.
typedef struct a_stats_line {
long pages;
long bytes;
long compressed_bytes;
} a_stats_line;
Mitglied Beschreibung
Pages Anzahl der Seiten
Bytes Anzahl der Bytes für die nicht komprimierte Datenbank
Compressed_bytes Anzahl der Bytes für die komprimierte Datenbank
"a_compress_stats-Struktur" auf Seite 340
Enthält Informationen, die für den Gebrauch des Dienstprogramms dbmlsync
mit der DBTools-Bibliothek benötigt werden.

Syntax
typedef struct a_sync_db {
unsigned short version;
char _fd_ * connectparms;
char _fd_ * publication;
const char _fd_ * offline_dir;
char _fd_ * extended_options;
char _fd_ * script_full_path;
const char _fd_ * include_scan_range;
const char _fd_ * raw_file;
MSG_CALLBACK confirmrtn;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
MSG_CALLBACK logrtn;
Kapitel 8 Die DBTools-Schnittstelle
353

DBTools-Strukturen
354
a_SQL_uint32 debug_dump_size;
a_SQL_uint32 dl_insert_width;
a_bit_field verbose : 1;
a_bit_field debug : 1;
a_bit_field debug_dump_hex : 1;
a_bit_field debug_dump_char : 1;
a_bit_field debug_page_offsets : 1;
a_bit_field use_hex_offsets : 1;
a_bit_field use_relative_offsets : 1;
a_bit_field output_to_file : 1;
a_bit_field output_to_mobile_link : 1;
a_bit_field dl_use_put : 1;
a_bit_field dl_use_upsert : 1;
a_bit_field kill_other_connections : 1;
a_bit_field retry_remote_behind : 1;
a_bit_field ignore_debug_interrupt : 1;
SET_WINDOW_TITLE_CALLBACK set_window_title_rtn;
char * default_window_title;
MSG_QUEUE_CALLBACK msgqueuertn;
MSG_CALLBACK progress_msg_rtn;
SET_PROGRESS_CALLBACK progress_index_rtn;
char ** argv;
char ** ce_argv;
a_bit_field connectparms_allocated : 1;
a_bit_field entered_dialog : 1;
a_bit_field used_dialog_allocation : 1;
a_bit_field ignore_scheduling : 1;
a_bit_field ignore_hook_errors : 1;
a_bit_field changing_pwd : 1;
a_bit_field prompt_again : 1;
a_bit_field retry_remote_ahead : 1;
a_bit_field rename_log : 1;
a_bit_field hide_conn_str : 1;
a_bit_field hide_ml_pwd : 1;
a_bit_field delay_ml_disconn : 1;
a_SQL_uint32 dlg_launch_focus;
char _fd_ * mlpassword;
char _fd_ * new_mlpassword;
char _fd_ * verify_mlpassword;
a_SQL_uint32 pub_name_cnt;
char ** pub_name_list;
USAGE_CALLBACK usage_rtn;
a_sql_uint32 hovering_frequency;
a_bit_short ignore_hovering : 1;
a_bit_short verbose_upload : 1;
a_bit_short verbose_upload_data : 1;
a_bit_short verbose_download : 1;
a_bit_short verbose_download_data : 1;
a_bit_short autoclose : 1;
a_bit_short ping : 1;
a_bit_short _unused : 9;

Parameter
Siehe auch:
a_syncpub-Struktur
Funktion
Syntax
Parameter
char _fd_ * encryption_key;
a_syncpub _fd_ * upload_defs;
char _fd_ * log_file_name;
char _fd_ * user_name;
} a_sync_db;
Kapitel 8 Die DBTools-Schnittstelle
Die Parameter entsprechen Funktionen, die über das Dienstprogramm
dbmlsync zugänglich sind.
In der Header-Datei dbtools.h finden Sie weitere Kommentare.
$ Weitere Hinweise finden Sie unter "MobiLink-Synchronisationsclient"
auf Seite 440 der Dokumentation MobiLink Benutzerhandbuch.
"DBSynchronizeLog-Funktion" auf Seite 330
Enthält Informationen, die für das Dienstprogramm dbmlsync benötigt
werden.
typedef struct a_syncpub {
struct a_syncpub _fd_ * next;
char _fd_ * pub_name;
char _fd_ * ext_opt;
a_bit_field alloced_by_dbsync: 1;
} a_syncpub;
Mitglied Beschreibung
a_syncpub Zeiger auf den nächsten Knoten in der Liste, NULL für
den letzten Knoten
pub_name Für diesen –n-Parameter angegebene
Publikationsnamen. Dies ist die exakte Zeichenfolge
nach -n in der Befehlszeile.
ext_opt Erweiterte Optionen, die mit dem Parameter -eu
angegeben werden
encryption 1 falls die Datenbank verschlüsselt ist, 0 (Null) falls
nicht
alloced_by_dbsync FALSE, mit Ausnahme der von dbtool8.dll erstellten
Knoten
355

DBTools-Strukturen
a_sysinfo-Struktur
Funktion
Parameter
Siehe auch
a_table_info-Struktur
Funktion
Syntax
356
Enthält Informationen, die für den Gebrauch der Dienstprogramme dbinfo
und dbunload mit der DBTools-Bibliothek benötigt werden.
typedef struct a_sysinfo {
a_bit_field valid_data : 1;
a_bit_field blank_padding : 1;
a_bit_field case_sensitivity : 1;
a_bit_field encryption : 1;
char default_collation[11];
unsigned short page_size;
} a_sysinfo;
Mitglied Beschreibung
valid_date Bit-Feld, das angibt, ob die folgenden Werte gesetzt sind
blank_padding 1 falls Auffüllen mit Leerzeichen in der Datenbank benutzt
wird, 0 (Null) falls nicht
case_sensitivity 1 falls die Datenbank Groß/Kleinschreibung beachtet, 0 (Null)
falls nicht
encryption 1 falls die Datenbank verschlüsselt ist, 0 (Null) falls nicht
default_collation Die Kollatierungssequenz für die Datenbank
page_size Die Seitengröße für die Datenbank
"a_db_info-Struktur" auf Seite 345
Enthält Informationen über eine Tabelle, die als Teil der a_db_info-Struktur
gebraucht wird.
typedef struct a_table_info {
struct a_table_info * next;
unsigned short table_id;
unsigned long table_pages;
unsigned long index_pages;
unsigned long table_used;
unsigned long index_used;
char * table_name;
a_sql_uint32 table_used_pct;
a_sql_uint32 index_used_pct;
} a_table_info;

Parameter
Siehe auch
a_translate_log-Struktur
Funktion
Syntax
Mitglied Beschreibung
next Nächste Tabelle in der Liste
table_id ID-Nummer für diese Tabelle
table_pages Anzahl der Tabellenseiten
index_pages Anzahl der Indexseiten
Kapitel 8 Die DBTools-Schnittstelle
table_used Anzahl der in den Tabellenseiten benutzten Bytes
index_used Anzahl der in den Indexseiten benutzten Bytes
table_name Name der Tabelle
table_used_pct Verwendung des Tabellenbereichs als Prozentsatz
index_used_pct Verwendung des Indexbereichs als Prozentsatz
"a_db_info-Struktur" auf Seite 345
Enthält Informationen, die für die Konvertierung des Transaktionslogs mit
der DBTools-Bibliothek gebraucht werden.
typedef struct a_translate_log {
unsigned short version;
const char * logname;
const char * sqlname;
p_name userlist;
MSG_CALLBACK confirmrtn;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
char userlisttype;
a_bit_field remove_rollback : 1;
a_bit_field ansi_SQL : 1;
a_bit_field since_checkpoint: 1;
a_bit_field omit_comments : 1;
a_bit_field replace : 1;
a_bit_field debug : 1;
a_bit_field include_trigger_trans : 1;
a_bit_field comment_trigger_trans : 1;
unsigned long since_time;
const char _fd_ * reserved_1;
357

DBTools-Strukturen
Parameter
Siehe auch
a_truncate_log-Struktur
Funktion
358
const char _fd_ * reserved_2;
a_sql_uint32 debug_dump_size;
a_bit_field debug_sql_remote : 1;
a_bit_field debug_dump_hex : 1;
a_bit_field debug_dump_char : 1;
a_bit_field debug_page_offsets : 1;
a_bit_field reserved_3 : 1;
a_bit_field use_hex_offsets : 1;
a_bit_field use_relative_offsets : 1;
a_bit_field include_audit : 1;
a_bit_field chronological_order : 1;
a_bit_field force_recovery : 1;
a_bit_field include_subsets : 1;
a_bit_field force_chaining : 1;
a_sql_uint32 recovery_ops;
a_sql_uint32 recovery_bytes;
const char _fd_ * include_source_sets;
const char _fd_ * include_destination_sets;
const char _fd_ * include_scan_range;
const char _fd_ * repserver_users;
const char _fd_ * include_tables;
const char _fd_ * include_publications;
const char _fd_ * queueparms;
a_bit_field generate_reciprocals :1;
a_bit_field match_mode :1;
const char _fd_ * match_pos;
MSG_CALLBACK statusrtn;
const char _fd_ * encryption_key;
a_bit_field show_undo :1;
const char _fd_ * logs_dir;
} a_translate_log;
Die Parameter entsprechen Funktionen, die über das Dienstprogramm dbtran
zugänglich sind.
In der Header-Datei dbtools.h finden Sie weitere Kommentare.
"DBTranslateLog-Funktion" auf Seite 332
"a_name-Struktur" auf Seite 351
"dbtran_userlist_type-Aufzählungstyp" auf Seite 368
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.
Enthält Informationen, die für das Kürzen des Transaktionslogs mit der
DBTools-Bibliothek gebraucht werden.

Syntax
Parameter
Siehe auch
an_unload_db-Struktur
Funktion
typedef struct a_truncate_log {
unsigned short version;
const char * connectparms;
const char * startline;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
a_bit_field quiet : 1;
char truncate_interrupted;
} a_truncate_log;
Kapitel 8 Die DBTools-Schnittstelle
Mitglied Beschreibung
version DBTools-Versionsnummer
connectparms Parameter für die Verbindung zur Datenbank. Sie haben
die Form von Zeichenfolgen, zum Beispiel:
"UID=DBA;PWD=SQL;DBF=c:\asa\asademo.db"
$ Alle Zeichenfolgen für die Verbindung finden Sie
unter "Verbindungsparameter" auf Seite 78 der
Dokumentation ASA Datenbankadministration
startline Befehlszeile zum Starten der Datenbank-Engine. Das
folgende Beispiel zeigt eine Startzeile:
"c:\asa\win32\dbeng8.exe"
Die standardmäßige Startzeile wird benutzt, wenn dieses
Element NULL ist.
errorrtn Callback-Routine für die Behandlung einer Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
quiet Ohne die Ausgabe von Nachrichten arbeiten (1) oder
Nachrichten ausgeben (0)
truncate_interrupted Gibt an, dass der Vorgang unterbrochen wurde
"DBTruncateLog-Funktion" auf Seite 332
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.
Enthält die Informationen, die gebraucht werden, um eine Datenbank mit der
DBTools-Bibliothek zu entladen oder um eine entfernte Datenbank für SQL
Remote zu extrahieren. Die Felder, die vom SQL Remote-
Extraktionsdienstprogramm dbxtract benutzt werden, sind gekennzeichnet.
359

DBTools-Strukturen
Syntax
360
typedef struct an_unload_db {
unsigned short version;
const char * connectparms;
const char * startline;
const char * temp_dir;
const char * reload_filename;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
MSG_CALLBACK statusrtn;
MSG_CALLBACK confirmrtn;
char unload_type;
char verbose;
a_bit_field unordered : 1;
a_bit_field no_confirm : 1;
a_bit_field use_internal_unload : 1;
a_bit_field dbo_avail : 1;
a_bit_field extract : 1;
a_bit_field table_list_provided : 1;
a_bit_field exclude_tables : 1;
a_bit_field more_flag_bits_present : 1;
a_sysinfo sysinfo;
const char * remote_dir;
const char * dbo_username;
const char * subscriber_username;
const char * publisher_address_type;
const char * publisher_address;
unsigned short isolation_level;
a_bit_field start_subscriptions : 1;
a_bit_field exclude_foreign_keys : 1;
a_bit_field exclude_procedures : 1;
a_bit_field exclude_triggers : 1;
a_bit_field exclude_views : 1;
a_bit_field isolation_set : 1;
a_bit_field include_where_subscribe : 1;
a_bit_field debug : 1;
p_name table_list;
a_bit_short escape_char_present : 1;
a_bit_short view_iterations_present : 1;
unsigned short view_iterations;

Parameter
Siehe auch
an_upgrade_db-Struktur
Funktion
Kapitel 8 Die DBTools-Schnittstelle
char escape_char;
char _fd_ * reload_connectparms;
char _fd_ * reload_db_filename;
a_bit_field output_connections:1;
char unload_interrupted;
a_bit_field replace_db:1;
const char _fd_ * locale;
const char _fd_ * site_name;
const char _fd_ * template_name;
a_bit_field preserve_ids:1;
a_bit_field exclude_hooks:1;
char _fd_ * reload_db_logname;
const char _fd_ * encryption_key;
const char _fd_ * encryption_algorithm;
a_bit_field syntax_version_7:1;
a_bit_field remove_java:1;
} an_unload_db;
Die Parameter entsprechen Funktionen, die über die Dienstprogramme
dbunload und dbxtract und mlxtract zugänglich sind.
In der Header-Datei dbtools.h finden Sie weitere Kommentare.
"DBUnload-Funktion" auf Seite 333
"a_name-Struktur" auf Seite 351
"dbunload-Aufzählungstyp" auf Seite 368
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.
Enthält die Informationen, die gebraucht werden, um eine Datenbank mit der
DBTools-Bibliothek zu aktualisieren.
361

DBTools-Strukturen
Syntax
Parameter
362
typedef struct an_upgrade_db {
unsigned short version;
const char * connectparms;
const char * startline;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
MSG_CALLBACK statusrtn;
a_bit_field quiet : 1;
a_bit_field dbo_avail : 1;
const char * dbo_username;
a_bit_field java_classes : 1;
a_bit_field jconnect : 1;
a_bit_field remove_java : 1;
a_bit_field java_switch_specified : 1;
const char * jdk_version;
} an_upgrade_db;
Mitglied Beschreibung
version DBTools-Versionsnummer
connectparms Parameter für die Verbindung zur Datenbank. Sie haben die
Form von Zeichenfolgen, zum Beispiel:
"UID=DBA;PWD=SQL;DBF=c:\asa\asademo.db"
$ Alle Zeichenfolgen für die Verbindung finden Sie unter
"Verbindungsparameter" auf Seite 78 der Dokumentation ASA
Datenbankadministration
startline Befehlszeile zum Starten der Datenbank-Engine. Das folgende
Beispiel zeigt eine Startzeile:
"c:\asa\win32\dbeng8.exe"
Die standardmäßige Startzeile wird benutzt, wenn dieses
Element NULL ist.
errorrtn Callback-Routine für die Behandlung einer Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
statusrtn Callback-Routine für die Behandlung einer Statusmeldung
quiet Ohne die Ausgabe von Nachrichten arbeiten (1) oder
Nachrichten ausgeben (0)
dbo_avail Auf 1 gesetzt. Zeigt an, dass die DBTools-Version neu genug
ist, um das Feld dbo_mirrorname zu unterstützen

Siehe auch
a_validate_db-Struktur
Funktion
Syntax
Mitglied Beschreibung
dbo_username Der für den dbo zu benutzende Name
Kapitel 8 Die DBTools-Schnittstelle
java_classes Datenbank umstellen, sodass sie Java enthält
jconnect Datenbank umstellen, sodass sie jConnect-Prozeduren
akzeptiert
remove_java Datenbank umstellen, sodass die Java-Funktionen entfernt
werden
jdk_version Einer der Werte für die Option dbinit -jdk
"DBUpgrade-Funktion" auf Seite 333
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.
Enthält Informationen, die für Datenbankvalidierung mit der DBTools-
Bibliothek gebraucht werden.
typedef struct a_validate_db {
unsigned short version;
const char * connectparms;
const char * startline;
p_name tables;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
MSG_CALLBACK statusrtn;
a_bit_field quiet : 1;
a_bit_field index : 1;
a_validate_type type;
} a_validate_db;
363

DBTools-Strukturen
Parameter
Siehe auch
a_writefile-Struktur
Funktion
364
Mitglied Beschreibung
version DBTools-Versionsnummer
connectparms Parameter für die Verbindung zur Datenbank. Sie haben die
Form von Zeichenfolgen, zum Beispiel:
"UID=DBA;PWD=SQL;DBF=c:\asa\asademo.db"
$ Alle Zeichenfolgen für die Verbindung finden Sie unter
"Verbindungsparameter" auf Seite 78 der Dokumentation ASA
Datenbankadministration
startline Befehlszeile zum Starten der Datenbank-Engine. Das folgende
Beispiel zeigt eine Startzeile:
"c:\Programme\Sybase\SA\win32\dbeng8.exe"
Die standardmäßige Startzeile wird benutzt, wenn dieses Element
NULL ist.
tables Zeiger auf eine verknüpfte Liste mit Tabellennamen
errorrtn Callback-Routine für die Behandlung einer Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
statusrtn Callback-Routine für die Behandlung einer Statusmeldung
quiet Ohne die Ausgabe von Nachrichten arbeiten (1) oder
Nachrichten ausgeben (0)
index Indizes validieren
type Weitere Hinweise unter "a_validate_type-Aufzählungstyp" auf
Seite 369
"DBValidate-Funktion" auf Seite 334
"a_name-Struktur" auf Seite 351
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.
Enthält Informationen, die für die Verwaltung der Datenbank-Write-Datei
mit der DBTools-Bibliothek gebraucht werden.

Syntax
Parameter
Kapitel 8 Die DBTools-Schnittstelle
typedef struct a_writefile {
unsigned short version;
const char * writename;
const char * wlogname;
const char * dbname;
const char * forcename;
MSG_CALLBACK confirmrtn;
MSG_CALLBACK errorrtn;
MSG_CALLBACK msgrtn;
char action;
a_bit_field quiet : 1;
a_bit_field erase : 1;
a_bit_field force : 1;
a_bit_field mirrorname_present : 1;
const char * wlogmirrorname;
a_bit_field make_log_and_mirror_names: 1;
const char * encryption_key;
} a_writefile;
Mitglied Beschreibung
version DBTools-Versionsnummer
writename Name der Write-Datei
wlogname Wird nur für die Erstellung von Write-Dateien benutzt
dbname Wird zum Ändern und Erstellen von Write-Dateien
benutzt
forcename Erzwungene Referenz auf einen Dateinamen
confirmrtn Callback-Routine für die Bestätigung einer Aktion. Wird
nur für die Erstellung einer Write-Datei benutzt
errorrtn Callback-Routine für die Behandlung einer
Fehlermeldung
msgrtn Callback-Routine für die Behandlung einer
Informationsnachricht
action Reserviert für Sybase
quiet Ohne die Ausgabe von Nachrichten arbeiten (1) oder
Nachrichten ausgeben (0)
erase Wird nur für die Erstellung von Write-Dateien benutzt.
Ohne Bestätigung löschen (1) oder mit Bestätigung (0)
365

DBTools-Strukturen
Siehe auch
366
Mitglied Beschreibung
force Falls 1, Write-Datei zwingend auf die angegebene Datei
zeigen lassen
mirrorname_present Wird nur für die Erstellung von Write-Dateien benutzt.
Auf 1 setzen; zeigt an, dass die DBTools-Version neu
genug ist, um das Feld mirrorname zu unterstützen
wlogmirrorname Name des Transaktionslogspiegels
make_log_and_mirro
r_names
Wenn auf TRUE, verwenden Sie die Werte in wlogname
und wlogmirrorname benutzt zum Festlegen der
Dateinamen.
encryption_key Der Chiffrierschlüssel für die Datenbankdatei.
"DBChangeWriteFile-Funktion" auf Seite 324
"DBCreateWriteFile-Funktion" auf Seite 326
"DBStatusWriteFile-Funktion" auf Seite 329
$ Weitere Hinweise zu Callback-Funktionen finden Sie unter "Callback-
Funktionen verwenden" auf Seite 316.

DBTools-Aufzählungstypen
Verbosity (Ausführlichkeit)
Funktion
Syntax
Parameter
Siehe auch
Kapitel 8 Die DBTools-Schnittstelle
Dieser Abschnitt führt die Aufzählungstypen auf, die von der DBTools-
Bibliothek benutzt werden. Die Aufzählungstypen sind alphabetisch
aufgeführt.
Gibt die Ausführlichkeit der Ausgabe an.
enum {
VB_QUIET,
VB_NORMAL,
VB_VERBOSE
};
Auffüllen mit Leerzeichen
Funktion
Syntax
Parameter
Siehe auch
Wert Beschreibung
VB_QUIET Keine Ausgabe
VB_NORMAL Normale Ausgabemenge
VB_VERBOSE Ausgabe ausführlich darstellen, nützlich für die
Fehlersuche
"a_create_db-Struktur" auf Seite 341
"an_unload_db-Struktur" auf Seite 359
Wird in der Struktur "a_create_db" (siehe "a_create_db-Struktur" auf
Seite 341) benutzt, um den Wert von blank_pad anzugeben.
enum {
NO_BLANK_PADDING,
BLANK_PADDING
};
Wert Beschreibung
NO_BLANK_PADDING Benutzt kein Auffüllen mit Leerzeichen
BLANK_PADDING Benutzt Auffüllen mit Leerzeichen
"a_create_db-Struktur" auf Seite 341
367

DBTools-Aufzählungstypen
dbtran_userlist_type-Aufzählungstyp
Funktion
Syntax
Parameter
Siehe auch
dbunload-Aufzählungstyp
Funktion
Syntax
Parameter
Siehe auch
368
Typ einer Benutzerliste, wie er unter "a_translate_log-Struktur" auf Seite 357
beschrieben ist.
typedef enum dbtran_userlist_type {
DBTRAN_INCLUDE_ALL,
DBTRAN_INCLUDE_SOME,
DBTRAN_EXCLUDE_SOME
} dbtran_userlist_type;
Wert Beschreibung
DBTRAN_INCLUDE_ALL Alle Benutzervorgänge einschliessen
DBTRAN_INCLUDE_SOME Nur Vorgänge der in der Benutzerliste
aufgeführten Benutzer einschliessen
DBTRAN_EXCLUDE_SOME Vorgänge der in der Benutzerliste
aufgeführten Benutzer ausschliessen
"a_translate_log-Struktur" auf Seite 357
Der Entladungstyp, der von der Struktur "an_unload-db" (siehe
"an_unload_db-Struktur" auf Seite 359) benutzt wird.
enum {
UNLOAD_ALL,
UNLOAD_DATA_ONLY,
UNLOAD_NO_DATA
};
Wert Beschreibung
UNLOAD_ALL Sowohl Daten wie auch Schema entladen
UNLOAD_DATA_ONLY Daten entladen Schema nicht entladen.
UNLOAD_NO_DATA Nur Schema entladen
"an_unload_db-Struktur" auf Seite 359

a_validate_type-Aufzählungstyp
Funktion
Syntax
Parameter
Siehe auch
Kapitel 8 Die DBTools-Schnittstelle
Der ausgeführte Validierungstyp gemäß "a_validate_db-Struktur" auf
Seite 363.
typedef enum {
VALIDATE_NORMAL = 0,
VALIDATE_DATA,
VALIDATE_INDEX,
VALIDATE_EXPRESS,
VALIDATE_FULL
} a_validate_type;
Wert Beschreibung
VALIDATE_NORMAL Nur mit der Standardprüfung validieren
VALIDATE_DATA Zusätzlich zur Standardprüfung mit der Datenprüfung
validieren
VALIDATE_INDEX Zusätzlich zur Standardprüfung mit der Indexprüfung
validieren
VALIDATE_EXPRESS Zusätzlich zur Standard- und Datenprüfung mit der
Expressprüfung validieren
VALIDATE_FULL Zusätzlich zur Standardprüfung mit der Daten- und
Indexprüfung validieren
"Datenbank mit dem Befehlszeilenprogramm ""dbvalid"" validieren" auf
Seite 589 der Dokumentation ASA Datenbankadministration
"VALIDATE TABLE-Anweisung" auf Seite 632 der Dokumentation ASA
SQL-Referenzhandbuch
369

DBTools-Aufzählungstypen
370

KAPITEL 9
Die OLE DB- und ADO-
Programmierschnittstellen
Über dieses
Kapitel
Inhalt
In diesem Kapitel wird beschrieben, wie Sie die OLE DB-Schnittstelle zu
Adaptive Server Anywhere verwenden.
Viele Anwendungen, welche die OLE DB-Schnittstelle verwenden, tun dies
nicht direkt, sondern über das Microsoft ActiveX-Datenobjekt (ADO)-
Programmierungsmodell. In diesem Kapitel wird auch die ADO-
Programmierung mit Adaptive Server Anywhere beschrieben.
Thema Seite
Einführung zu OLE DB 372
ADO-Programmierung mit Adaptive Server Anywhere 374
Unterstützte OLE DB-Schnittstellen 382
371

Einführung zu OLE DB
Einführung zu OLE DB
Unterstützte Plattformen
372
OLE DB ist ein Datenzugriffsmodell von Microsoft. Es verwendet
Component Object Model (COM)-Schnittstellen und, anders als bei ODBC,
wird hier nicht vorausgesetzt, dass die Datenquelle einen SQL-
Abfrageprozessor verwendet.
Adaptive Server Anywhere enthält einen OLE DB-Provider namens
ASAProv. Dieser Provider steht für aktuelle Windows- sowie für
Windows CE-Plattformen zur Verfügung.
Sie können auf Adaptive Server Anywhere auch über den Microsoft OLE
DB Provider für ODBC (MSDASQL) zusammen mit dem ODBC-Treiber
von Adaptive Server Anywhere zugreifen.
Die Verwendung des OLE DB-Providers von Adaptive Server Anywhere
bietet mehrere Vorteile:
♦ Einige Funktionen, wie z.B. die Aktualisierung über einen Cursor, sind
bei Verwendung der OLE DB/ODBC Brücke nicht verfügbar.
♦ Wenn Sie Adaptive Server Anywhere OLE DB-Provider verwenden, ist
ODBC für Ihre Entwicklung nicht erforderlich.
♦ Mit MSDASQL können OLE DB-Clients mit jedem ODBC-Treiber
arbeiten, wobei jedoch nicht garantiert wird, dass Sie sämtliche
Funktionen jedes ODBC-Treibers nutzen können. Wenn Sie Adaptive
Server Anywhere-Provider verwenden, haben Sie Zugriff auf sämtliche
Adaptive Server Anywhere-Funktionen aus OLE DB-
Programmierumgebungen.
Der Adaptive Server Anywhere OLE DB-Provider wurde so entwickelt, dass
er mit OLE DB 2.5 und höher arbeitet. Für Windows CE und Nachfolger
wurde der OLE DB-Provider für ADOCE 3.0 und höher entwickelt.
ADOCE ist der Microsoft ADO für Windows CE SDK und bietet
Datenbankfunktionen für Anwendungen, die mit den Windows CE Toolkits
für Visual Basic 5.0 und Visual Basic 6.0 entwickelt wurden.
$ Eine Liste der unterstützten Plattformen finden Sie unter
"Betriebssystemversionen" auf Seite 150 der Dokumentation SQL Anywhere
Studio Erste Orientierung.

Verteilte Transaktionen
Kapitel 9 Die OLE DB- und ADO-Programmierschnittstellen
Der OLE DB-Treiber kann in einer Umgebung mit verteilten Transaktionen
als Ressourcen-Manager eingesetzt werden.
$ Weitere Hinweise finden Sie unter "Dreischichtige Datenverarbeitung
und verteilte Transaktionen" auf Seite 399.
373

ADO-Programmierung mit Adaptive Server Anywhere
ADO-Programmierung mit Adaptive Server
Anywhere
374
Bei ADO (ActiveX-Datenobjekte) handelt es sich um ein
Datenzugriffsmodell, das über eine Automationsschnittstelle zugänglich
wird, die es Clientanwendungen ermöglicht, die Methoden und
Eigenschaften von Objekten in Laufzeit zu erfassen, ohne das Objekt vorher
zu kennen. Mit Hilfe von Automation können Skriptsprachen wie Visual
Basic ein Standardmodell für Datenzugriffsobjekte verwenden. ADO
verwendet OLE DB, um den Datenzugriff bereitzustellen.
Wenn Sie den Adaptive Server Anywhere OLE DB-Provider verwenden,
haben Sie aus einer ADO-Programmierungsumgebung Zugriff auf sämtliche
Adaptive Server Anywhere-Funktionen.
In diesem Abschnitt wird beschrieben, wie grundlegende Aufgaben während
der Verwendung von ADO aus Visual Basic ausgeführt werden. Er stellt
keine vollständige Anleitung zur Programmierung mit ADO dar.
Codebeispiele aus diesem Abschnitt finden Sie in den folgenden Dateien:
Entwicklungs-Tool Beispiel
Microsoft Visual Basic
6.0
Samples\ASA\VBSampler\vbsampler.vbp
Microsoft eMbedded
Visual Basic 3.0
Samples\ASA\ADOCE\OLEDB_PocketPC.ebp
$ Weitere Hinweise zur Programmierung in ADO finden Sie im
Handbuch Ihres Entwicklungstools.
$ Detaillierte Erläuterungen zur Verwendung von ADO und Visual
Basic, um auf Daten in einer Adaptive Server Anywhere-Datenbank
zuzugreifen, finden Sie im Whitepaper "Accessing Data in Adaptive Server
Anywhere Using ADO and Visual Basic" unter
http://www.sybase.com/detail?id=1017429.
Eine Datenbank mit einem Verbindungsobjekt verbinden
In diesem Abschnitt wird eine einfache Visual Basic-Routine beschrieben,
die eine Verbindung zu einer Datenbank herstellt.

Beispielcode
Hinweise
Kapitel 9 Die OLE DB- und ADO-Programmierschnittstellen
Sie können diese Routine ausprobieren, indem Sie eine Befehlsschaltfläche
namens Command1 in einer Maske platzieren und die Routine in ihr Click-
Ereignis einfügen. Führen Sie das Programm aus und klicken Sie auf die
Schaltfläche, um eine Verbindung herzustellen und trennen Sie die
Verbindung dann.
Private Sub cmdTestConnection_Click()
’ Variable deklarieren
Dim myConn As New ADODB.Connection
Dim myCommand As New ADODB.Command
Dim cAffected As Long
On Error GoTo HandleError
’ Verbindung herstellen
myConn.Provider = "ASAProv"
myConn.ConnectionString = _
"Data Source=ASA 8.0 Sample"
myConn.Open
MsgBox "Verbindung erfolgreich"
myConn.Close
Exit Sub
HandleError:
MsgBox "Verbindung nicht erfolgreich"
Exit Sub
End Sub
Das Beispiel führt die folgenden Aufgaben aus:
♦ Es deklariert die Variablen, die in der Routine verwendet werden.
♦ Es stellt mit Hilfe des OLE DB-Providers von Adaptive Server
Anywhere eine Verbindung zur Beispieldatenbank her.
♦ Es verwendet ein Befehlsobjekt zur Ausführung einer einfachen
Anweisung, die eine Meldung im Fenster des Datenbankservers anzeigt.
♦ Es beendet die Verbindung.
Wenn der ASAProv-Provider installiert ist, registriert er sich selbst. Der
Registriervorgang umfasst auch die Registriereinträge in dem Abschnitt
COM der Registry, sodass ADO die Position der DLL ermitteln kann, wenn
der ASAProv-Provider aufgerufen wird. Wenn Sie den Speicherort Ihrer
DLL ändern, müssen Sie sie neu registrieren.
v So registrieren Sie den OLE DB-Provider:
1 Öffnen Sie eine Befehlszeile.
375

ADO-Programmierung mit Adaptive Server Anywhere
376
2 Wechseln Sie zu dem Verzeichnis, in dem der OLE DB-Provider
installiert ist.
3 Geben Sie den folgenden Befehl ein, um den Provider zu registrieren:
regsvr32 dboledb8.dll
$ Weitere Hinweise, wie Sie mit OLE DB eine Verbindung zu einer
Datenbank herstellen, finden Sie unter "Verbinden mit einer Datenbank über
OLE DB" auf Seite 75 der Dokumentation ASA Datenbankadministration.
Anweisungen mit dem Befehlsobjekt ausführen
Beispielcode
Hinweise
In diesem Abschnitt wird eine einfache Routine beschrieben, die eine
einfache SQL-Anweisung an die Datenbank sendet.
Sie können diese Routine ausprobieren, indem Sie eine Befehlsschaltfläche
namens Command2 in einer Maske platzieren und die Routine in ihr Click-
Ereignis einfügen. Führen Sie das Programm aus und klicken Sie auf die
Schaltfläche, um eine Verbindung herzustellen, eine Meldung im Fenster des
Datenbankservers anzuzeigen, und trennen Sie die Verbindung dann.
Private Sub cmdUpdate_Click()
’ Variable deklarieren
Dim myConn As New ADODB.Connection
Dim myCommand As New ADODB.Command
Dim cAffected As Long
’Verbindung herstellen
myConn.Provider = "ASAProv"
myConn.ConnectionString = _
"Data Source=ASA 8.0 Sample"
myConn.Open
'Befehl ausführen
myCommand.CommandText = _
"update customer set fname='Liz' where id=102"
Set myCommand.ActiveConnection = myConn
myCommand.Execute cAffected
MsgBox CStr(cAffected) +
" rows affected.", vbInformation
myConn.Close
End Sub
Nachdem eine Verbindung hergestellt wurde, erstellt der Beispielcode ein
Befehlsobjekt und stellt die Eigenschaft CommandText auf eine Update-
Anweisung und die Eigenschaft ActiveConnection auf die aktuelle
Verbindung ein. Dann führt er die Update-Anweisung aus und zeigt die
Anzahl der von der Aktualisierung betroffenen Zeilen in einem
Meldungsfeld an.

Kapitel 9 Die OLE DB- und ADO-Programmierschnittstellen
In diesem Beispiel wird die Aktualisierung an die Datenbank gesendet und
festgeschrieben, sobald sie ausgeführt wurde.
$ Weitere Hinweise zur Verwendung von Transaktionen in ADO finden
Sie unter "Transaktionen verwenden" auf Seite 381.
Sie können Aktualisierungen auch über einen Cursor ausführen.
$ Weitere Hinweise finden Sie unter "Daten mit einem Cursor
aktualisieren" auf Seite 379.
Datenbank mit dem Recordset-Objekt abfragen
Beispielcode
Das ADO-Recordset-Objekt stellt die Ergebnismenge einer Abfrage dar. Sie
können es benutzen, um Daten aus einer Datenbank anzuzeigen.
Sie können diese Routine ausprobieren, indem Sie eine Befehlsschaltfläche
mit dem Namen cmdQuery in ein Formular einfügen und die Routine in ihr
Click-Ereignis einfügen. Führen Sie das Programm aus und klicken Sie auf
die Schaltfläche, um eine Verbindung herzustellen, eine Meldung im Fenster
des Datenbankservers anzuzeigen, eine Abfrage auszuführen und die ersten
Zeilen in Meldungsfeldern anzuzeigen. Danach trennen Sie die Verbindung.
377

ADO-Programmierung mit Adaptive Server Anywhere
Hinweise
378
Private Sub cmdQuery_Click()
’ Variable deklarieren
Dim myConn As New ADODB.Connection
Dim myCommand As New ADODB.Command
Dim myRS As New ADODB.Recordset
On Error GoTo ErrorHandler:
’ Verbindung herstellen
myConn.Provider = "ASAProv"
myConn.ConnectionString = _
"Data Source=ASA 8.0 Sample"
myConn.CursorLocation = adUseServer
myConn.Mode = adModeReadWrite
myConn.IsolationLevel = adXactCursorStability
myConn.Open
'Eine Abfrage ausführen
Set myRS = New Recordset
myRS.CacheSize = 50
myRS.Source = "Select * from customer"
myRS.ActiveConnection = myConn
myRS.CursorType = adOpenKeyset
myRS.LockType = adLockOptimistic
myRS.Open
'Durch die ersten Ergebnisse blättern
myRS.MoveFirst
For i = 1 To 5
MsgBox myRS.Fields("company_name"), vbInformation
myRS.MoveNext
Next
myRS.Close
myConn.Close
Exit Sub
ErrorHandler:
MsgBox Error(Err)
Exit Sub
End Sub
Das Recordset-Objekt in diesem Beispiel enthält die Ergebnisse aus einer
Abfrage der Tabelle Kunden. Die Schleife For blättert durch die ersten
Zeilen und zeigt den Wert company_name für jede Zeile an.
Hierbei handelt es sich um ein einfaches Beispiel für die Verwendung eines
Cursors aus ADO.
$ Weiterführende Beispiele für die Verwendung eines Cursors aus ADO
finden Sie unter "Mit dem Recordset-Objekt arbeiten" auf Seite 379.

Mit dem Recordset-Objekt arbeiten
Cursortypen
Beispielcode
Kapitel 9 Die OLE DB- und ADO-Programmierschnittstellen
Bei der Arbeit mit Adaptive Server Anywhere stellt die ADO Recordset
einen Cursor dar. Sie können den Cursortyp auswählen, indem Sie eine
CursorType-Eigenschaft des Recordset-Objekts deklarieren, bevor Sie das
Recordset öffnen. Die Auswahl des Cursortyps beeinflusst die Aktionen, die
Sie am Recordset vornehmen können und hat Auswirkungen auf die
Performance.
Die von Adaptive Server Anywhere unterstützten Cursortypen werden in
"Cursoreigenschaften" auf Seite 26 beschrieben. ADO hat seine eigene
Namenskonvention für Cursortypen.
Die verfügbaren Cursortypen, die entsprechenden Cursortypenkonstanten
und die Adaptive Server Anywhere-Typen, denen sie entsprechen, sind hier
aufgelistet:
ADO-Cursortyp ADO-Konstante Adaptive Server
Anywhere-Typ
Dynamischer
Cursor
Schlüsselgruppen-
Cursor
adOpenDynamic Dynamisch abrollender
Cursor
adOpenKeyset Abrollender Cursor
Statischer Cursor adOpenStatic Unempfindlicher Cursor
Vorwärts-Cursor adOpenForwardOnly Nicht-abrollender Cursor
$ Weitere Hinweise zur Auswahl eines für Ihre Anwendung geeigneten
Cursortyps finden Sie unter "Cursortypen auswählen" auf Seite 26.
Der folgende Code legt den Cursortyp für ein ADO Recordset-Objekt fest:
Dim myRS As New ADODB.Recordset
myRS.CursorType = adOpenDynamic
Daten mit einem Cursor aktualisieren
Recordsets
aktualisieren
Mit dem Adaptive Server Anywhere OLE DB-Provider können Sie eine
Ergebnismenge über einen Cursor aktualisieren. Diese Funktion ist über den
MSDASQL-Provider nicht verfügbar.
Sie können die Datenbank über einen Recordset aktualisieren.
Private Sub Command6_Click()
Dim myConn As New ADODB.Connection
Dim myRS As New ADODB.Recordset
Dim SQLString As String
379

ADO-Programmierung mit Adaptive Server Anywhere
Hinweise
380
’ Verbindung herstellen
myConn.Provider = "ASAProv"
myConn.ConnectionString = _
"Data Source=ASA 8.0 Sample"
myConn.Open
myConn.BeginTrans
SQLString = "Select * from customer"
myRS.Open SQLString, _
myConn, adOpenDynamic, adLockBatchOptimistic
If myRS.BOF And myRS.EOF Then
MsgBox "Recordset ist leer!", _
16, "Leeres Recordset"
Else
MsgBox "Cursor-Typ: " + _
CStr(myRS.CursorType), vbInformation
myRS.MoveFirst
For i = 1 To 3
MsgBox "Zeile: " + CStr(myRS.Fields("id")), _
vbInformation
If i = 2 Then
myRS.Update "City", "Toronto"
myRS.UpdateBatch
End If
myRS.MoveNext
Next i
’ myRS.MovePrevious
myRS.Close
End If
myConn.CommitTrans
myConn.Close
End Sub
Wenn Sie die Einstellung adLockBatchOptimistic für das Recordset
verwenden, werden bei der myRS.Update-Methode keine Änderungen an
der Datenbank selbst vorgenommen. Statt dessen wird eine lokale Kopie des
Recordsets aktualisiert.
Die myRS.UpdateBatch-Methode nimmt die Aktualisierung am
Datenbankserver vor, schreibt sie jedoch nicht fest, da sie sich innerhalb
einer Transaktion befindet. Wenn eine UpdateBatch-Methode von
außerhalb einer Transaktion aufgerufen wurde, werden die Änderungen
festgeschrieben.
Die Methode myConn.CommitTrans schreibt die Änderungen fest. Das
Recordset-Objekt wurde zwischenzeitlich geschlossen, sodass das Problem,
ob die lokale Kopie der Daten geändert wurde oder nicht, nicht mehr besteht.

Transaktionen verwenden
Kapitel 9 Die OLE DB- und ADO-Programmierschnittstellen
Standardmäßig werden sämtliche Änderungen, die Sie mit ADO an der
Datenbank vornehmen, festgeschrieben, sobald sie ausgeführt werden.
Hierzu gehören auch explizite Aktualisierungen und die UpdateBatch-
Methode für einen Recordset. Im vorherigen Abschnitt wurde jedoch
gezeigt, dass Sie die Methoden BeginTrans und RollbackTrans oder
CommitTrans auf das Connection-Objekt anwenden können, um
Transaktionen zu benutzen.
Die Transaktions-Isolationsstufe wird als eine Eigenschaft des
Verbindungsobjekts festgelegt. Die Eigenschaft IsolationLevel kann einen
der folgenden Werte annehmen:
ADO-Isolationsstufe Konstante ASA-Stufe
Unbekannt (Unspecified) adXactUnspecified Nicht anwendbar. Auf 0
setzen
Chaos adXactChaos Nicht unterstützt. Auf 0
setzen
Durchsuchen (Browse) adXactBrowse 0
Nicht festgeschriebene
Lesevorgänge (Read
uncommitted)
Cursorstabilität (Cursor
stability)
Festgeschriebene
Lesevorgänge (Read
committed)
Wiederholbare
Lesevorgänge (reatable
read)
adXactReadUncommitted 0
adXactCursorStability 1
adXactReadCommitted 1
adXactRepeatableRead 2
Isoliert (Isolated) adXactIsolated 3
Serialisierbar
(Serializable)
adXactSerializable 3
$ Weitere Hinweise zu Isolationsstufen finden Sie unter "Isolationsstufen
und Konsistenz" auf Seite 105 der Dokumentation ASA SQL-
Benutzerhandbuch.
381

Unterstützte OLE DB-Schnittstellen
Unterstützte OLE DB-Schnittstellen
382
Die OLE DB API besteht aus einer Reihe von Schnittstellen. In der
folgenden Tabelle wird die Unterstützung für jede Schnittstelle im OLE DB-
Treiber von Adaptive Server Anywhere beschrieben.
Schnittstelle Verwendung Einschränkungen
IAccessor Bindungen zwischen
Clientspeicher- und
Datenspeicherwerten
definieren
IAlterIndex
IAlterTable
Tabellen, Indizes und
Spalten ändern
IChapteredRowset Mit einer segmentierten
Zeilengruppe kann auf
Zeilen einer Zeilengruppe
in getrennten Kapiteln
zugegriffen werden
IColumnsInfo Einfache Informationen zu
Spalten in einer Zeilengruppe
erhalten
IColumnsRowset Informationen zu
optionalen
Metadatenspalten in einer
Zeilengruppe und eine
Zeilengruppe von Spalten-
Metadaten erhalten
DBACCESSOR_PA
SSBYREF nicht
unterstützt
DBACCESSOR_OP
TIMIZED nicht
unterstützt
Nicht unterstützt
Nicht unterstützt
Adaptive Server
Anywhere untersützt
segmentierte
Zeilengruppen nicht.
Nicht für CE
Nicht für CE
ICommand SQL-Befehle ausführen Unterstützt keinen
Aufruf
ICommandPropertie
s
GetProperties mit
DBPROPSET_PRO
PERTIESINERROR
um Eigenschaften zu
finden, die nicht
gesetzt werden
konnten.

Kapitel 9 Die OLE DB- und ADO-Programmierschnittstellen
Schnittstelle Verwendung Einschränkungen
ICommandPersist Zustand eines
Befehlsobjekts (jedoch
nicht jede aktive Zeilengruppe)
aufrechterhalten.
Diese beständigen
Befehlsobjekte können
nachfolgend mit der
Zeilengruppe
PROCEDURES oder
VIEWS nummeriert
werden.
Nicht für CE
ICommandPrepare Befehle vorbereiten. Nicht für CE
ICommandProperties Zeilengruppeneigenschaften
für von einem Befehl
erstellte Zeilengruppen
festlegen. Häufig
verwendet, um die
Schnittstellen anzugeben,
welche die Zeilengruppe
unterstützen sollen
ICommandText SQL-Befehlstext für
Icommand festlegen
IcommandWithParameters Parameterinformationen für
einen Befehl festlegen und
beziehen
Unterstützt
Nur der SQL-
Dialekt
DBGUID_DEFAUL
T wird unterstützt
Nicht für Parameter
unterstützt, die als
Vektoren skalarer
Werte gespeichert
werden
Keine Unterstützung
für BLOB-
Parameter
Nicht für CE
IConvertType Unterstützt
Für CE
eingeschränkte
Unterstützung
383

Unterstützte OLE DB-Schnittstellen
384
Schnittstelle Verwendung Einschränkungen
IDBAsynchNotify
IDBAsyncStatus
Asynchrone Verarbeitung
Client über Ereignisse in
der asynchronen
Verarbeitung bei der
Initialisierung von
Datenquellen, dem
Anfüllen von Zeilengruppen,
usw. informieren
IDBCreateCommand Befehle aus einer Sitzung
erstellen
IDBCreateSession Eine Sitzung aus einem
Datenquellenobjekt
erstellen.
IDBDataSourceAdmin Datenquellenobjekte, bei
denen es sich um COM-
Objekte handelt, die von
Clients unterstützt werden,
erstellen/zerstören/ändern.
Diese Schnittstelle wird
nicht für die Verwaltung
von Datenspeichern
(Datenbanken) verwendet.
IDBInfo Informationen über
Schlüsselwörter suchen, die
für diesen Provider
eindeutig sind (d.h.
Schlüsselwörter die nicht
dem Standard-SQL
entsprechen)
Außerdem Informationen
zu Literalen, d.h. Sonderzeichen,
die in textlich
übereinstimmenden
Abfragen verwendet
werden, und andere Literal-
Informationen suchen
IDBInitialize Datenquellenobjekte und
Aufzähler initialisieren.
IDBProperties Eigenschaften für ein
Datenquellenobjekt oder
einen Aufzähler verwalten
Nicht unterstützt
Unterstützt
Unterstützt
Nicht unterstützt
Nicht für CE
Nicht für CE
Nicht für CE

Kapitel 9 Die OLE DB- und ADO-Programmierschnittstellen
Schnittstelle Verwendung Einschränkungen
IDBSchemaRowset Informationen zu
Systemtabellen in einer
Standardmaske (einer
Zeilengruppe) beziehen.
IErrorInfo
IErrorLookup
IErrorRecords
Unterstützung von
ActiveX-Fehler-Objekten
IGetDataSource Gibt einen Schnittstellenzeiger
auf das Datenquellenobjekt
einer Sitzung
zurück
IIndexDefinition Indizes im Datenspeicher
erstellen oder löschen
IMultipleResults Mehrere Ergebnisse
(Zeilengruppen oder
Zeilenzählungen) aus einem
Befehl abrufen
IOpenRowset Auf eine Datenbanktabelle
mit ihrem Namen, nicht mit
SQL zugreifen
IParentRowset Auf
segmentierte/hierarchische
Zeilengruppen zugreifen
IRowset Auf Zeilengruppen
zugreifen
IRowsetChange Änderungen an Zeilengruppendaten
zulassen, die
im Datenspeicher reflektiert
werden
InsertRow/SetData für
Blobs nocht nicht
implementiert
IRowsetChapterMember Auf
segmentierte/hierarchische
Zeilengruppen zugreifen
IRowsetCurrentIndex Index für eine Zeilengruppe
dynamisch ändern
Nicht für CE
Nicht für CE
Unterstützt
Nicht unterstützt
Unterstützt
Unterstützt
Öffnen einer Tabelle
mit ihrem Namen,
nicht über einen
GUID, wird
unterstützt
Nicht unterstützt
Unterstützt
Nicht für CE
Nicht unterstützt
Nicht unterstützt
385

Unterstützte OLE DB-Schnittstellen
386
Schnittstelle Verwendung Einschränkungen
IRowsetFind Eine Zeile innerhalb einer
Zeilengruppe, die mit einem
spezifischen Wert übereinstimmt,
finden
Nicht unterstützt
IRowsetIdentity Zeilen-Handles vergleichen Nicht unterstützt
IRowsetIndex Auf Datenbankindizes
zugreifen
IRowsetInfo Informationen zu einer
Zeilengruppeneigenschaft
suchen oder das Objekt
suchen, das die Zeilengruppe
erstellt hat
IRowsetLocate Position in Zeilen einer
Zeilengruppe, unter
Verwendung von
Bookmarks
IRowsetNotify Bietet eine COM-Callback-
Schnittstelle für Zeilengruppen-Ereignisse
IRowsetRefresh Den neuesten Wert für
Daten beziehen, der für eine
Transaktion sichtbar ist
IRowsetResynch Alte OLEDB 1.x-
Schnittstelle, von
IRowsetRefresh abgelöst
IRowsetScroll Durch Zeilengruppe
blättern, um Zeilendaten
abzurufen
IRowsetUpdate Änderungen an
Zeilengruppendaten
verzögern, bis Update
aufgerufen wurde
IRowsetView Ansichten für eine
vorhandene Zeilengruppe
verwenden
Nicht unterstützt
Nicht für CE
Nicht für CE
Unterstützt
Nicht unterstützt
Nicht unterstützt
Nicht unterstützt
Unterstützt
Nicht für CE
Nicht unterstützt
ISequentialStream Eine Blob-Spalte abrufen Nur für Lesen
unterstützt
Keine Unterstützung
von SetData mit
dieser Schnittstelle
Nicht für CE

Kapitel 9 Die OLE DB- und ADO-Programmierschnittstellen
Schnittstelle Verwendung Einschränkungen
ISessionProperties Informationen zu
Sitzungseigenschaften
beziehen
ISourcesRowset Eine Zeilengruppe von
Datenquellenobjekten und
Aufzählern beziehen
ISQLErrorInfo
ISupportErrorInfo
ITableDefinition
ItableDefinitionWithConstraints
Unterstützung von
ActiveX-Fehler-Objekten
Tabellen mit
Integritätsregeln erstellen,
löschen und ändern
ITransaction Transaktionen festschreiben
oder abbrechen
ITransactionJoin Verteilte Transaktionen
werden unterstützt
ITransactionLocal Transaktionen für eine
Sitzung werden abgewickelt
Nicht alle Kennzeichnungen
werden
unterstützt
Unterstützt
Nicht für CE
Optional für CE
Nicht für CE
Nicht alle
Kennzeichnungen
werden unterstützt
Nicht für CE
Nicht alle
Kennzeichnungen
werden unterstützt
Nicht für CE
Nicht für CE
387

Unterstützte OLE DB-Schnittstellen
388
Schnittstelle Verwendung Einschränkungen
ITransactionOptions Optionen für eine
Transaktion beziehen oder
einstellen
IviewChapter Mit Ansichten für eine
vorhandene Zeilengruppe
arbeiten, insbesondere um
Nachbearbeitungsfilter/sortierungen
auf Zeilen
anzuwenden
IviewFilter Inhalte einer Zeilengruppe
werden auf Zeilen, welche
eine Reihe von Bedinungen
erfüllen, beschränkt
IviewRowset Inhalte einer Zeilengruppe
werden beim Öffnen einer
Zeilengruppe auf Zeilen,
welche eine Reihe von
Bedinungen erfüllen,
beschränkt
IviewSort Sortierreihenfolge auf eine
Ansicht anwenden
Nicht für CE
Nicht unterstützt
Nicht unterstützt
Nicht unterstützt
Nicht unterstützt.

KAPITEL 10
Die Open Client-Schnittstelle
Über dieses
Kapitel
Inhalt
Dieses Kapitel beschreibt die Open Client-Programmierschnittstelle für
Adaptive Server Anywhere.
Die primäre Quelle für Informationen zur Open Client-
Anwendungsentwicklung ist die Sybase Open Client-Dokumentation. Dieses
Kapitel beschreibt spezifische Funktionen für Adaptive Server Anywhere; es
ist jedoch keine umfassende Anleitung für die Anwendungsentwicklung mit
Open Client.
Thema Seite
Was Sie für die Entwicklung von Open Client-Anwendungen
brauchen 390
Datentyp-Zuordnungen 391
SQL in Open Client-Anwendungen verwenden
Bekannte Open Client-Einschränkungen von Adaptive Server
394
Anywhere 398
389

Was Sie für die Entwicklung von Open Client-Anwendungen brauchen
Was Sie für die Entwicklung von Open Client-
Anwendungen brauchen
390
Um Open Client-Anwendungen auszuführen, müssen Sie Open Client-
Komponenten auf dem Rechner installieren und konfigurieren, auf dem die
Anwendung laufen soll. Diese Komponenten sind eventuell bereits als Teil
Ihrer Installation anderer Sybase Produkte vorhanden; andernfalls können
Sie diese Bibliotheken wahlweise mit Adaptive Server Anywhere
entsprechend den Bedingungen Ihres Lizenzvertrags installieren.
Open Client-Anwendungen benötigen keine Open Client-Komponenten auf
dem Rechner, auf dem der Datenbankserver läuft.
Um Open Client-Anwendungen zu erstellen, benötigen Sie die
Entwicklungsversion von Open Client. Diese ist bei Sybase erhältlich.
Standardmäßig werden Adaptive Server Anywhere-Datenbanken ohne
Berücksichtigung von Groß-/Kleinschreibung erstellt, während Adaptive
Server Enterprise-Datenbanken unter Berücksichtigung von Groß-
/Kleinschreibung erstellt werden.
$ Weitere Hinweise zur Ausführung von Open Client-Anwendungen mit
Adaptive Server Anywhere finden Sie unter "Adaptive Server Anywhere als
Open Server" auf Seite 117 der Dokumentation ASA
Datenbankadministration.

Datentyp-Zuordnungen
Adaptive Server
Anywhere-
Datentypen ohne
direkte
Entsprechung in
Open Client
Kapitel 10 Die Open Client-Schnittstelle
Open Client hat seine eigenen internen Datentypen, die in einigen Details
von den Datentypen abweichen, die in Adaptive Server Anywhere zur
Verfügung stehen. Aus diesem Grunde ordnet Adaptive Server Anywhere
intern einige Datentypen von Open Client-Anwendungen den in Adaptive
Server Anywhere zur Verfügung stehenden Datentypen zu.
Um Open Client Anwendungen zu erstellen, benötigen Sie die
Entwicklungsversion von Open Client. Um Open Client-Anwendungen zu
verwenden, müssen die Open Client Laufzeitprogramme auf dem Computer
installiert und konfiguriert sein, auf dem die Anwendung laufen soll.
Der Adaptive Server Anywhere Server benötigt zur Unterstützung von Open
Client-Anwendungen keine externe Kommunikations-Laufzeit.
Jeder Open Client-Datentyp wird dem entsprechenden Adaptive Server
Anywhere-Datentyp zugeordnet. Es werden alle Open Client-Datentypen
unterstützt.
Die folgende Tabelle zeigt die Zuordnung von Datentypen, die in Adaptive
Server Anywhere unterstützt werden, und die keine direkte Entsprechung in
Open Client haben.
Adaptive Server Anywhere-
Datentyp
unsigned short int
unsigned int bigint
unsigned bigint bigint
Open Client-Datentyp
date smalldatetime
time smalldatetime
serialization longbinary
java longbinary
string varchar
timestamp struct datetime
391

Datentyp-Zuordnungen
Wertebereichseinschränkungen bei der Zuordnung von Datentypen
Beispiel
Zeitstempel
392
Einige Datentypen haben in Adaptive Server Anywhere andere
Wertebereiche als in Open Client. In solchen Fällen kann es zu
Überlauffehlern während der Abfrage oder des Einfügens von Daten
kommen.
Die folgende Tabelle zeigt Open Client-Anwendungsdatentypen, die zwar
Adaptive Server Anywhere-Datentypen zugeordnet werden können, aber nur
mit einigen Einschränkungen im Wertebereich möglicher Werte.
In den meisten Fällen wird der Open Client-Datentyp einem Adaptive Server
Anywhere-Datentyp zugeordnet, der einen größeren Bereich möglicher
Werte hat. Deshalb ist es möglich, einen Wert an Adaptive Server Anywhere
zu übergeben, der zwar akzeptiert und in einer Datenbank gespeichert wird,
der aber zu groß ist, um von einer Open Client-Anwendung abgerufen zu
werden.
Datentyp Untere Open
Client-Grenze
MONEY –922 377 203 685
477.5808
Obere Open
Client-Grenze
922 377 203 685
477.5807
Untere ASA-
Grenze
Obere ASA-
Grenze
–1e15 + 0.0001 1e15 – 0.0001
SMALLMONEY –214 748.3648 214 748.3647 –214 748.3648 214 748.3647
DATETIME 1. Januar 1753 31. Dezember
9999
1. Januar 0001 31. Dez. 9999
SMALLDATETIME 1. Januar 1900 Juni 2079 1. März 1600 31. Dez. 7910
Die Open Client-Datentypen MONEY und SMALLMONEY umfassen zum
Beispiel nicht den gesamten numerischen Bereich der zu Grunde liegenden
Adaptive Server Anywhere-Implementierung. Daher kann in einer Spalte in
Adaptive Server Anywhere ein Wert enthalten sein, der die Grenzwerte des
Open Client Datentyps MONEY überschreitet. Ruft der Client einen solchen
unzulässigen Wert mit Adaptive Server Anywhere ab, wird eine
Fehlermeldung erzeugt.
Die Implementierung des Open Client-Datentyps TIMESTAMP in Adaptive
Server Anywhere unterscheidet sich von der Implementierung in Adaptive
Server Enterprise. In Adaptive Server Anywhere wird der Wert auf dem
Adaptive Server Anywhere-Datentyp DATETIME zugeordnet. Der
voreingestellte Wert ist NULL in Adaptive Server Anywhere, der Wert kann
also uneindeutig sein. Im Gegensatz dazu stellt Adaptive Server Enterprise
sicher, dass der Wert gleichförmig steigt und somit immer eindeutig ist.

Kapitel 10 Die Open Client-Schnittstelle
Der Adaptive Server Anywhere Datentyp TIMESTAMP umfasst Jahr,
Monat, Tag, Stunde, Minute, Sekunde und Sekundenbruchteile. Außerdem
hat der Datentyp DATETIME einen größeren Wertebereich als die Open
Client-Datentypen, die von Adaptive Server Anywhere zugeordnet werden.
393

SQL in Open Client-Anwendungen verwenden
SQL in Open Client-Anwendungen verwenden
SQL Anweisungen ausführen
394
Dieser Abschnitt bietet eine kurze Einführung in die Verwendung von SQL
in Open Client-Anwendungen, mit einem Schwerpunkt auf Themen, die für
Adaptive Server Anywhere spezifisch sind.
$ Eine Einführung in die Konzepte finden Sie unter "SQL in
Anwendungen verwenden" auf Seite 9. Eine vollständige Beschreibung
finden Sie in Ihrer Open Client-Dokumentation.
Sie senden SQL Anweisungen an eine Datenbank, indem Sie sie in die Client
Library Funktionsaufrufe einschließen. Die folgenden beiden Aufrufe führen
zum Beispiel eine DELETE-Anweisung aus:
ret = ct_command(cmd, CS_LANG_CMD,
"DELETE FROM employee
WHERE emp_id=105"
CS_NULLTERM,
CS_UNUSED);
ret = ct_send(cmd);
Die Funktion ct_command wird für viele verschiedene Zwecke eingesetzt.
Vorbereitete Anweisungen verwenden
Die Funktion ct_dynamic wird für die Verwaltung von vorbereiteten
Anweisungen benutzt. Diese Funktion übernimmt den type-Parameter, der
die Aktion beschreibt, die Sie ausführen.
v Eine vorbereitete Anweisung in Open Client benutzen:
1 Bereiten Sie die Anweisung mit der Funktion ct_dynamic mit
CS_PREPARE als type-Parameter vor.
2 Setzen Sie die Anweisungsparameter mit ct_param.
3 Führen Sie die Anweisung mit ct_dynamic mit CS_EXECUTE als
type-Parameter aus.
4 Geben Sie die mit der Anweisung verbundenen Ressourcen frei, indem
Sie ct_dynamic mit einem CS_DEALLOC-type-Parameter
verwenden.

Cursor verwenden
Unterstützte
Cursortypen
Schritte bei der
Verwendung von
Cursorn
Kapitel 10 Die Open Client-Schnittstelle
$ Weitere Informationen über die Verwendung von vorbereiteten
Anweisungen in Open Client finden Sie in der Open Client-Dokumentation.
Die Funktion ct_cursor wird für die Verwaltung von Cursorn verwendet.
Diese Funktion übernimmt den type-Parameter, der die Aktion beschreibt,
die Sie ausführen.
Einige der Cursortypen, die Adaptive Server Anywhere unterstützt, stehen in
der Open Client Schnittstelle nicht zur Verfügung. Sie können über Open
Client weder Scroll-Cursor, noch dynamische Scroll-Cursor, noch
unempfindliche Cursor benutzen.
Eindeutigkeit und Aktualisierbarkeit sind zwei Eigenschaften von Cursorn.
Cursor können eindeutig sein (unabhängig davon, ob sie von der Anwendung
benutzt wird oder nicht, hat jede Zeile einen Primärschlüssel oder eine
Eindeutigkeitsinformation) oder nicht eindeutig sein. Cursor können
schreibgeschützt oder aktualisierbar sein. Ist ein Cursor aktualisierbar und
nicht eindeutig, kann die Performance leiden, da in diesem Fall keine Zeilen
vorab abgerufen werden können. Dies ist unabhängig von der
CS_CURSOR_ROWS-Belegung (siehe unten).
Im Gegensatz zu anderen Schnittstellen wie Embedded SQL ordnet Open
Client einem Cursor eine SQL Anweisung als Zeichenfolge zu. Embedded
SQL bereitet zuerst eine Anweisung vor, dann wird der Cursor mit Hilfe des
Statement-Handles deklariert.
v Cursor in Open Client verwenden:
1 Um einen Cursor in Open Client zu deklarieren, verwenden Sie
ct_cursor mit CS_CURSOR_DECLARE als type-Parameter.
2 Nachdem Sie einen Cursor deklariert haben, können Sie steuern, wie
viele Zeilen vorab vom Client abgerufen werden, und zwar jedesmal
wenn eine Zeile mit ct_cursor mit CS_CURSOR_ROWS als type-
Parameter vom Server abgerufen wird.
Vorab abgerufene Zeilen clientseitig zu speichern, reduziert die Anzahl
der Serveraufrufe. Dies verbessert sowohl den Gesamtdurchsatz als auch
die Fertigstellungszeit. Vorab abgerufene Zeilen werden nicht sofort an
die Anwendung übergeben, sondern werden verwendungsbereit in einem
clientseitigen Puffer zwischengespeichert.
395

SQL in Open Client-Anwendungen verwenden
Zeilen mit einen Cursor ändern
396
Die Einstellung der Datenbankoption PREFETCH steuert den Prefetch-
Vorgang für andere Schnittstellen. Sie wird von Open Client
Verbindungen nicht beachtet. Die Einstellung CS_CURSOR_ROWS
wird bei nicht eindeutigen, aktualisierbaren Cursorn nicht beachtet.
3 Um einen Cursor in Open Client zu öffnen, verwenden Sie ct_cursor
mit CS_CURSOR_OPEN als type-Parameter.
4 Um eine Zeile in der Anwendung abzurufen, verwenden Sie jeweils
ct_fetch.
5 Um einen Cursor zu schließen, verwenden Sie ct_cursor mit
CS_CURSOR_CLOSE.
6 In Open Client müssen Sie außerdem die Ressourcen freigeben, die an
den Cursor gebunden waren. Verwenden Sie dafür ct_cursor mit
CS_CURSOR_DEALLOC. Sie können auch CS_CURSOR_CLOSE mit
dem zusätzlichen Parameter CS_DEALLOC benutzen, um diese
Vorgänge in einem Schritt auszuführen.
Mit Open Client können Sie Zeilen in einem Cursor löschen oder
aktualisieren, sofern der Cursor für eine einzelne Tabelle gilt. Der Benutzer
muss die Berechtigung zur Aktualisierung der Tabelle haben und der Cursor
muss für Aktualisierung markiert sein.
v Zeilen durch einen Cursor verändern:
♦ Statt einen Abruf durchzuführen, können Sie die aktuelle Zeile im
Cursor mit ct_cursor und CS_CURSOR_DELETE löschen oder mit
ct_cursor und CS_CURSOR_UPDATE aktualisieren.
Sie können in Open Client-Anwendungen mit einem Cursor keine Zeilen
einfügen.
Abfrageergebnisse in Open Client beschreiben
Open Client geht mit Ergebnismengen anders um als andere Adaptive Server
Anywhere-Schnittstellen.
In Embedded SQL und ODBC beschreiben Sie eine Abfrage oder eine
gespeicherte Prozedur, um die richtige Anzahl und Typen der Variablen zu
setzen, die die Ergebnisse aufnehmen sollen. Die Beschreibung wird in der
Anweisung selbst gegeben.

Kapitel 10 Die Open Client-Schnittstelle
In Open Client brauchen Sie eine Anweisung nicht zu beschreiben. Statt
dessen kann jede Zeile, die vom Server zurückgegeben wird, eine
Beschreibung Ihrer Inhalte enthalten. Falls Sie ct_command und
ct_send verwenden, um Anweisungen auszuführen, können Sie die
Funktion ct_results benutzen, um mit allen Aspekten der
zurückgegebenen Zeilen umzugehen.
Falls Sie nicht nach dieser Zeile-für-Zeile-Methode vorgehen wollen, können
Sie ct_dynamic verwenden, um eine SQL Anweisung vorzubereiten und
ct_describe, um die Ergebnismenge zu beschreiben. Dies entspricht
mehr dem Beschreiben von SQL Anweisungen bei anderen Schnittstellen.
397

Bekannte Open Client-Einschränkungen von Adaptive Server Anywhere
Bekannte Open Client-Einschränkungen von
Adaptive Server Anywhere
398
Mit der Open Client-Schnittstelle können Sie eine Adaptive Server
Anywhere-Datenbank weitgehend wie eine Adaptive Server Enterprise-
Datenbank verwenden. Es gibt allerdings einige Einschränkungen, unter
anderem folgende:
♦ Commit Service Adaptive Server Anywhere unterstützt Adaptive
Server Enterprise Commit Service nicht.
♦ Funktionen Die Funktionen einer Client/Server-Verbindung bestimmen,
welche Clientanforderungen und Serverantworten für diese Verbindung
zulässig sind. Folgende Funktionen werden nicht unterstützt:
♦ CS_REG_NOTIF
♦ CS_CSR_ABS
♦ CS_CSR_FIRST
♦ CS_CSR_LAST
♦ CS_CSR_PREV
♦ CS_CSR_REL
♦ CS_DATA_BOUNDARY
♦ CS_DATA_SENSITIVITY
♦ CS_PROTO_DYNPROC
♦ CS_REQ_BCP
♦ Sicherheitsoptionen, wie SSL und verschlüsselte Kennwörter, werden
nicht unterstützt.
♦ Open Client-Anwendungen können über TCP/IP oder, wenn verfügbar,
über das Named Pipes-Protokoll des lokalen Systems eine Verbindung
zu Adaptive Server Anywhere herstellen.
$ Weitere Hinweise zu Funktionen finden Sie in der Dokumentation
Open Server Server-Library C Reference Manual (in englischer
Sprache).

KAPITEL 11
Dreischichtige Datenverarbeitung und
verteilte Transaktionen
Über dieses
Kapitel
Inhalt
In diesem Kapitel wird beschrieben, wie Adaptive Server Anywhere in einer
dreischichtigen Umgebung mit einem Anwendungsserver verwendet wird.
Der Schwerpunkt ist, wie Adaptive Server Anywhere in verteilte
Transaktionen einbezogen werden kann.
Thema Seite
Einleitung 400
Dreischichtige Datenverarbeitungsarchitektur 401
Verteilte Transaktionen verwenden 405
EAServer mit Adaptive Server Anywhere verwenden 407
399

Einleitung
Einleitung
400
Sie können Adaptive Server Anywhere als Datenbankserver oder als
Ressourcen-Manager einsetzen, der an verteilten Transaktionen teilnimmt,
die von einem Transaktionsserver koordiniert werden.
Eine dreischichtige Umgebung, in der ein Anwendungsserver zwischen
Clientanwendung und einer Reihe von Ressourcen-Managern sitzt, ist eine
übliche Umgebung für verteilte Transaktionen. Sybase EAServer und einige
andere Anwendungsserver sind ebenfalls Transaktionsserver.
Sybase EAServer und Microsoft Transaction Server verwenden beide den
Microsoft Distributed Transaction Coordinator (DTC) zum Koordinieren der
Transaktionen. Adaptive Server Anywhere bietet Unterstützung für verteilte
Transaktionen, die vom DTC-Service kontrolliert werden, sodass Sie
Adaptive Server Anywhere mit einem dieser Anwendungsserver oder einem
anderen DTC-basierten Produkt verwenden können.
Wenn Sie Adaptive Server Anywhere in eine dreischichtige Umgebung
integrieren, muss der Großteil der Arbeit vom Anwendungsserver erledigt
werden. Dieses Kapitel ist eine Einführung in die Konzepte und die
Architektur der dreischichtigen Datenverarbeitung sowie ein Überblick über
die relevanten Adaptive Server Anywhere-Funktionen. Es beschreibt nicht,
wie Ihr Anwendungsserver für die Arbeit mit Adaptive Server Anywhere
konfiguriert werden muss. Weitere Hinweise finden Sie in der
Anwendungsserver-Dokumentation.

Kapitel 11 Dreischichtige Datenverarbeitung und verteilte Transaktionen
Dreischichtige Datenverarbeitungsarchitektur
Bei der dreistufigen Datenverarbeitung wird die Anwendungslogik auf einem
Anwendungsserver wie einem Sybase EAServer gespeichert, der sich
zwischen dem Ressourcen-Manager und der Clientanwendung befindet. In
vielen Situationen kann ein einziger Anwendungsserver auf mehrere
Ressourcen-Manager zugreifen. Bei Internetanwendungen ist die Clientseite
browserbasiert, und der Anwendungsserver ist im Allgemeinen eine
Webserver-Erweiterung.
Anwendungs-
Server
Sybase EAServer speichert die Anwendungslogik in Form von
Komponenten und stellt diese den Clientanwendungen zur Verfügung. Bei
den Komponenten kann es sich um PowerBuilder-Komponenten, JavaBeans
oder COM-Komponenten handeln.
$ Weitere Hinweise finden Sie in der Dokumentation zum Sybase
EAServer.
401

Dreischichtige Datenverarbeitungsarchitektur
Verteilte Transaktionen in dreischichtiger Datenverarbeitung
402
Wenn Clientanwendungen oder Anwendungsserver mit einer einfachen
Transaktionsverarbeitungs-Datenbank arbeiten, wie etwa Adaptive Server
Anywhere, wird außerhalb der Datenbank selbst keine Transaktionslogik
benötigt. Wenn jedoch mit mehreren Ressourcen-Managern gearbeitet wird,
muss die Transaktionssteuerung die in die Transaktion einbezogenen
Ressourcen abdecken. Anwendungsserver bieten ihren Clientanwendungen
Transaktionslogik, sodass Gruppen von Vorgängen in kleinsten Einheiten
ausgeführt werden.
Viele Transaktionsserver, einschließlich Sybase EAServer, verwenden den
Microsoft Distributed Transaction Coordinator (DTC), um den
Clientanwendungen Transaktionsdienste anzubieten. DTC verwendet OLE-
Transaktionen, die ihrerseits das Protokoll Zwei-Phasen-Commit für die
Koordinierung von Transaktionen mit mehreren Ressourcen-Managern
verwenden. Um die in diesem Kapitel beschriebenen Funktionen verwenden
zu können, müssen Sie DTC installiert haben.
Adaptive Server Anywhere in verteilten Transaktionen
Adaptive Server Anywhere kann an von DTC koordinierten Transaktionen
teilnehmen. Das bedeutet, dass Sie Adaptive Server Anywhere-Datenbanken
in verteilten Transaktionen mit einem Transaktionsserver wie etwa Sybase
EAServer oder Microsoft Transaction Server verwenden können. Außerdem
können Sie DTC direkt in Ihren Anwendungen zur Koordinierung von
Transaktionen über mehrere Ressourcen-Manager einsetzen.
Begriffe im Zusammenhang mit verteilten Transaktionen
In diesem Kapitel wird eine gewisse Vertrautheit mit verteilten
Transaktionen vorausgesetzt. Hinweise finden Sie in der Dokumentation zum
Transaktionsserver. In diesem Abschnitt werden allgemein übliche Begriffe
beschrieben.
♦ Ressourcen-Manager sind Dienste, die in eine Transaktion
einbezogene Daten verwalten.
Der Adaptive Server Anywhere-Datenbankserver kann in einer
verteilten Transaktion als Ressourcen-Manager agieren, wenn über OLE
DB oder ODBC darauf zugegriffen wird. Der ODBC-Treiber und der
OLE DB-Provider agieren auf dem Client-System als Ressourcen-
Manager-Proxys.

Zwei-Phasen-
Commit
Kapitel 11 Dreischichtige Datenverarbeitung und verteilte Transaktionen
♦ Anstatt direkt mit dem Ressourcen-Manager, können
Anwendungskomponenten mit Ressourcen-Verteilern kommunizieren,
die ihrerseits Verbindungen oder Verbindungs-Pools zu den Ressourcen-
Managern verwalten.
Adaptive Server Anywhere unterstützt zwei Ressourcen-Verteiler: den
ODBC-Treibermanager und OLE DB.
♦ Wenn eine Transaktionskomponente eine Datenbankverbindung
anfordert (über einen Ressourcen-Manager), bezieht der
Anwendungsserver alle Datenbankverbindungen ein, die an der
Transaktion teilnehmen. DTC und der Ressourcen-Verteiler führen den
Einbeziehungsvorgang aus.
Verteilte Transaktionen werden mit Zwei-Phasen-Commit verwaltet. Wenn
die Arbeit der Transaktion abgeschlossen ist, fragt der Transaktions-Manager
(DTC) alle in die Transaktion einbezogenen Ressourcen-Manager, ob sie
bereit sind, die Transaktion festzuschreiben. Diese Phase wird Vorbereiten
zum Festschreiben genannt.
Wenn alle Ressourcen-Manager antworten, dass sie zum Festschreiben bereit
sind, sendet DTC eine Anforderung zum Festschreiben an jeden einzelnen
Ressourcen-Manager und antwortet seinem Client, dass die Transaktion
abgeschlossen ist. Wenn einer oder mehrere Ressourcen-Manager nicht
antworten oder antworten, dass sie die Transaktion nicht festschreiben
können, wird die gesamte Arbeit der Transaktion über alle Ressourcen-
Manager zurückgesetzt.
So verwenden Anwendungsserver DTC
Sybase EAServer und Microsoft Transaction Server sind beides
Komponentenserver. Die Anwendungslogik wird in Form von Komponenten
gespeichert und den Clientanwendungen zur Verfügung gestellt.
Jede Komponente hat ein Transaktionsattribut, das darauf hinweist, wie die
Komponente an Transaktionen teilnimmt. Der Anwendungsentwickler, der
die Komponente aufbaut, muss die Arbeit der Transaktion in die
Komponente einprogrammieren: Die Ressourcen-Manager-Verbindungen,
die Vorgänge mit den Daten, für die jeder einzelne Ressourcen-Manager
verantwortlich ist. Der Anwendungsentwickler braucht jedoch nicht die
Transaktionsverwaltungslogik in die Komponente einzubauen. Wenn das
Transaktionsattribut so gesetzt ist, dass darauf hingewiesen wird, dass die
Komponente eine Transaktionsverwaltung benötigt, verwendet EAServer
DTC, um die Transaktion einzubeziehen und den Zwei-Phasen-Commit-
Vorgang zu verwalten.
403

Dreischichtige Datenverarbeitungsarchitektur
Verteilte Transaktionsarchitektur
404
Das folgende Diagramm veranschaulicht die Architektur von verteilten
Transaktionen. In diesem Fall ist der Ressourcen-Manager-Proxy entweder
ODBC oder OLE DB.
Client-
System
Ressourcen-
Manager-
Proxy
DTC
Serversystem
1
Anwendungs-
Server
DTC
DTC
Serversystem
2
Ressourcen-
Manager-
Proxy
In diesem Fall wird ein einzelner Ressourcen-Verteiler verwendet. Der
Anwendungsserver fordert DTC auf, die Transaktion vorzubereiten. DTC
und der Ressourcen-Verteiler beziehen jede einzelne Verbindung in die
Transaktion ein. Jeder einzelne Ressourcen-Manager muss sowohl mit DTC
als auch mit der Datenbank in Kontakt stehen, damit die Arbeit ausgeführt
werden kann, und um DTC ggf. auf seinen Transaktionsstatus hinzuweisen.
Auf jedem System muss ein DTC-Dienst laufen, damit die verteilten
Transaktionen ausgeführt werden können. DTC-Dienste können vom
Symbol "Dienste" in der Windows-Systemsteuerung aus kontrolliert werden.
Der DTC-Dienst heißt MSDTC.
$ Weitere Hinweise finden Sie in der Dokumentation zu DTC bzw.
EAServer.

Kapitel 11 Dreischichtige Datenverarbeitung und verteilte Transaktionen
Verteilte Transaktionen verwenden
DTC-Isolationsstufen
Wenn Adaptive Server Anywhere in eine verteilte Transaktion einbezogen
ist, gibt er die Kontrolle an den Transaktionsserver weiter und Adaptive
Server Anywhere gewährleistet, dass keine implizite Transaktionsverwaltung
ausgeführt wird. Die folgenden Bedingungen werden automatisch von
Adaptive Server Anywhere auferlegt, wenn er an verteilten Transaktionen
teilnimmt:
♦ Autocommit wird automatisch deaktiviert, wenn es verwendet wurde.
♦ Datendefinitions-Anweisungen (als Nebenwirkung festgeschrieben)
werden während der verteilten Transaktionen deaktiviert.
♦ Ein explizites COMMIT oder ROLLBACK von der Anwendung direkt
an Adaptive Server Anywhere anstatt über den Transaktionskoordinator
führt zu einer Fehlermeldung. Die Transaktion wird jedoch nicht
abgebrochen.
♦ Eine Verbindung kann jeweils nur an einer verteilten Transaktion
teilnehmen.
♦ Zu dem Zeitpunkt, wenn die Verbindung in eine verteilte Transaktion
einbezogen wird, darf es keine nicht festgeschriebenen Vorgänge geben.
DTC weist eine Reihe von Isolationsstufen auf, die der Anwendungsserver
angibt. Diese Isolationsstufen entsprechen folgendermaßen den
Isolationsstufen von Adaptive Server Anywhere:
DTC-Isolationsstufe Adaptive Server
Anywhere-Isolationsstufe
ISOLATIONLEVEL_UNSPECIFIED 0
ISOLATIONLEVEL_CHAOS 0
ISOLATIONLEVEL_READUNCOMMITTED 0
ISOLATIONLEVEL_BROWSE 0
ISOLATIONLEVEL_CURSORSTABILITY 1
ISOLATIONLEVEL_READCOMMITTED 1
ISOLATIONLEVEL_REPEATABLEREAD 2
ISOLATIONLEVEL_SERIALIZABLE 3
ISOLATIONLEVEL_ISOLATED 3
405

Verteilte Transaktionen verwenden
Wiederherstellung nach verteilten Transaktionen
406
Wenn der Datenbankserver einen Fehler aufweist, während nicht
festgeschriebene Vorgänge auf Ausführung warten, müssen diese Vorgänge
beim Neustart entweder zurückgesetzt oder festgeschrieben werden, damit
die atomare Natur der Transaktion geschützt wird.
Wenn während der Wiederherstellung nicht festgeschriebene Vorgänge einer
verteilten Transaktion gefunden werden, versucht der Datenbankserver eine
Verbindung mit DTC herzustellen und fordert, wieder in die auf Ausführung
wartenden bzw. in die zweifelhaften Transaktionen einbezogen zu werden.
Wenn die Wiedereinbeziehung abgeschlossen ist, weist DTC den
Datenbankserver an, die ausstehenden Vorgänge zurückzusetzen oder
festzuschreiben.
Wenn der Wiedereinbeziehungsvorgang fehlschlägt, kann Adaptive Server
Anywhere nicht wissen, ob die zweifelhaften Vorgänge festgeschrieben oder
zurückgesetzt werden sollten, und die Wiederherstellung schlägt fehl. Wenn
Sie wollen, dass die Datenbank wieder in solch einem Status hergestellt wird,
unabhängig vom unsicheren Status der Daten, können Sie die
Wiederherstellung mit den folgenden Datenbankserveroptionen erzwingen:
♦ -tmf Wenn DTC nicht geladen werden kann, werden die ausstehenden
Vorgänge zurückgesetzt und die Wiederherstellung wird fortgesetzt.
$ Weitere Hinweise finden Sie unter "–tmf-Serveroption" auf
Seite 169 der Dokumentation ASA Datenbankadministration.
♦ -tmt Wenn die Wiedereinbeziehung vor der angegebenen Zeit nicht
gelingt, werden die ausstehenden Vorgänge zurückgesetzt und die
Wiederherstellung wird fortgesetzt.
$ Weitere Hinweise finden Sie unter "–tmt-Serveroption" auf
Seite 169 der Dokumentation ASA Datenbankadministration.

Kapitel 11 Dreischichtige Datenverarbeitung und verteilte Transaktionen
EAServer mit Adaptive Server Anywhere
verwenden
EA Server konfigurieren
Dieser Abschnitt bietet einen Überblick über die in EAServer 3.0 oder später
für die Arbeit mit Adaptive Server Anywhere zu ergreifenden Maßnahmen.
Weitere Hinweise finden Sie in der Dokumentation zum Sybase EAServer.
Alle in einem Sybase EAServer installierten Komponenten nutzen
gemeinsam denselben Transaktionskoordinator.
EAServer 3.0 und später bieten eine Auswahl von
Transaktionskoordinatoren. Sie müssen DTC als Transaktionskoordinator
verwenden, wenn Sie Adaptive Server Anywhere in die Transaktionen
einbeziehen. In diesem Abschnitt wird beschrieben, wie EAServer 3.0 für die
Benutzung von DTC als Transaktionskoordinator konfiguriert wird.
Der Komponentenserver in EAServer trägt den Namen Jaguar.
v So wird ein EAServer für die Verwendung des Microsoft DTC
Transaktionsmodells konfiguriert:
1 Vergewissern Sie sich, dass Ihr Jaguar-Server läuft.
Unter Windows läuft der Jaguar-Server normalerweise als Dienst. Wenn
der mit EAServer 3.0 installierte Jaguar-Server manuell gestartet werden
soll, wählen Sie Start➤Programme➤Sybase➤EAServer➤EAServer.
2 Starten Sie den Jaguar Manager.
Wählen Sie vom Windows Desktop
Start➤Programme➤Sybase➤EAServer➤Jaguar Manager.
3 Stellen Sie vom Jaguar Manager aus eine Verbindung mit dem Jaguar-
Server her.
Wählen Sie im Sybase Central-Menü Extras➤Verbinden➤Jaguar
Manager. Geben Sie im Verbindungsdialog jagadmin als
Benutzernamen ein, lassen Sie das Kennwortfeld leer und geben Sie den
Hostnamen localhost ein. Klicken Sie auf OK, damit eine Verbindung
hergestellt wird.
4 Legen Sie das Transaktionsmodell für den Jaguar-Server fest.
407

EAServer mit Adaptive Server Anywhere verwenden
408
Öffnen Sie im linken Fensterausschnitt den Ordner "Server".
Rechtsklicken Sie im rechten Fensterausschnitt auf den Server, den Sie
konfigurieren wollen und wählen Sie "Servereigenschaften" aus dem
Menü. Öffnen Sie das Register "Transaktionen" und wählen Sie
Microsoft DTC als Transaktionsmodell. Klicken Sie auf OK, damit der
Vorgang abgeschlossen wird.
Komponenten-Transaktionsattribut festlegen
Im EAServer können Sie eine Komponente implementieren, die Vorgänge
mit mehr als einer Datenbank ausführt. Sie weisen dieser Komponente ein
Transaktionsattribut zu, das festlegt, wie sie an Transaktionen teilnimmt.
Das Transaktionsattribut kann die folgenden Werte annehmen:
♦ Nicht unterstützt Die Methoden der Komponente werden nie als Teil
einer Transaktion ausgeführt. Wird die Komponente von einer anderen
Komponente aktiviert, die innerhalb einer Transaktion ausgeführt wird,
dann wird die Arbeit der neuen Instanz außerhalb der vorhandenen
Transaktion ausgeführt. Dies ist die Standardeinstellung.
♦ Unterstützt Transaktion Die Komponente kann im Kontext einer
Transaktion ausgeführt werden, eine Verbindung ist jedoch nicht
erforderlich, um die Methoden der Komponente auszuführen. Wenn die
Komponente direkt von einem Basis-Clienten instanziert wird, beginnt
EAServer keine Transaktion. Wenn Komponente A von Komponente B
instanziert und Komponente B innerhalb einer Transaktion ausgeführt
wird, führt das System die Komponente A in derselben Transaktion aus.
♦ Erfordert Transaktion Die Komponente wird immer in einer
Transaktion ausgeführt. Wenn die Komponente direkt von einem Basis-
Client instanziert wird, beginnt eine neue Transaktion. Wenn
Komponente A von Komponente B aktiviert wird und B innerhalb einer
Transaktion ausgeführt wird, führt das System A innerhalb derselben
Transaktion aus, wenn B nicht in einer Transaktion ausgeführt wird,
führt das System A in einer neuen Transaktion aus.
♦ Erfordert neue Transaktion Wenn die Komponente instanziert wird,
beginnt eine neue Transaktion. Wenn Komponente A von Komponente
B aktiviert wird und B innerhalb einer Transaktion ausgeführt wird,
beginnt A einen neue Transaktion, die unabhängig ist vom Ergebnis der
Transaktion B, wenn B nicht in einer Transaktion ausgeführt wird, führt
das System A in einer neuen Transaktion aus.

Kapitel 11 Dreischichtige Datenverarbeitung und verteilte Transaktionen
In der Beispielanwendung Sybase Virtual University, die mit EAServer als
SVU-Paket geliefert wird, führt die Methode enroll() der Komponente
SVUEnrollment zwei separate Vorgänge aus (reserviert einen Platz in
einem Kurs, fakturiert den Studenten für den Kurs). Diese beiden Vorgänge
müssen als Einzel-Transaktionen behandelt werden.
Microsoft Transaction Server bietet dieselbe Gruppe von Attributwerten.
v So wird das Transaktionsattribut einer Komponente festgelegt:
1 Ermitteln Sie die Position der Komponente im Jaguar Manager.
Wenn Sie die Komponente SVUEnrollment in der Jaguar-
Beispielanwendung suchen wollen, stellen Sie eine Verbindung mit dem
Jaguar-Server her, öffnen Sie den Ordner "Pakete" und öffnen Sie das
SVU-Paket. Die Komponenten im Paket werden im rechten
Fensterausschnitt aufgeführt.
2 Legen Sie das Transaktionsattribut für die gewünschte Komponente fest.
Rechtsklicken Sie auf die Komponente und klicken Sie auf
"Komponenten-Eigenschaften" im Einblendmenü. Öffnen Sie das
Register "Transaktion" und wählen Sie den Wert für das
Transaktionsattribut aus der Liste. Klicken Sie auf OK, damit der
Vorgang abgeschlossen wird.
Die Komponente SVUEnrollment ist bereits als "Erfordert Transaktion"
markiert.
Wenn das Komponenten-Transaktionsattribut festgelegt ist, können Sie
Adaptive Server Anywhere-Vorgänge von der Komponente aus ausführen
und sicher sein, dass die Transaktion auf der Ebene ausgeführt wird, die Sie
angegeben haben.
409

EAServer mit Adaptive Server Anywhere verwenden
410

KAPITEL 12
Deployment: Datenbanken und
Anwendungen im System bereitstellen
Über dieses
Kapitel
Inhalt
In diesem Kapitel wird beschrieben, wie Komponenten von Adaptive Server
Anywhere für die allgemeine Nutzung im System bereitgestellt werden
können. Beschrieben werden die erforderlichen Dateien für die
Bereitstellung sowie Fragen im Zusammenhang mit der Adressierung und
der Einstellung von Verbindungsparametern.
Prüfen Sie Ihre Lizenzvereinbarung
Die Weitergabe von Dateien wird durch die Lizenzvereinbarung geregelt.
In diesem Kapitel enthaltene Ausführungen können die Bestimmungen
Ihrer Lizenzvereinbarung weder aufheben noch ändern. Bevor Sie daher
Anwendungen im System bereitstellen, prüfen Sie bitte Ihre
Lizenzvereinbarung.
Thema Seite
Systemeinführung - Überblick 412
Installationsverzeichnisse und Dateinamen 415
InstallShield-Objekte und Vorlagen zum Bereitstellen verwenden 420
Dialogfreie Installation für die Systemeinführung 422
Clientanwendungen im System bereitstellen 426
Tools zur Verwaltung bereitstellen 437
Datenbankserver im System bereitstellen 438
Eingebettete Datenbankanwendungen im System bereitstellen 441
411

Systemeinführung - Überblick
Systemeinführung - Überblick
412
Wenn Sie eine Datenbankanwendung fertig gestellt haben, müssen Sie die
Anwendung für Ihre Endbenutzer bereitstellen. Je nach der Art, wie Ihre
Anwendung Adaptive Server Anywhere verwendet (als eingebettete
Datenbank, im Client-/Servermodus usw.), müssen Sie Komponenten von
Adaptive Server Anywhere zusammen mit Ihrer Anwendung bereitstellen. Es
kann außerdem erforderlich sein, Konfigurationsdaten bereitzustellen, wie
etwa Datenquellennamen, damit die Anwendung mit Adaptive Server
Anywhere kommunizieren kann.
Prüfen Sie Ihre Lizenzvereinbarung
Die Weitergabe von Dateien wird durch die Lizenzvereinbarung mit
Sybase geregelt. In diesem Kapitel enthaltene Ausführungen können die
Bestimmungen Ihrer Lizenzvereinbarung weder aufheben noch ändern.
Bevor Sie daher Anwendungen im System bereitstellen, prüfen Sie bitte
Ihre Lizenzvereinbarung.
Folgende Bereiche der Systemeinführung werden in diesem Kapitel
besprochen:
♦ Ermittlung der erforderlichen Dateien je nach Anwendungsplattform
und Plattformarchitektur
♦ Konfiguration der Clientanwendungen
Modelle für die Systemeinführung
Eine großer Teil des Kapitels befasst sich mit einzelnen Dateien und wo sie
platziert werden müssen. Es wird jedoch empfohlen, Adaptive Server
Anywhere-Komponenten unter Verwendung der Installshield-Objekte oder
dialogfrei zu installieren. Hinweise finden Sie unter "InstallShield-Objekte
und Vorlagen zum Bereitstellen verwenden" auf Seite 420 und "Dialogfreie
Installation für die Systemeinführung" auf Seite 422.
Welche Dateien Sie bei der Systemeinführung bereitstellen müssen, hängt
vom gewählten Modell ab. Nachstehend werden einige denkbare Modelle
beschrieben:
♦ Clientbereitstellung Sie können nur die Clientkomponenten von
Adaptive Server Anywhere für die Endbenutzer bereitstellen, sodass
diese sich mit einem zentral untergebrachten Netzwerk-Datenbankserver
verbinden können.

Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
♦ Netzwerkserver bereitstellen Sie können Netzwerkserver in
Zweigstellen einrichten und dann Clients für alle Benutzer in diesen
Büros bereitstellen.
♦ Eingebettete Datenbanken bereitstellen Sie können eine Datenbank
bereitstellen, die mit einem Personal Datenbankserver läuft. In diesem
Fall müssen der Client und der Personal Server auf dem Rechner des
Endbenutzers installiert werden.
♦ Bereitstellung über SQL Remote Die Bereitstellung einer SQL
Remote-Anwendung ist eine Erweiterung des Modells der Bereitstellung
einer eingebetteten Datenbank.
♦ DBTools-Bereitstellung Sie können Interactive SQL, Sybase Central
und andere Tools zur Verwaltung bereitstellen.
Möglichkeiten zur Weitergabe von Dateien
Es gibt zwei Möglichkeiten, Adaptive Server Anywhere für den allgemeinen
Gebrauch verfügbar zu machen:
♦ Sie benutzen das Installationsprogramm von Adaptive Server
Anywhere Sie können das Setup-Programm den Endbenutzern zur
Verfügung stellen. Wenn der Endbenutzer die richtigen
Installationsoptionen wählt, verfügt er garantiert über alle erforderlichen
Dateien.
Dies ist die einfachste Lösung für viele Fälle der Systemeinführung. In
diesem Fall müssen Sie den Endbenutzern nur noch eine Methode zur
Verbindungsaufnahme mit dem Datenbankserver übergeben (z.B. eine
ODBC-Datenquelle).
$ Weitere Hinweise finden Sie unter "Dialogfreie Installation für die
Systemeinführung" auf Seite 422.
♦ Entwicklung Ihrer eigenen Installation Es kann Gründe dafür geben,
dass Sie ein eigenes Installationsprogramm entwickeln wollen, das
Dateien von Adaptive Server Anywhere enthält. Diese Option ist viel
komplizierter, und daher richtet sich der größte Teil dieses Kapitels an
jene, die eigene Installationen entwickeln müssen.
Wenn Adaptive Server Anywhere bereits passend für den Servertyp und
das Betriebssystem der Clientanwendung installiert wurde, stehen die
erforderlichen Dateien in dem entsprechend benannten Unterverzeichnis
bereit, das im Installationsverzeichnis von Adaptive Server Anywhere
angelegt wurde.
413

Systemeinführung - Überblick
414
Wenn beispielsweise das Standard-Installationsverzeichnis gewählt
wurde, enthält das Unterverzeichnis win32 im Installationsverzeichnis
die Dateien, die benötigt werden, um den Server unter Windows-
Betriebssystemen zu betreiben.
Ebenso können Anwender von InstallShield Professional 5.5 und höher
die InstallShield-Vorlagenprojekte für SQL Anywhere Studio
verwenden, um ihre eigenen Anwendungen bereitzustellen. Mit dieser
Funktion erstellen Sie das Installationsprogramm für Ihre Anwendung,
indem Sie das gesamte Vorlagenprojekt oder nur die für Ihre Installation
relevanten Teile verwenden.
Gleichgültig welche Option Sie wählen: Sie müssen sich dabei immer an die
Bestimmungen Ihrer Lizenz halten.

Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
Installationsverzeichnisse und Dateinamen
Damit eine im System bereitgestellte Anwendung richtig funktioniert,
müssen die Clientbibliotheken ermitteln können, wo die erforderlichen
Dateien untergebracht sind. Die bereitgestellten Dateien müssen in derselben
Struktur gespeichert werden wie in der Installation von Adaptive Server
Anywhere.
In der Praxis bedeutet das, dass auf einem PC die meisten Dateien in ein
einziges Verzeichnis gehören. Unter Windows z.B. werden Dateien für den
Datenbankserver und für den Client in nur einem Verzeichnis installiert,
nämlich dem Unterverzeichnis win32 des Installationsverzeichnisses von
Adaptive Server Anywhere.
$ Eine vollständige Beschreibung der Standorte, an denen die Software
nach Dateien sucht, finden Sie unter "Ermittlung des Dateienstandorts durch
Adaptive Server Anywhere" auf Seite 228 der Dokumentation ASA
Datenbankadministration.
Anwendungen unter UNIX bereitstellen
Die Bereitstellung von Anwendungen unter UNIX unterscheidet sich von der
auf PC üblichen in folgender Weise:
♦ Verzeichnisstruktur Bei UNIX-Installationen lautet die
Verzeichnisstruktur wie folgt:
Verzeichnis Inhalt
/opt/sybase/SYBSsa8/bin Programmdateien
/opt/sybase/SYBSsa8/lib Gemeinsame Objekte und Bibliotheken
/opt/sybase/SYBSsa8/res Textdateien
Auf AIX lautet das standardmäßige Stammverzeichnis
/usr/lpp/sybase/SYBSsa8 an Stelle von /opt/sybase/SYBSsa8.
♦ Dateierweiterungen In den Tabellen dieses Kapitels werden die
gemeinsamen Objekte mit der Erweiterung .so angeführt. Unter HP-UX
lautet diese Erweiterung .sl.
Im Betriebssystem AIX haben gemeinsam genutzte Dateien, mit denen
sich Anwendungen verknüpfen müssen, die Erweiterung .a.
415

Installationsverzeichnisse und Dateinamen
Namenskonventionen für Dateien
416
♦ Symbolische Verknüpfungen Jedes gemeinsam genutzte Objekt ist als
symbolische Verknüpfung zu einer Datei gleichen Namens mit der
zusätzlichen Erweiterung .1 (eins) installiert. Beispiel: Die Datei
libdblib8.so ist eine symbolische Verknüpfung zur Datei libdblib8.so.1 in
demselben Verzeichnis.
Wenn Korrekturprogramme für die Installation von Adaptive Server
Anywhere erforderlich sind, werden sie mit der Erweiterung .2 geliefert
und die symbolische Verknüpfung muss umgeleitet werden.
♦ Anwendungen mit und ohne Threads Die meisten gemeinsam
genutzten Objekte werden in zwei Formen geliefert, von denen eine mit
den zusätzlichen Zeichen _r vor der Dateierweiterung versehen ist.
Beispiel: Zusätzlich zu libdblib8.so gibt es eine Datei mit der
Bezeichnung libdblib8_r.so. In diesem Fall müssen Anwendungen mit
Thread mit dem gemeinsam genutzten Objekt _r verknüpft werden,
Anwendungen ohne Thread hingegen mit dem gemeinsam genutzten
Objekt ohne den Zusatz _r.
♦ Zeichensatzkonvertierung Wenn Sie die Zeichensatzkonvertierung
des Datenbankservers (Serveroption -ct) benutzen möchten, müssen die
folgenden Dateien hinzugefügt werden:
♦ libunic.so
♦ Verzeichnisstruktur charsets/
♦ asa.cvf
$ Eine Beschreibung der Standorte, an denen die Software nach Dateien
sucht, finden Sie unter "Ermittlung des Dateienstandorts durch Adaptive
Server Anywhere" auf Seite 228 der Dokumentation ASA
Datenbankadministration.
Adaptive Server Anywhere benutzt einheitliche Konventionen, damit Sie die
Systemkomponenten leichter erkennen und zu Gruppen zusammenfassen
können.
Diese Konventionen sind wie folgt aufgebaut:
♦ Versionsnummer Die Versionsnummer von Adaptive Server Anywhere
wird im Dateinamen der Haupt-Serverkomponenten (.exe and .dll
Dateien) dargestellt.
Beispiel: Die Datei dbeng8.exe ist eine Programmdatei für Version 7.

Andere Dateitypen
erkennen
Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
♦ Sprache Die in einer Sprachen-Ressourcebibliothek verwendete
Sprache wird durch einen Sprachcode im Dateinamen angezeigt. Die
zwei Zeichen vor der Versionsnummer weisen auf die in der Bibliothek
verwendete Sprache hin. Zum Beispiel ist dblgen8.dll die Sprachen-
Ressourcebibliothek für Englisch. Diese Codes aus zwei Buchstaben
sind im ISO-Standard 639 festgelegt.
$ Weitere Hinweise zur Sprachenkennzeichnung finden Sie unter
"Näheres zur Sprache der Sprachumgebung" auf Seite 288 der
Dokumentation ASA Datenbankadministration.
Sie können das International Resources Deployment Kit, das DLLs für die
Bereitstellung von Sprachressourcen enthält, gratis von der Sybase-Website
herunterladen.
v So laden Sie das International Resources Deployment Kit von der
Sybase-Website herunter:
1 Öffnen Sie im Webbrowser den folgenden URL:
http://www.sybase.com/products/mobilewireless/anywhe
re/
2 Klicken Sie unterhalb der Überschrift "SQL Anywhere Studio" links auf
der Seite auf "Downloads".
3 Klicken Sie unterhalb der Überschrift "Emergency Bug Fix/Updates"
auf "Emergency Bug Fixes and Updates for SQL Anywhere Studio".
4 Melden Sie sich bei Ihrem Sybase-Netzkonto an.
Klicken Sie auf "Create a New Account", um ein Sybase-Netzkonto zu
erstellen, falls Sie noch keines haben.
5 Aus der Liste der verfügbaren Downloads wählen Sie das International
Resources Deployment Kit aus, das der verwendeten Plattform und
Version von Adaptive Server Anywhere entspricht.
$ Eine Liste der in Adaptive Server Anywhere verfügbaren Sprachen
finden Sie unter "Mitgelieferte Kollatierungen" auf Seite 295 der
Dokumentation ASA Datenbankadministration.
Die folgende Tabelle zeigt die Plattform und die Funktion der Adaptive
Server Anywhere-Dateien entsprechend ihrer Dateierweiterung. In Adaptive
Server Anywhere wurden, wo immer möglich, die Standard-
Dateierweiterungen verwendet.
417

Installationsverzeichnisse und Dateinamen
Datenbankdateinamen
418
Dateierweiterung
Plattform Dateityp
.nlm Novell Netware Mit NetWare ladbares
Modul
.cnt, .ftg, .fts,
.gid, .hlp, .chm,
.chw
.lib Ändert sich je nach
Entwicklungstool
.cfg, .cpr, .dat,
.loc, .spr, .srt,
.xlt
Windows NT Datei des Hilfesystems
Statische Laufzeitbibliotheken
für die
Erstellung von Embedded
SQL Programmdateien
Windows Komponenten von Sybase
Adaptive Server Enterprise
.cmd .bat Windows Befehlsdateien
.res NetWare, UNIX Sprachen-Ressourcedatei
für Umgebungen außer
Windows
.dll Windows Dynamische
Verknüpfungsbibliothek
(Dynamic Link Library)
.so .sl .a UNIX Gemeinsam genutztes
Objekt (Sun Solaris und
IBM AIX) oder gemeinsam
genutzte Bibliothek (HP-
UX). Dies ist das
Gegenstück zu einer DLL
auf PC-Plattformen.
Die Adaptive Server Anywhere Datenbanken bestehen aus zwei Elementen:
♦ Datenbankdatei Sie wird verwendet, um Informationen in organisierter
Form zu speichern. Dieser Datei ist die Dateierweiterung .db
zugeordnet.
♦ Transaktionslogdatei Sie wird benutzt, um alle Änderungen
aufzuzeichnen, die an den Daten in der Datenbankdatei vorgenommen
werden. Für diese Datei wird die Dateierweiterung .log verwendet. Sie
wird vom Adaptive Server Anywhere erzeugt, wenn keine solche Datei
vorhanden ist und die Verwendung einer Logdatei definiert wurde. Ein
gespiegeltes Transaktionslog hat die standardmäßige Erweiterung .mlg.
♦ Write-Datei Wenn Ihre Anwendung eine Write-Datei verwendet, verfügt
sie in der Regel über die Dateierweiterung .wrt.

Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
♦ Komprimierte Datenbankdatei Wenn Sie eine schreibgeschützte
komprimierte Datenbankdatei verwenden, hat sie normalerweise die
Dateierweiterung .cdb.
Diese Dateien werden vom Datenbank-Managementsystem von Adaptive
Server Anywhere aktualisiert, gepflegt und verwaltet.
419

InstallShield-Objekte und Vorlagen zum Bereitstellen verwenden
InstallShield-Objekte und Vorlagen zum
Bereitstellen verwenden
420
Wenn Sie InstallShield 6 oder höher verwenden, können Sie SQL Anywhere
Studio InstallShield-Objekte in Ihr Installationsprogramm einbeziehen. Die
Objekte zur Bereitstellung von Clients, Personal Datenbankservern,
Netzwerkservern und Verwaltungstools finden Sie im Verzeichnis
deployment\Objects in Ihrem SQL Anywhere-Verzeichnis.
Anwender von InstallShield Professional 5.5 und höher können InstallShield-
Vorlagenprojekte für SQL Anywhere Studio verwenden, um sich die Arbeit
für die Bereitstellung ihrer eigenen Anwendungen zu erleichtern. Vorlagen
zum Bereitstellen eines Netzwerkservers, eines Personal Servers, Client-
Schnittstellen und Verwaltungstools finden Sie im Verzeichnis
SQL Anywhere 8\deployment\Templates.
Wenn Sie InstallShield 6 oder höher haben, sind die Objekte den Vorlagen
vorzuziehen, weil sie einfacher zusammen mit anderen Komponenten in die
Installation zu integrieren sind.
v So fügen Sie ein Vorlagenprojekt zu Ihrer InstallShield-IDE hinzu:
1 Starten Sie die InstallShield-IDE.
2 Wählen Sie Datei➤Öffnen.
3 Wechseln Sie zu Ihrer SQL Anywhere 7-Installation und ins
Bereitstellungsverzeichnis.
Wechseln Sie zum Beispiel zu folgendem Verzeichnis:
C:\Programme\Sybase\SQL Anywhere 8\deployment.
4 Öffnen Sie die Vorlage, die dem Typ des Objekts entspricht, das Sie
bereitstellen wollen.
Sie können zwischen NetworkServer, PersonalServer, Client und
JavaTools wählen.
5 Wählen Sie die Datei mit der Erweiterung .ipr.
Das Projekt wird in der InstallShield-IDE geöffnet. Im Projektbereich
wird ein Symbol für die Vorlage angezeigt.
Die Vorlagen werden während der Installation geändert, sodass die
Suchpfade der einzelnen Dateien, die in allen .fgl-Dateien aufgelistet
sind, auf die aktuelle Installation von ASA zeigen. Laden Sie einfach die
Vorlage in die InstallShield-IDE, generieren Sie die Medien und die
Vorlage wird unmittelbar ausgeführt.

Hinweise:
Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
Wenn Sie die Medien generieren, sehen Sie Warnmeldungen über leere
Dateigruppen. Diese Warnungen werden durch leere Dateigruppen
verursacht, die als Platzhalter für die Dateien Ihrer Anwendung in die
Vorlage eingefügt wurden. Um diese Warnungen zu entfernen, können
Sie entweder die Dateien Ihrer Anwendung in die Dateigruppen
einfügen oder die Dateigruppen löschen oder umbenennen.
421

Dialogfreie Installation für die Systemeinführung
Dialogfreie Installation für die Systemeinführung
422
Dialogfreie Installationen laufen ohne Eingriff von Seiten des Benutzers und
ohne dass der Benutzer erfährt, dass eine Installation ausgeführt wird. Bei
Windows-Betriebssystemen können Sie das InstallShield-Setup-Programm
von Adaptive Server Anywhere so aufrufen, dass die Adaptive Server
Anywhere Installation dialogfrei verläuft. Dialogfreie Installationen werden
ebenfalls vom Microsoft Systems Management Server verwendet (siehe
"SMS-Installation" auf Seite 424).
Sie können eine dialogfreie Installation für alle Systemeinführungsmodelle
verwenden, die in "Modelle für die Systemeinführung" auf Seite 412
beschrieben wurden. Sie können zur Bereitstellung von MobiLink-
Synchronisationsservern auch eine dialogfreie Installation verwenden.
So wird eine dialogfreie Installation eingerichtet
Die bei einer dialogfreien Installation verwendeten Installationsoptionen
stammen aus einer Antwortdatei. Die Antwortdatei wird erstellt, indem das
Setup-Programm von Adaptive Server Anywhere mit der Option –r
ausgeführt wird. Eine dialogfreie Installation wird durch Ausführen von
Setup mit der Option –s ausgeführt.
Verwenden Sie keine Durchsuchungsfunktionen
Wenn Sie eine dialogfreie Installation erstellen, dürfen Sie die
Schaltflächen "Durchsuchen" nicht verwenden. Die Ergebnisse von
Durchsuchungsfunktionen können fehlerhaft sein.
v So wird eine dialogfreie Installation eingerichtet:
1 (Fakultativ) Entfernen Sie vorhandene Installationen von Adaptive
Server Anywhere.
2 Öffnen Sie eine Systembefehlszeile und wechseln Sie in das Verzeichnis
mit den Installations-Dateien (die setup.exe, setup.ins usw. enthalten).
3 Installieren Sie die Software im Modus "Record" (Aufzeichnen).
Geben Sie folgenden Befehl ein:
setup –r

Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
Dialogfreie Installation ausführen
Mit diesem Befehl wird das Setup-Programm von Adaptive Server
Anywhere ausgeführt und aus Ihrer Auswahl bei den Optionen eine
Antwortdatei erstellt. Die Antwortdatei erhält den Namen setup.iss und
befindet sich im Windows-Verzeichnis. Diese Datei enthält die
Antworten, die Sie während der Installation in den Dialogfeldern
gegeben haben.
Wenn das Programm im Modus "Record" (Aufzeichnen) ausgeführt
wird, schlägt es nicht vor, das Betriebssystem neu zu starten, auch wenn
ein Neustart erforderlich ist.
4 Installieren Sie Adaptive Server Anywhere mit den Optionen und
Einstellungen, die beim Bereitstellen von Adaptive Server Anywhere
auf dem Computer des Endbenutzers für die Benutzung mit Ihrer
Anwendung eingerichtet werden sollen. Während der dialogfreien
Installation können Pfade aufgehoben werden.
Ihr eigenes Installationsprogramm muss die dialogfreie Installation von
Adaptive Server Anywhere mit der Option –s aufrufen. In diesem Abschnitt
wird beschrieben, wie eine dialogfreie Installation verwendet wird.
v So wird eine dialogfreie Installation verwendet:
1 Fügen Sie den entsprechenden Befehl in Ihre Installationsprozedur ein,
damit die dialogfreie Installation von Adaptive Server Anywhere
ausgeführt wird.
Wenn die Antwortdatei sich im Installations-Verzeichnis befindet,
können Sie die dialogfreie Installation ausführen, indem Sie im
Verzeichnis mit dem Installationsabbilds folgenden Befehl ausführen:
setup –s
Wenn sich die Antwortdatei anderswo befindet, müssen Sie den Pfad
mit der Option –f1 angeben. In der folgenden Befehlszeile darf es keine
Leerstelle zwischen f1 und dem Anführungszeichen geben.
setup –s –f1"c:\winnt\setup.iss"
Wenn die Installation von einem anderen InstallShield-Skript ausgeführt
werden soll, können Sie folgenden Befehl benutzen:
DoInstall(
"Pfad_des_ASA_Installationsabbilds\SETUP.INS",
"-s", WAIT );
423

Dialogfreie Installation für die Systemeinführung
SMS-Installation
424
Zum Aufheben der Pfade für das Adaptive Server Anywhere-
Verzeichnis und für das gemeinsam genutzte Verzeichnis können Sie
Optionen benutzen:
setup TARGET_DIR=Verzeichnisname
SHARED_DIR=Gem_Verzeichnis –s
Die Argumente TARGET_DIR und SHARED_DIR müssen allen
anderen Optionen vorangestellt werden.
2 Prüfen Sie, ob der Zielcomputer neu gestartet werden muss.
Setup erstellt eine Datei namens silent.log im Zielverzeichnis. Diese
Datei enthält nur einen Abschnitt mit der Bezeichnung ResponseResult
und der folgenden Zeile:
Reboot=Wert
Diese Zeile gibt an, ob der Zielcomputer neu gestartet werden muss,
damit die Installation abgeschlossen wird. Mögliche Werte sind 0 bzw.
1, mit folgender Bedeutung:
♦ Reboot=0 Neustart nicht erforderlich.
♦ Reboot=1 Die Option BATCH_INSTALL war während der
Installation aktiviert und der Zielcomputer muss neu gestartet
werden. Die Installationsprozedur, die die dialogfreie Installation
aufgerufen hat, ist verantwortlich für die Prüfung des Eintrags
"Reboot" und ggf. für den Neustart des Zielcomputers.
3 Prüfen Sie, ob das Setup ordnungsgemäß abgeschlossen wurde.
Setup erstellt eine Datei namens setup.log im Verzeichnis mit der
Antwortdatei. Die Logdatei enthält einen Bericht über die dialogfreie
Installation. Der letzte Abschnitt dieser Datei heißt ResponseResult und
enthält die folgende Zeile:
ResultCode=Wert
Diese Zeile gibt an, ob die Installation erforderlich war. Ein Nicht-Null-
ResultCode gibt an, dass während der Installation ein Fehler aufgetreten
ist. Eine Beschreibung der Fehlercodes finden Sie in der Dokumentation
zu InstallShield.
Microsoft System Management Server (SMS) erfordert eine dialogfreie
Installation, die den Zielcomputer nicht neu startet. Die dialogfreie
Installation von Adaptive Server Anywhere startet den Computer nicht neu.

Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
Ihr SMS-Distributionspaket müsste eine Antwortdatei, das
Installationsabbild und die Paket-Definitionsdatei asa8.pdf enthalten (auf
der Adaptive Server Anywhere-CD-ROM im Ordner \Extras). Die Setup-
Befehlszeile in der PDF-Datei enthält die folgenden Optionen:
♦ Die Option –s für eine dialogfreie Installation
♦ Die Option –SMS zur Angabe, dass die Installation von SMS ausgelöst
wird
♦ Die Option –m, damit eine MIF-Datei erzeugt wird. Die MIF-Datei wird
von SMS verwendet um festzustellen, ob die Installation erfolgreich
war.
425

Clientanwendungen im System bereitstellen
Clientanwendungen im System bereitstellen
426
Um eine Clientanwendung im System bereitzustellen, die mit einem
Netzwerk-Datenbankserver betrieben wird, müssen Sie jedem Endbenutzer
folgende Elemente zur Verfügung stellen:
♦ Clientanwendung Die Anwendungssoftware selbst ist von der
Datenbanksoftware unabhängig und wird hier nicht beschrieben.
♦ Datenbank-Interface-Dateien Die Clientanwendung benötigt die
Dateien für die Datenbank-Schnittstelle, die sie benutzt (ODBC, JDBC,
Embedded SQL oder Open Client).
♦ Verbindungsinformationen Jede Clientanwendung benötigt
Verbindungsinformationen für die Datenbank.
Die erforderlichen Interface-Dateien und Verbindungsinformationen richten
sich nach der Schnittstelle, die von Ihrer Anwendung benutzt wird. Jede
Schnittstelle wird in den folgenden Abschnitten im Einzelnen beschrieben.
Die einfachste Methode zur Bereitstellung von Clients ist es, die
mitgelieferten InstallShield-Objekte zu verwenden. Weitere Hinweise finden
Sie unter "InstallShield-Objekte und Vorlagen zum Bereitstellen verwenden"
auf Seite 420.
OLE DB- und ADO-Clients bereitstellen
Die einfachste Art, OLE DB-Clientbibliotheken bereitzustellen, ist es, die
InstallShield-Objekte und Vorlagen zu verwenden. Hinweise dazu finden Sie
unter "InstallShield-Objekte und Vorlagen zum Bereitstellen verwenden" auf
Seite 420. Dieser Abschnitt beschreibt die Dateien, die Sie den Endbenutzern
bereitstellen müssen, wenn Sie vorhaben, Ihre eigene Installation zu
erstellen.
Jeder OLE DB-Clientrechner muss folgende Elemente aufweisen:
♦ Eine funktionierende OLE DB-Installation OLE DB-Dateien und
Anweisungen für ihre Verteilung können bei der Microsoft Corporation
bezogen werden. Sie werden hier nicht im Einzelnen beschrieben.
♦ Der Adaptive Server Anywhere OLE DB-Provider Die folgende
Tabelle enthält die Dateien, die für den Adaptive Server Anywhere OLE
DB-Provider erforderlich sind. Diese Dateien sollten in nur einem
Verzeichnis abgelegt werden. Die Adaptive Server Anywhere-
Installation platziert sie alle in das Betriebssystem-Unterverzeichnis des
SQL Anywhere-Installationsverzeichnisses (zum Beispiel: win32).

Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
Beschreibung Windows Windows CE
OLE DB-Treiberdatei dboledb8.dll dboledb8.dll
OLE DB-Treiberdatei dboledba8.dll dboledba8.dll
Sprachen-
Ressourcebibliothek
ODBC-Clients im System bereitstellen
dblgen8.dll dblgen8.dll
Dialogfeld "Verbinden" dbcon8.dll Nicht zutreffend
OLE DB-Provider benötigen viele Registrierungseinträge. Sie können
diese erstellen, indem Sie die DLLs mit dem Dienstprogramm regsvr32
unter Windows oder dem Dienstprogramm regsvrce unter Windows CE
selbst registrieren.
$ Weitere Hinweise finden Sie unter "Datenbanken für Windows CE
erstellen" auf Seite 300 der Dokumentation ASA
Datenbankadministration und "ODBC-Anwendungen unter Windows
CE verknüpfen" auf Seite 281.
Die einfachste Art, ODBC-Clients bereitzustellen, ist es, die InstallShield-
Objekte und Vorlagen zu verwenden. Hinweise dazu finden Sie unter
"InstallShield-Objekte und Vorlagen zum Bereitstellen verwenden" auf
Seite 420.
Jeder ODBC-Clientrechner muss folgende Elemente aufweisen:
♦ Eine funktionierende ODBC-Installation ODBC-Dateien und
Anweisungen für ihre Verteilung können bei der Microsoft Corporation
bezogen werden. Sie werden hier nicht im Einzelnen beschrieben.
Microsoft liefert den ODBC-Treibermanager für Windows-
Betriebssysteme. SQL Anywhere Studio enthält einen ODBC Driver
Manager für UNIX. Es gibt keinen ODBC-Treibermanager für Windows
CE.
ODBC-Anwendungen können ohne den Treibermanager laufen. Auf
Plattformen, für die ein ODBC-Treibermanager verfügbar ist, ist das
nicht zu empfehlen.
427

Clientanwendungen im System bereitstellen
428
Falls erforderlich ODBC aktualisieren
Das SQL Anywhere Setup-Programm aktualisiert alte Installationen
der Microsoft Data Access-Komponenten, einschließlich ODBC.
Wenn Sie Ihre eigene Anwendung bereitstellen, müssen Sie
sichergehen, dass die ODBC-Installation den Anforderungen Ihrer
Anwendung entspricht.
♦ Der ODBC-Treiber für Adaptive Server Anywhere Dies ist die Datei
dbodbc8.dll mit ihren Zusatzdateien.
$ Weitere Hinweise finden Sie unter "Erforderliche Dateien für den
ODBC-Treiber" auf Seite 428.
♦ Verbindungsinformation Die Clientanwendung muss Zugriff auf die
Daten haben, aus denen sie die Informationen für die Verbindung mit
dem Server bezieht. Diese Informationen sind normalerweise in der
ODBC-Datenquelle enthalten.
Erforderliche Dateien für den ODBC-Treiber
Hinweise
Die folgende Tabelle zeigt die Dateien, die für einen funktionierenden
ODBC-Treiber von Adaptive Server Anywhere erforderlich sind. Diese
Dateien sollten in nur einem Verzeichnis abgelegt werden. Die Adaptive
Server Anywhere-Installation platziert sie alle in das Betriebssystem-
Unterverzeichnis des SQL Anywhere-Installationsverzeichnisses (zum
Beispiel: win32).
Beschreibung Windows Windows CE UNIX
ODBC-Treiber dbodbc8.dll dbodbc8.dll libdbodbc8.so
libdbtasks8.so
Sprachen-
Ressourcebibliothek
dblgen8.dll dblgen8.dll dblgen8.res
Dialogfeld
"Verbinden"
dbcon8.dll Nicht zutreffend Nicht zutreffend
♦ Der Endbenutzer muss über eine funktionierende ODBC-Installation mit
einem Treibermanager verfügen. Anweisungen für die Bereitstellung
von ODBC finden Sie im Microsoft ODBC SDK.
♦ Das Dialogfeld "Verbinden" ist erforderlich, wenn die Endbenutzer
eigene Datenquellen erstellen sollen, bei der Verbindungsaufnahme
Benutzer-IDs und Kennwörter eingeben müssen oder wenn Das
Dialogfeld aus anderen Gründen angezeigt werden muss.

Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
ODBC-Treiber konfigurieren
Windows
♦ Der ODBC-Übersetzer ist nur erforderlich, wenn Ihre Anwendung eine
Umwandlung von OEM in ANSI durchführt.
$ Weitere Hinweise finden Sie unter "Datenbanken für Windows CE
erstellen" auf Seite 300 der Dokumentation ASA
Datenbankadministration, und "ODBC-Anwendungen unter Windows
CE verknüpfen" auf Seite 281.
♦ Bei Anwendungen mit mehrfachen Threads unter UNIX benutzen Sie
libdbodbc8_r.so und libdbtasks8_r.so.
Das Setup-Programm muss nicht nur die Dateien des ODBC-Treibers auf die
Festplatte kopieren, sondern auch eine Reihe von Einträgen in der
Registrierung vornehmen, damit der ODBC-Treiber richtig installiert wird.
Das Setup-Programm von Adaptive Server Anywhere führt Änderungen in
der Systemregistrierung durch, um den ODBC-Treiber anzumelden und zu
konfigurieren. Wenn Sie ein Setup-Programm für die Endbenutzer erstellen,
müssen Sie dieselben Einstellungen vornehmen.
Sie können das Dienstprogramm regedit verwenden, um die
Registrierungseinträge anzuzeigen.
Der ODBC-Treiber von Adaptive Server Anywhere wird im System durch
eine Gruppe von Registrierungseinträgen im folgenden
Registrierungsschlüssel angemeldet:
HKEY_LOCAL_MACHINE\
SOFTWARE\
ODBC\
ODBCINST.INI\
Adaptive Server Anywhere 8.0
Folgende Werte werden gesetzt:
Name des Wertes Typ des Wertes Daten des Wertes
Driver Zeichenfolge Pfad\dbodbc8.dll
Setup Zeichenfolge Pfad\dbodbc8.dll
Es gibt auch einen Registrierungseintrag im folgenden Schlüssel:
HKEY_LOCAL_MACHINE\
SOFTWARE\
ODBC\
ODBCINST.INI\
ODBC Drivers
429

Clientanwendungen im System bereitstellen
ODBC-Treiber von
Drittanbietern
430
Der Wert ist wie folgt:
Name des Wertes Typ des
Wertes
Verbindungsinformationen bereitstellen
Arten von
Datenquellen
Adaptive Server Anywhere 8.0 Zeichenfolge Installed
Daten des Wertes
Wenn Sie einen ODBC-Treiber eines Drittanbieters auf einem anderen
Betriebssystem als Windows verwenden, finden Sie in der Dokumentation
dieses ODBC-Treibers Hinweise dazu, wie der ODBC-Treiber zu
konfigurieren ist.
Die Verbindungsinformationen für den ODBC-Client werden im
Allgemeinen in Form einer ODBC-Datenquelle im System bereitgestellt. Die
Bereitstellung einer ODBC-Datenquelle erfolgt auf folgende Weise:
♦ Programmgesteuert Fügen Sie die Beschreibung für eine Datenquelle
in die Registrierung des Endbenutzers oder in die ODBC-
Initialisierungsdateien ein.
♦ Manuell Übergeben Sie den Endbenutzern Anweisungen, damit sie auf
ihrem Rechner eine geeignete Datenquelle einrichten können.
Sie können eine Datenquelle manuell mit dem ODBC Administrator
erstellen, indem Sie das Register Benutzer-DSN oder System-DSN
verwenden. Der ODBC-Treiber von Adaptive Server Anywhere zeigt
den Konfigurationsdialog für die Eingabe der Einstellungen an.
Einstellungen für die Datenquelle enthalten den Standort der
Datenbankdatei, den Namen des Datenbankservers sowie Startparameter
und andere Optionen.
In diesem Abschnitt finden Sie die Informationen, die Sie für beide Ansätze
benötigen.
Es gibt drei Arten von Datenquellen: Benutzerdatenquellen,
Systemdatenquellen und Dateidatenquellen.
Die Definitionen der Benutzerdatenquellen werden in der Registrierung im
Abschnitt für den aktuell im System angemeldeten Benutzer gespeichert.
Systemdatenquellen hingegen stehen allen Benutzern und Diensten von
Windows zur Verfügung, wobei die Dienste auch aktiv sind, wenn kein
Benutzer angemeldet ist. Bei einer richtig konfigurierten Systemdatenquelle
"MeineAnwendung" kann jeder Benutzer diese ODBC-Verbindung
verwenden, indem er "DSN=MeineAnwendung" in der ODBC-
Verbindungszeichenfolge eingibt.

Registrierungseinträge
für die
Datenquelle
Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
Dateidatenquellen werden nicht in der Registrierung gespeichert, sondern in
einem speziellen Verzeichnis. Eine Verbindungszeichenfolge muss einen
FileDSN-Verbindungsparameter liefern, um eine Dateidatenquelle benutzen
zu können.
Jede Benutzerdatenquelle ist im System über Registrierungseinträge
angemeldet.
Sie müssen eine Gruppe von Registrierungswerten in einem bestimmten
Registrierungsschlüssel angeben. Für Benutzerdatenquellen ist der Schlüssel
wie folgt:
HKEY_CURRENT_USER\
SOFTWARE\
ODBC\
ODBC.INI\
Benutzerdatenquellenname
Für Systemdatenquellen ist der Schlüssel wie folgt:
HKEY_LOCAL_MACHINE\
SOFTWARE\
ODBC\
ODBC.INI\
Systemdatenquellenname
Der Schlüssel enthält eine Gruppe von Registrierungswerten, die jeweils
einem Verbindungsparameter entsprechen. Zum Beispiel enthält der
Schlüssel "ASA 8.0 Sample", der der Datenquelle der Beispieldatenbank von
ASA 8.0 entspricht, folgende Einstellungen:
Name des Wertes Typ des
Wertes
Autostop Zeichenfolge yes
Daten des Wertes
DatabaseFile Zeichenfolge Pfad\asademo.db
Description Zeichenfolge Adaptive Server Anywhere Beispieldatenbank
Driver String Pfad\win32\dbodbc8.dll
PWD String sql
Start String Pfad\win32\dbeng8.exe -c 8m
UID String dba
In diesen Einträgen steht Pfad für das Installationsverzeichnis von Adaptive
Server Anywhere.
Außerdem müssen Sie die Datenquelle der Liste von Datenquellen in der
Registrierung hinzufügen. Für Benutzerdatenquellen benutzen Sie folgenden
Schlüssel:
431

Clientanwendungen im System bereitstellen
Erforderliche und
fakultative
Verbindungsparameter
432
HKEY_CURRENT_USER\
SOFTWARE\
ODBC\
ODBC.INI\
ODBC Data Sources
Für Systemdatenquellen benutzen Sie folgenden Schlüssel:
HKEY_LOCAL_MACHINE\
SOFTWARE\
ODBC\
ODBC.INI\
ODBC Data Sources
Der Wert verknüpft jede Datenquelle mit einem ODBC-Treiber. Der Name
des Wertes ist der Datenquellenname, und die Daten des Wertes sind der
Name des ODBC-Treibers. Beispiel: Die Benutzerdatenquelle, die von
Adaptive Server Anywhere installiert wird, heißt "ASA 8.0 Sample" und hat
folgenden Wert:
Name des Wertes Typ des
Wertes
Daten des Wertes
ASA 8.0 Sample Zeichenfolge Adaptive Server Anywhere 8.0
Vorsicht: ODBC-Einstellungen können leicht angezeigt werden
Die Konfiguration von Benutzerdatenquellen kann vertrauliche
Datenbankeinstellungen enthalten, wie z.B. Benutzerkennungen und
Kennwörter. Diese Einstellungen werden in der Registrierung in reiner
Textform gespeichert und können mit Registrierungseditoren von
Windows regedit.exe oder regedt32.exe angezeigt werden. Diese Editoren
sind in jedem Windows-System automatisch installiert. Sie können
Kennwörter verschlüsseln oder von Benutzern verlangen, sie bei der
Aufnahme der Verbindung einzugeben.
Sie können den Datenquellennamen in einem ODBC-Konfigurationseintrag
in folgender Weise definieren:
DSN=Benutzerdatenquellenname
Wenn ein DSN-Parameter in der Verbindungszeichenfolge geliefert wird,
werden erst die aktuellen Definitionen von Benutzerdatenquellen in der
Registrierung durchsucht, dann die Systemdatenquellen. Dateidatenquellen
werden nur durchsucht, wenn "FileDSN" in der Zeichenfolge für die ODBC-
Verbindung geliefert wird.
Die folgende Tabelle zeigt die Auswirkungen auf Benutzer und Entwickler,
wenn eine Datenquelle vorhanden ist und in die Verbindungszeichenfolge
der Anwendung als Parameter DSN oder FileDSN einbezogen ist.

Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
Datenquelle Eingabe in der
Verbindungszeichenfolge
Enthält den ODBC-
Treibernamen und –
Speicherort, den Namen
der Datenbankdatei, des
Datenbankservers, die
Startparameter sowie
Benutzer-ID und
Kennwort
Enthält nur Namen und
Speicherort des ODBC-
Treibers
Keine zusätzlichen
Informationen
Name der Datenbankdatei
oder des Datenbankservers;
fakultativ die
Benutzerkennung und das
Kennwort
Nicht vorhanden Der Name des zu
verwendenden ODBC-
Treibers in folgendem
Format:
Driver={ODBC
Treibername}
Ebenfalls: Name der
Datenbank, Datenbankdatei
oder Datenbankserver;
fakultativ andere
Verbindungsparameter
wie Benutzerkennung und
Kennwort
Eingabe durch den
Benutzer
Keine zusätzlichen
Informationen
Benutzer-ID und
Kennwort, wenn nicht
im DSN oder in der
Zeichenfolge für die
ODBC-Verbindung
angegeben.
Benutzerkennung und
Kennwort, wenn nicht
in der Zeichenfolge für
die ODBC-Verbindung
geliefert
$ Weitere Hinweise zu ODBC-Verbindungen und Konfigurationen finden
Sie unter
♦ "Verbindung mit einer Datenbank herstellen" auf Seite 41 der
Dokumentation ASA Datenbankadministration.
♦ Open Database Connectivity (ODBC) SDK von Microsoft
Bereitstellen von Embedded SQL-Clients
Die einfachste Art, Embedded SQL-Clients bereitzustellen, ist es, die
InstallShield-Objekte und Vorlagen zu verwenden. Hinweise dazu finden Sie
unter "InstallShield-Objekte und Vorlagen zum Bereitstellen verwenden" auf
Seite 420.
433

Clientanwendungen im System bereitstellen
434
Die Bereitstellung von Embedded SQL-Clients im System umfasst folgende
Aufgaben:
♦ Installierte Dateien Jeder Clientrechner muss die erforderlichen Dateien
für eine Adaptive Server Anywhere Embedded SQL-Clientanwendung
enthalten.
♦ Verbindungsinformation Die Clientanwendung muss Zugriff auf die
Daten haben, aus denen sie die Informationen für die Verbindung mit
dem Server bezieht. Diese Informationen können in die ODBC-
Datenquelle aufgenommen werden.
Dateien für Embedded SQL-Clients installieren
Hinweise
Die folgende Tabelle zeigt, welche Dateien für Embedded SQL Clients
benötigt werden.
Beschreibung Windows UNIX
Schnittstellenbibliothek dblib8.dll libdblib8.so,
libdbtasks8.so
Sprachen-
Ressourcebibliothek
IPX
Netzwerkkommunikation
dblgen8.dll dblgen8.res
dbipx8.dll Nicht zutreffend
Dialogfeld "Verbinden" dbcon8.dll Nicht zutreffend
♦ Die Netzwerkport-DLL ist nicht erforderlich, wenn der Client nur mit
dem Personal Datenbankserver arbeitet.
♦ Wenn die Clientanwendung eine ODBC-Datenquelle benutzt, um die
Verbindungsparameter zu speichern, muss der Endbenutzer über eine
funktionierende ODBC-Installation verfügen. Anweisungen für die
Bereitstellung von ODBC finden Sie im Microsoft ODBC SDK.
$ Weitere Hinweise zur Bereitstellung von ODBC-Informationen im
System finden Sie unter "ODBC-Clients im System bereitstellen" auf
Seite 427.
♦ Das Dialogfeld "Verbindung" ist erforderlich, wenn die Endbenutzer
eigene Datenquellen erstellen, bei der Verbindungsaufnahme Benutzer-
IDs und Kennwörter eingeben müssen oder wenn das Dialogfeld aus
anderen Gründen angezeigt werden muss.
♦ Bei Anwendungen mit mehrfachen Threads unter UNIX benutzen Sie
libdbodbc8_r.so und libdbtasks8_r.so.

Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
Verbindungsinformationen
Verbindungsinformation Die Bereitstellung von Embedded SQL-
Verbindungsinformationen erfolgt auf folgende Weise:
♦ Manuell Übergeben Sie den Endbenutzern Anweisungen, damit sie auf
ihrem Rechner eine geeignete Datenquelle einrichten können.
♦ Datei Übergeben Sie den Endbenutzern eine Datei, die
Verbindungsinformationen in einem Format enthält, das Ihre
Anwendung lesen kann.
♦ ODBC-Datenquelle Sie können die ODBC-Datenquelle verwenden, um
darin die Verbindungsinformationen zu speichern. In diesem Fall
benötigen Sie eine Teilgruppe der ODBC-Dateien von Microsoft.
Hinweise finden Sie unter "ODBC-Clients im System bereitstellen" auf
Seite 427.
♦ Hartcodiert Sie können Verbindungsinformationen in der Anwendung
programmieren. Dies ist eine unflexible Methode, die beispielsweise bei
einem Upgrade von Datenbanken umfassende Neuprogrammierungen
erforderlich macht.
JDBC-Clients im System bereitstellen
Zusätzlich zur Java-Laufzeitumgebung (Java Runtime Environment) muss
jeder JDBC-Client auch über den JDBC-Treiber jConnect von Sybase oder
die JDBC-ODBC-Brücke verfügen.
$ Hinweise zur Bereitstellung von jConnect finden Sie unter
http://manuals.sybase.com/onlinebooks/group-jc/jcg0420e/ auf der Sybase-
Website.
Zur Bereitstellung der JDBC-ODBC-Brücke müssen die folgenden Dateien
mitgeliefert werden:
♦ jodbc.jar Diese muss sich im Classpath der Anwendung befinden.
♦ dbjodbc8.dll Diese muss sich im Systempfad befinden. In UNIX- oder
Linux-Umgebungen ist die Datei eine gemeinsam genutzte Bibliothek
(dbjodbc8.so).
♦ Die ODBC-Treiberdateien. Weitere Hinweise finden Sie unter
"Erforderliche Dateien für den ODBC-Treiber" auf Seite 428.
Ihre Java-Anwendung benötigt einen URL, um sich mit der Datenbank zu
verbinden. Dieser URL gibt den Treiber, den zu verwendenden Rechner und
den Port an, auf dem der Datenbankserver auf Daten wartet.
435

Clientanwendungen im System bereitstellen
436
$ Weitere Hinweise zu URL finden Sie unter "Einem Server einen URL
liefern" auf Seite 152.
Open Client-Anwendungen im System bereitstellen
Um Open Client-Anwendungen bereitzustellen, muss auf jedem Rechner
Sybase Open Client installiert sein. Sie müssen die Open Client-Software
getrennt bei Sybase erwerben. Sie enthält eigene Installationsanweisungen.
$ Verbindungsinformationen für Open Client-Clients sind in der Interface-
Datei zu finden. Hinweise zur Interface-Datei finden Sie in der Open Client-
Dokumentation und unter "Open Server konfigurieren" auf Seite 122 der
Dokumentation ASA Datenbankadministration.

Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
Tools zur Verwaltung bereitstellen
Interactive SQL
bereitstellen
Abhängig von Ihrer Lizenzvereinbarung können Sie eine Reihe von
Verwaltungstools wie Interactive SQL, Sybase Central und das
Überwachungsdienstprogramm dbconsole bereitstellen.
Die einfachste Methode zur Bereitstellung von Verwaltungstools ist es, die
mitgelieferten InstallShield-Objekte zu verwenden. Weitere Hinweise finden
Sie unter "InstallShield-Objekte und Vorlagen zum Bereitstellen verwenden"
auf Seite 420.
Wenn Ihre Kundenanwendung auf Rechnern mit begrenzten Ressourcen
läuft, sollten Sie die C-Version von Interactive SQL (dbisqlc.exe) an Stelle
der Standardversion bereitstellen (dbisql.exe und die dazugehörigen Java-
Klassen).
Das dbisqlc-Programm erfordert die clientseitigen Embedded SQL-
Standardbibliotheken.
$ Hinweise über die Systemanforderungen von Verwaltungstools finden
Sie unter "Systemvoraussetzungen für das Administrationstool" auf
Seite 153 der Dokumentation SQL Anywhere Studio Erste Orientierung.
437

Datenbankserver im System bereitstellen
Datenbankserver im System bereitstellen
438
Sie können einen Datenbankserver im System bereitstellen, indem Sie das
Setup-Programm für das SQL Anywhere Studio den Endbenutzern
übergeben. Wenn der Endbenutzer die richtigen Installationsoptionen wählt,
verfügt er garantiert über alle erforderlichen Dateien.
Die einfachste Methode zur Bereitstellung eines Personal Datenbankservers
oder eines Netzwerk-Datenbankserver ist es, die mitgelieferten InstallShield-
Objekte zu verwenden. Weitere Hinweise finden Sie unter "InstallShield-
Objekte und Vorlagen zum Bereitstellen verwenden" auf Seite 420.
Um einen Datenbankserver zu betreiben, müssen Sie eine Gruppe von
Dateien installieren. Die Dateien werden in der folgenden Tabelle angeführt.
Die Weitergabe dieser Dateien unterliegt den Bestimmungen der
Lizenzvereinbarung. Sie müssen vorher feststellen, ob Sie das Recht haben,
die Dateien des Datenbankservers weiterzugeben.
Windows UNIX NetWare
dbeng8.exe dbeng8 Nicht zutreffend
dbsrv8.exe dbsrv8 dbsrv8.nlm
dbserv8.dll libdbserv8.so,
libdbtasks8_r.so
dbserv8.dll dbserv8.so,
libdbtasks8.so
dblgen8.dll oder
dblgde8.dll
dbjava8.dll (1)
Nicht zutreffend
Nicht zutreffend
dblgen8.res dblgen8.res
libdbjava8.so (1)
dbjava8.nlm (1)
dbctrs8.dll Nicht zutreffend Nicht zutreffend
dbextf.dll (2)
asajdbc.zip (1,3)
asajrt12.zip (1,3)
classes.zip (1,3)
dbmem.vxd (4)
libdbextf.so (2)
asajdbc.zip (1,3)
asajrt12.zip (1,3)
classes.zip (1,3)
N/A N/A
libunic.dll libunic.so N/A
dbextf.nlm (2)
asajdbc.zip (1,3)
asajrt12.zip (1,3)
classes.zip (1,3)
asa.cvf asa.cvf asa.cvf
Verzeichnis charsets\ charsets/ directory N/A
1. Nur erforderlich, wenn Sie Java in der Datenbank verwenden. Bei Datenbanken, die mit JDK
1.1 initialisiert wurden, stellen Sie asajdbc.zip bereit. Bei Datenbanken, die mit JDK 1.2 oder
JDK 1.3 initialisiert wurden, stellen Sie asajrt13.zip bereit.

Hinweise
Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
2. Nur erforderlich, wenn Sie erweiterte Systemprozeduren und Funktionen benutzen (xp_).
3. So installieren, dass die Klassen in dieser Datei über die Umgebungsvariable CLASSPATH
gefunden werden.
4. Erforderlich auf Windows 95/98/Me, wenn die dynamische Cachebelegung verwendet wird.
♦ Je nach Konfiguration müssen Sie den Personal Datenbankserver
(dbeng8) oder den Netzwerk-Datenbankserver (dbsrv8) im System
bereitstellen.
♦ Die Java DLL (dbjava8.dll) ist nur erforderlich, wenn der
Datenbankserver die Funktionalität von Java in der Datenbank
verwenden soll.
♦ Die Tabelle enthält keine Dateien, die für das Ausführung von
Dienstprogrammen wie dbbackup erforderlich sind.
$ Hinweise zur Bereitstellung von Datenbank-Dienstprogrammen im
System finden Sie unter "Tools zur Verwaltung bereitstellen" auf
Seite 437.
♦ Die zip-Dateien sind nur für Anwendungen erforderlich, die Java in der
Datenbank verwenden und werden an einem Standort in der
Umgebungsvariable CLASSPATH auf dem Rechner des Benutzers
installiert.
Datenbanken im System bereitstellen
Eine Datenbankdatei wird im System bereitgestellt, indem Sie die
Datenbankdatei auf der Festplatte des Endbenutzers installieren.
Wenn der Datenbankserver sauber herunterfährt, brauchen Sie mit der
Datenbankdatei kein Transaktionslog bereitzustellen. Wenn der Endbenutzer
die Datenbank startet, wird ein neues Transaktionslog erstellt.
Für Anwendungen mit SQL Remote muss die Datenbank in einem ordentlich
synchronisierten Zustand erstellt werden und daher wird kein
Transaktionslog benötigt. Sie können dafür das Extraktionsdienstprogramm
verwenden.
Datenbanken auf schreibgeschützten Datenträgern bereitstellen
Sie können Datenbanken auf schreibgeschützten Datenträgern verteilen, wie
etwa CD-ROM, sofern Sie sie im schreibgeschützten Modus oder mit einer
Write-Datei ausführen.
$ Weitere Hinweise zum Ausführen von Datenbanken im
schreibgeschützten Modus finden Sie unter "–r-Serveroption" auf Seite 166
der Dokumentation ASA Datenbankadministration.
439

Datenbankserver im System bereitstellen
440
Damit Änderungen an Adaptive Server Anywhere-Datenbanken
vorgenommen werden können, die auf schreibgeschützten Datenträgern
geliefert werden, wie etwa CD-ROM, können Sie eine Write-Datei
verwenden. In der Write-Datei werden Änderungen gespeichert, die in einer
schreibgeschützten Datenbank durchgeführt werden. Sie befindet sich auf
einem Datenträger, der Schreiben und Lesen zulässt, z.B. einer Festplatte.
In diesem Fall wird die Datenbankdatei auf der CD-ROM gespeichert, die
Write-Datei hingegen auf der Festplatte. Die Verbindung wird mit der Write-
Datei aufgenommen, die auf der Festplatte ein Transaktionslog führt.
$ Weitere Hinweise zu Write-Dateien finden Sie unter "Mit Write-
Dateien arbeiten" auf Seite 247 der Dokumentation ASA
Datenbankadministration.

Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
Eingebettete Datenbankanwendungen im
System bereitstellen
In diesem Abschnitt finden Sie Informationen über die Bereitstellung von
eingebetteten Datenbanken, bei denen die Anwendung und die Datenbank
auf demselben Rechner untergebracht sind.
Eine eingebettete Datenbankanwendung enthält folgende Komponenten:
♦ Datenbankserver Der Adaptive Server Anywhere Personal
Datenbankserver.
$ Hinweise zur Bereitstellung von Datenbankservern finden Sie
unter "Datenbankserver im System bereitstellen" auf Seite 438.
♦ SQL Remote Wenn Ihre Anwendung die Replikation mit SQL Remote
benutzt, müssen Sie das Deployment von SQL Remote Message Agent
vornehmen.
♦ Die Datenbank Sie müssen eine Datenbankdatei im System
bereitstellen, die die von der Anwendung benutzten Daten aufnimmt.
Personal Server im System bereitstellen
Wenn Sie eine Anwendung im System bereitstellen, die den Personal Server
benutzt, müssen Sie sowohl die Komponenten der Clientanwendung
bereitstellen, als auch die Komponenten des Datenbankservers.
Die Sprachen-Ressourcebibliothek (dblgen8.dll) wird vom Client und vom
Server gemeinsam genutzt. Sie brauchen nur ein Exemplar dieser Datei.
Es wird empfohlen, dass Sie die Installationsvorgaben von Adaptive Server
Anywhere einhalten und die Dateien für Client und Server in demselben
Verzeichnis installieren.
Beachten Sie, dass Sie die Java zip-Dateien und die Java-DLL bereitstellen
müssen, wenn Ihre Anwendung Java in der Datenbank benutzt.
Datenbank-Dienstprogramme bereitstellen
Wenn Sie Datenbank-Dienstprogramme (wie z.B. dbbackup.exe) gemeinsam
mit Ihrer Anwendung im System bereitstellen müssen, brauchen Sie die
Programmdatei des Dienstprogramms mit folgenden zusätzlichen Dateien:
441

Eingebettete Datenbankanwendungen im System bereitstellen
Hinweise
442
Beschreibung Windows UNIX
Bibliothek der Datenbanktools Dbtool8.dll libdbtools8.so,
libdbtasks8.so
Zusätzliche Bibliothek dbwtsp8.dll Libdbwtsp8.so
Sprachen-Ressourcebibliothek dblgen8.dll dblgen8.res
Verbindungsdialog (nur dbisqlc) dbcon8.dll
♦ Die Datenbanktools sind Embedded SQL-Anwendungen. Sie müssen die
für diese Anwendungen erforderlichen Dateien bereitstellen. Siehe dazu
die Liste in "Bereitstellen von Embedded SQL-Clients" auf Seite 433.
♦ Bei Anwendungen mit mehrfachen Threads unter UNIX benutzen Sie
libdbodbc8_r.so und libdbtasks8_r.so.
SQL Remote im System bereitstellen
Wenn Sie den Nachrichtenagenten von SQL Remote im System bereitstellen,
müssen folgende Dateien installiert werden:
Beschreibung Windows UNIX
Nachrichtenagent dbremote.exe dbremote
Bibliothek der Datenbanktools dbtool8.dll libdbtools8.so,
libdbtasks8.so
Zusätzliche Bibliothek dbwtsp8.dll libdbwtsp8.so
Sprachen-Ressourcebibliothek dblgen8.dll dblgen8.res
Bibliothek für VIM-
Nachrichtenverbindungen 1
Bibliothek für SMTP-
Nachrichtenverbindungen 1
Bibliothek für FILE-
Nachrichtenverbindungen 1
Bibliothek für FTP-
Nachrichtenverbindungen 1
Bibliothek für MAPI-
Nachrichtenverbindungen 1
dbvim8.dll
dbsmtp8.dll
dbfile8.dll libdbfile8.so
dbftp8.dll
dbmapi8.dll
Schnittstellenbibliothek dblib8.dll
1
Stellen Sie nur die Bibliothek für die Nachrichtenverbindung bereit, die die Anwendung
benutzen wird.

Kapitel 12 Deployment: Datenbanken und Anwendungen im System bereitstellen
Es wird empfohlen, dass Sie die Installationsvorgaben von Adaptive Server
Anywhere einhalten und die Dateien für SQL Remote in demselben
Verzeichnis installieren wie Adaptive Server Anywhere.
Bei Anwendungen mit mehrfachen Threads unter UNIX benutzen Sie
libdbodbc8_r.so und libdbtasks8_r.so.
443

Eingebettete Datenbankanwendungen im System bereitstellen
444

KAPITEL 13
Fehlermeldungen des SQL-Präprozessors
Über dieses
Kapitel
Inhalt
In diesem Kapitel finden Sie eine Liste aller Fehler- und Warnmeldungen des
SQL-Präprozessors.
Thema Seite
Fehlermeldungen des SQL-Präprozessors, sortiert nach
Fehlernummern 446
SQLPP-Fehler 450
445

Fehlermeldungen des SQL-Präprozessors, sortiert nach Fehlernummern
Fehlermeldungen des SQL-Präprozessors,
sortiert nach Fehlernummern
446
Fehlernummer Meldung
2601 "Subskriptionswert %1 zu groß" auf
Seite 464
2602 "Kombinierter Zeiger und Arrays für
Hosttypen nicht zulässig" auf
Seite 455
2603 "Nur eindimensionale Arrays werden
für den 'char'-Typ unterstützt" auf
Seite 463
2604 "VARCHAR-Typ muss eine Länge
haben" auf Seite 454
2605 "Arrays von VARCHAR nicht
unterstützt" auf Seite 454
2606 "VARCHAR-Hostvariable können
keine Zeiger sein" auf Seite 453
2607 "Initialisieren bei der VARCHAR-
Hostvariablen nicht zulässig" auf
Seite 459
2608 "FIXCHAR-Typ muss eine Länge
haben" auf Seite 451
2609 "Arrays werden für FIXCHAR nicht
unterstützt" auf Seite 454
2610 "Arrays dieses Typs werden nicht
unterstützt" auf Seite 455
2611 "Beim Dezimaltyp muss die Anzahl
der Dezimalstellen angegeben
werden" auf Seite 463
2612 "Dezimalzahlen-Arrays sind nicht
zulässig" auf Seite 454
2613 "Unbekannter Hostvariablen-Typ"
auf Seite 453
2614 "Ungültige Ganzzahl" auf Seite 460
2615 "'%1' Hostvariable muss ein C-
Zeichenfolgentyp sein" auf Seite 450

Kapitel 13 Fehlermeldungen des SQL-Präprozessors
Fehlernummer Meldung
2617 "Das Symbol ’%1’ ist bereits
definiert" auf Seite 450
2618 "Ungültiger Typ für SQL-
Anweisungsvariable" auf Seite 461
2619 "Include-Datei '%1' kann nicht
gefunden werden" auf Seite 451
2620 "Hostvariable '%1' ist unbekannt" auf
Seite 457
2621 "Indikatorvariable '%1' ist
unbekannt" auf Seite 459
2622 "Ungültiger Typ für Indikatorvariable
'%1'" auf Seite 460
2623 "Ungültiger Hostvariablen-Typ auf
'%1'" auf Seite 460
2625 "Hostvariable '%1' hat zwei
verschiedene Definitionen" auf
Seite 457
2626 "Anweisung '%1' wurde vorher noch
nicht vorbereitet" auf Seite 463
2627 "Cursor '%1' wurde vorher noch nicht
deklariert" auf Seite 455
2628 "Unbekannte Anweisung '%1'" auf
Seite 465
2629 "Hostvariable für diesen Cursor nicht
zulässig" auf Seite 457
2630 "Hostvariable zweimal angegeben -
bei 'Declare' und bei 'Open'" auf
Seite 458
2631 "Host-Liste oder Using-Klausel für
%1 muss angegeben werden" auf
Seite 461
2633 "Keine INTO-Klausel in SELECT-
Anweisung" auf Seite 462
2634 "Fehlerhafte SQL-Sprachensyntax -
Dies ist eine '%1' Erweiterung" auf
Seite 458
2635 "Fehlerhafte Embedded-SQL-
Sprachensyntax - Dies ist eine '%1'
Erweiterung" auf Seite 458
447

Fehlermeldungen des SQL-Präprozessors, sortiert nach Fehlernummern
448
Fehlernummer Meldung
2636 "Fehlerhafte Embedded-SQL-Syntax"
auf Seite 458
2637 "Fehlendes schließendes
Anführungszeichen für die
Zeichenfolge" auf Seite 461
2639 "Token zu lang" auf Seite 464
2640 "'%1' Hostvariable muss ein
Ganzzahltyp sein" auf Seite 450
2641 "SQLDA muss für DESCRIBE
angegeben werden" auf Seite 462
2642 "Zwei SQLDAs für denselben Typ
angegeben (INTO oder USING)" auf
Seite 453
2646 "Statische Cursor können nicht
beschrieben werden" auf Seite 455
2647 "Makros können nicht neu definiert
werden" auf Seite 453
2648 "Ungültige Arraydimension" auf
Seite 453
2649 "Ungültiger Deskriptor-Index" auf
Seite 459
2650 "Ungültiges Feld für SET
DESCRIPTOR" auf Seite 460
2651 "Feld in SET DESCRIPTOR
Anweisung mehr als einmal
verwendet" auf Seite 456
2652 "Datenwert muss eine Hostvariable
sein" auf Seite 456
2660 "Into-Klausel in 'declare cursor' nicht
zulässig - ignoriert" auf Seite 452
2661 "Nicht erkannte SQL-Syntax" auf
Seite 465
2662 "Unbekannte SQL-Funktion '%1'" auf
Seite 465
2663 "Falsche Anzahl von Parametern für
SQL-Funktion '%1'" auf Seite 466
2664 "Statische Anweisungsnamen
funktionieren nicht richtig, wenn von
2 Threads benutzt" auf Seite 463

Kapitel 13 Fehlermeldungen des SQL-Präprozessors
Fehlernummer Meldung
2665 "Hostvariable ’%1!’ wurde neu
definiert" auf Seite 457
2666 "Erweiterung des Herstellers" auf
Seite 466
2667 "Intermediate-SQL-Merkmal" auf
Seite 459
2668 "Volles SQL-Merkmal" auf Seite 456
2669 "Transact-SQL-Erweiterung" auf
Seite 464
2680 "Kein ’Declare’-Abschnitt und keine
INCLUDE SQLCA Anweisung" auf
Seite 462
2681 "Temporäre Datei kann nicht geöffnet
werden" auf Seite 465
2682 "Fehler beim Lesen der temporären
Datei" auf Seite 456
2683 "Fehler beim Schreiben der
Ausgabedatei" auf Seite 456
2690 "Inkonsistente Zahl von Hostvariable
für diesen Cursor" auf Seite 452
2691 "Inkonsistente Hostvariablentypen für
diesen Cursor" auf Seite 452
2692 "Inkonsistente Indikatorvariable für
diesen Cursor" auf Seite 452
2693 "Merkmal steht bei UltraLite nicht
zur Verfügung" auf Seite 451
2694 "Kein OPEN-Befehl für Cursor '%1'"
auf Seite 462
2695 "Kein FETCH- oder PUT-Befehl für
Cursor '%1'" auf Seite 462
2696 "Hostvariable '%1' wird mit
unterschiedlichen Indikatoren mehr
als einmal verwendet" auf Seite 451
2697 "Größenlimit für long binary/long
varchar ist 65535 für UltraLite" auf
Seite 461
449

SQLPP-Fehler
SQLPP-Fehler
450
In diesem Abschnitt finden Sie die Meldungen, die vom SQL-Präprozessor
generiert werden. Die Meldungen können je nach Einstellung durch die
Befehlszeilenparameter Fehler-, Warnmeldungen oder beides sein.
$ Weitere Hinweise zum SQL-Präprozessor und zu seinen
Befehlszeilenparametern finden Sie unter "SQL-Präprozessor" auf Seite 249.
’%1’ Hostvariable muss ein C-Zeichenfolgentyp sein
Mögliche Ursache
Fehlernummer Fehlertyp
2615 Fehler
Eine C-Zeichenfolge war in einer Embedded SQL-Anweisung erforderlich
(für einen Cursornamen, Optionsnamen etc.), und der übergebene Wert war
keine C-Zeichenfolge.
’%1’ Hostvariable muss ein Ganzzahltyp sein
Mögliche Ursache
Fehlernummer Fehlertyp
2640 Fehler
Sie haben eine Hostvariable, die kein Ganzzahltyp ist, in einer Anweisung
verwendet, in der nur Hostvariablen vom Ganzzahltyp zulässig sind.
Das Symbol ’%1’ ist bereits definiert
Mögliche Ursache
Fehlernummer Fehlertyp
2617 Fehler
Sie haben eine Hostvariable zweimal definiert.

Include-Datei ’%1’ kann nicht gefunden werden
Mögliche Ursache
Kapitel 13 Fehlermeldungen des SQL-Präprozessors
Fehlernummer Fehlertyp
2619 Fehler
Die angegebene Include-Datei wurde nicht gefunden. Beachten Sie, dass der
Präprozessor die INCLUDE-Umgebungsvariable zur Suche nach Include-
Dateien verwendet.
FIXCHAR-Typ muss eine Länge haben
Mögliche Ursache
Fehlernummer Fehlertyp
2608 Fehler
Sie haben den Makro DECL_FIXCHAR benutzt, um eine Hostvariable des
Typs FIXCHAR zu deklarieren, aber keine Länge angegeben.
Merkmal steht bei UltraLite nicht zur Verfügung
Mögliche Ursache
Fehlernummer Fehlertyp
2693 Markierung (Warnung oder Fehler)
Sie haben eine Funktion benutzt, die von UltraLite nicht unterstützt wird.
Hostvariable ’%1’ wird mit unterschiedlichen Indikatoren mehr als
einmal verwendet
Mögliche Ursache
Fehlernummer Fehlertyp
2696 Fehler
Sie haben dieselbe Hostvariable mehrere Male mit unterschiedlichen
Indikatorvariablen in derselben Anweisung verwendet. Dies wird nicht
unterstützt.
451

SQLPP-Fehler
Inkonsistente Hostvariablentypen für diesen Cursor
Mögliche Ursache
452
Fehlernummer Fehlertyp
2691 Fehler
Sie haben eine Hostvariable mit einem anderen Typ oder einer anderen
Länge verwendet als vorher mit diesem Cursor. Hostvariablentypen müssen
für den Cursor konsistent sein.
Inkonsistente Indikatorvariable für diesen Cursor
Mögliche Ursache
Fehlernummer Fehlertyp
2692 Fehler
Sie haben eine Indikatorvariable benutzt, obwohl vorher mit dem Cursor
keine verwendet wurde, oder Sie haben keine Indikatorvariable benutzt,
obwohl vorher mit dem Cursor eine benutzt wurde. Indikatorvariablen
müssen bei Cursorn konsistent verwendet werden.
Inkonsistente Zahl von Hostvariable für diesen Cursor
Mögliche Ursache
Fehlernummer Fehlertyp
2690 Fehler
Sie haben eine andere Anzahl von Hostvariablen benutzt als vorher mit dem
Cursor benutzt wurde. Die Anzahl von Hostvariablentypen muss für den
Cursor konsistent sein.
Into-Klausel in 'declare cursor' nicht zulässig - ignoriert
Mögliche Ursache
Fehlernummer Fehlertyp
2660 Warnung
Sie haben eine INTO-Klausel mit einer DECLARE CURSOR-Anweisung
verwendet. Die INTO-Klausel wird ignoriert.

Ungültige Arraydimension
Mögliche Ursache
Kapitel 13 Fehlermeldungen des SQL-Präprozessors
Fehlernummer Fehlertyp
2648 Fehler
Die Arraydimension der Variablen ist negativ.
Makros können nicht neu definiert werden
Mögliche Ursache
Fehlernummer Fehlertyp
2647 Fehler
Ein Präprozessor-Makro wurde zweimal definiert, möglicherweise in einer
Header-Datei.
Zwei SQLDAs für denselben Typ angegeben (INTO oder USING)
Mögliche Ursache
Unbekannter Hostvariablen-Typ
Mögliche Ursache
Fehlernummer Fehlertyp
2642 Fehler
Sie haben zwei INTO DESCRIPTOR- oder zwei USING DESCRIPTOR-
Klauseln für diese Anweisung angegeben.
Fehlernummer Fehlertyp
2613 Fehler
Sie haben eine Hostvariable eines Typs angegeben, der vom SQL-
Präprozessor nicht verstanden wird.
VARCHAR-Hostvariable können keine Zeiger sein
Fehlernummer Fehlertyp
2606 Fehler
453

SQLPP-Fehler
Mögliche Ursache
454
Sie haben versucht, eine Hostvariable als Zeiger auf einen VARCHAR- oder
BINARY-Typ zu deklarieren. Dies ist kein zulässiger Hostvariablentyp.
VARCHAR-Typ muss eine Länge haben
Mögliche Ursache
Fehlernummer Fehlertyp
2604 Fehler
Sie haben versucht, eine VARCHAR- oder BINARY-Hostvariable mit dem
DECL_VARCHAR- oder DECL_BINARY-Makro zu deklarieren, aber
keine Größe für das Array angegeben.
Arrays werden für FIXCHAR nicht unterstützt
Mögliche Ursache
Fehlernummer Fehlertyp
2609 Fehler
Sie haben versucht, eine Hostvariable als Array von FIXCHAR-Arrays zu
deklarieren. Dies ist kein zulässiger Hostvariablentyp.
Arrays von VARCHAR nicht unterstützt
Mögliche Ursache
Fehlernummer Fehlertyp
2605 Fehler
Sie haben versucht, eine Hostvariable als Array von VARCHAR- oder
BINARY-Arrays zu deklarieren. Dies ist kein zulässiger Hostvariablentyp.
Dezimalzahlen-Arrays sind nicht zulässig
Fehlernummer Fehlertyp
2612 Fehler

Mögliche Ursache
Kapitel 13 Fehlermeldungen des SQL-Präprozessors
Sie haben versucht, eine Hostvariable als Array von DECIMAL-Arrays zu
deklarieren. Ein dezimales Array ist kein zulässiger Hostvariablentyp.
Arrays dieses Typs werden nicht unterstützt
Mögliche Ursache
Fehlernummer Fehlertyp
2610 Fehler
Sie haben versucht, ein Hostvariablen-Array eines Typs zu deklarieren, der
nicht unterstützt wird.
Statische Cursor können nicht beschrieben werden
Mögliche Ursache
Fehlernummer Fehlertyp
2646 Fehler
Sie haben einen statischen Cursor beschrieben. Beim Beschreiben eines
Cursors muss der Cursorname in einer Hostvariablen angegeben sein.
Kombinierter Zeiger und Arrays für Hosttypen nicht zulässig
Mögliche Ursache
Fehlernummer Fehlertyp
2602 Fehler
Sie haben ein Array von Zeigern als Hostvariable benutzt. Dies ist nicht
zulässig.
Cursor ’%1’ wurde vorher noch nicht deklariert
Mögliche Ursache
Fehlernummer Fehlertyp
2627 Fehler
Ein Embedded SQL-Cursorname wurde benutzt (in FETCH, OPEN, CLOSE
etc.), ohne vorher deklariert worden zu sein.
455

SQLPP-Fehler
Datenwert muss eine Hostvariable sein
Mögliche Ursache
456
Fehlernummer Fehlertyp
2652 Fehler
Die in der SET DESCRIPTOR-Anweisung benutzte Variable wurde nicht als
Hostvariable deklariert.
Fehler beim Lesen der temporären Datei
Mögliche Ursache
Fehlernummer Fehlertyp
2682 Fehler
Beim Lesen aus einer temporären Datei ist ein Fehler aufgetreten.
Fehler beim Schreiben der Ausgabedatei
Mögliche Ursache
Fehlernummer Fehlertyp
2683 Fehler
Beim Schreiben in die Ausgabedatei ist ein Fehler aufgetreten.
Feld in SET DESCRIPTOR Anweisung mehr als einmal verwendet
Mögliche Ursache
Volles SQL-Merkmal
Fehlernummer Fehlertyp
2651 Fehler
Dasselbe Schlüsselwort wurde mehr als einmal in einer einzigen SET
DESCRIPTOR-Anweisung verwendet.
Fehlernummer Fehlertyp
2668 Markierung (Warnung oder Fehler)

Mögliche Ursache
Kapitel 13 Fehlermeldungen des SQL-Präprozessors
Sie haben eine volle SQL/92-Funktion verwendet und mit den Optionen -ee,
-ei, -we oder -wi im Präprozessor verarbeitet.
Hostvariable ’%1!’ wurde neu definiert
Mögliche Ursache
Fehlernummer Fehlertyp
2665 Warnung
Sie haben dieselbe Hostvariable mit einem anderen Hosttyp neu definiert.
Für den SQL-Präprozessor sind Hostvariable globale Variable: zwei
Hostvariable mit unterschiedlichen Typen können niemals den gleichen
Namen haben.
Hostvariable ’%1’ hat zwei verschiedene Definitionen
Mögliche Ursache
Hostvariable ’%1’ ist unbekannt
Mögliche Ursache
Fehlernummer Fehlertyp
2625 Fehler
Dieselbe Hostvariable wurden in demselben Modul mit zwei verschiedenen
Typen definiert. Beachten Sie, dass die Hostvariablen in einem C-Modul
global sind.
Fehlernummer Fehlertyp
2620 Fehler
Sie haben eine Hostvariable in einer Anweisung benutzt, und diese
Hostvariable wurde nicht in einem Declare-Abschnitt deklariert.
Hostvariable für diesen Cursor nicht zulässig
Fehlernummer Fehlertyp
2629 Fehler
457

SQLPP-Fehler
Mögliche Ursache
458
Hostvariable sind in der Declare-Anweisung für den angegebenen Cursor
nicht zulässig. Wenn der Cursorname über eine Hostvariable übergeben
wird, müssen Sie volle dynamische SQL verwenden und die Anweisung
vorbereiten. Eine vorbereitete Anweisung kann Hostvariable aufweisen.
Hostvariable zweimal angegeben - bei ’Declare’ und bei ’Open’
Mögliche Ursache
Fehlernummer Fehlertyp
2630 Fehler
Sie haben Hostvariablen für einen Cursor in den Declare- und Open-
Anweisungen angegeben. Im statischen Fall müssen Sie Hostvariable in der
Declare-Anweisung angeben. Im dynamischen Fall geben Sie sie in der
Open-Anweisung an.
Fehlerhafte Embedded-SQL-Sprachensyntax - Dies ist eine ’%1’
Erweiterung
Fehlernummer Fehlertyp
2635 Fehler
Fehlerhafte Embedded-SQL-Syntax
Mögliche Ursache
Fehlernummer Fehlertyp
2636 Fehler
Eine Embedded SQL-spezifische Anweisung (OPEN, DECLARE, FETCH
etc.) hat einen Syntaxfehler.
Fehlerhafte SQL-Sprachensyntax - Dies ist eine ’%1’ Erweiterung
Fehlernummer Fehlertyp
2634 Fehler

Indikatorvariable ’%1’ ist unbekannt
Mögliche Ursache
Kapitel 13 Fehlermeldungen des SQL-Präprozessors
Fehlernummer Fehlertyp
2621 Fehler
Sie haben eine Indikatorvariable in einer Anweisung benutzt, und diese
Indikatorvariable wurde nicht in einem Declare-Abschnitt deklariert.
Initialisieren bei der VARCHAR-Hostvariablen nicht zulässig
Mögliche Ursache
Intermediate-SQL-Merkmal
Mögliche Ursache
Ungültiger Deskriptor-Index
Mögliche Ursache
Fehlernummer Fehlertyp
2607 Fehler
Sie können keinen C-Variablen-Initialisierer für eine Hostvariable des Typs
VARCHAR oder BINARY angeben. Sie müssen diese Variable in regulätem
ausführbarem C-Code initialisieren.
Fehlernummer Fehlertyp
2667 Markierung (Warnung oder Fehler)
Sie haben eine Intermediate-SQL/92-Funktion verwendet und mit den
Optionen -ee oder -we im Präprozessor verarbeitet.
Fehlernummer Fehlertyp
2649 Fehler
Sie haben weniger als eine Variable mit der Anweisung ALLOCATE
DESCRIPTOR zugewiesen.
459

SQLPP-Fehler
Ungültiges Feld für SET DESCRIPTOR
Mögliche Ursache
460
Fehlernummer Fehlertyp
2650 Fehler
Ein ungültiges oder unbekanntes Schlüsselwort ist in einer SET
DESCRIPTOR-Anweisung vorhanden. Schlüsselwörter können nur sein:
TYPE, PRECISION, SCALE, LENGTH, INDICATOR oder DATA.
Ungültiger Hostvariablen-Typ auf '%1'
Mögliche Ursache
Ungültige Ganzzahl
Mögliche Ursache
Fehlernummer Fehlertyp
2623 Fehler
Sie haben an einer Stelle, an der der Präprozessor eine Hostvariable vom
Zeichenfolgentyp erwartete, eine Hostvariable verwendet, die kein
Zeichenfolgentyp ist.
Fehlernummer Fehlertyp
2614 Fehler
Eine Ganzzahl wurde in einer Embedded SQL-Anweisung (für einen Fetch-
Offset oder einen Hostvariablen-Arrayindex, etc.) erwartet, und der
Präprozessor konnte das übergebene Element nicht in eine Ganzzahl
konvertieren.
Ungültiger Typ für Indikatorvariable '%1'
Mögliche Ursache
Fehlernummer Fehlertyp
2622 Fehler
Indikatorvariable müssen den Typ "short int" haben. Sie haben eine Variable
eines anderen Typs als Indikatorvariable verwendet.

Ungültiger Typ für SQL-Anweisungsvariable
Mögliche Ursache
Kapitel 13 Fehlermeldungen des SQL-Präprozessors
Fehlernummer Fehlertyp
2618 Fehler
Eine Hostvariable, die als Anweisungsbezeichner benutzt wird, muss vom
Typ a_sql_statement_number sein. Sie haben versucht, eine Hostvariable
eines anderen Typs als Anweisungsbezeichner zu benutzen.
Größenlimit für long binary/long varchar ist 65535 für UltraLite
Mögliche Ursache
Fehlernummer Fehlertyp
2697 Fehler
Bei der Verwendung von DECL_LONGBINARY oder
DECL_LONGVARCHAR mit UltraLite ist die Obergrenze für das Array 64
KByte.
Fehlendes schließendes Anführungszeichen für die Zeichenfolge
Mögliche Ursache
Fehlernummer Fehlertyp
2637 Fehler
Sie haben eine Zeichenfolgenkonstante in einer Embedded SQL-Anweisung
eingegeben, aber es ist kein schließendes Anführungszeichen für das
Zeilenende oder das Dateiende vorhanden.
Host-Liste oder Using-Klausel für %1 muss angegeben werden
Mögliche Ursache
Fehlernummer Fehlertyp
2631 Fehler
Die angegebene Anweisung benötigt die Angabe von Hostvariablen in einer
Hostvariablenliste oder aus einer SQLDA.
461

SQLPP-Fehler
SQLDA muss für DESCRIBE angegeben werden
462
Fehlernummer Fehlertyp
2641 Fehler
Kein FETCH- oder PUT-Befehl für Cursor '%1'
Mögliche Ursache
Fehlernummer Fehlertyp
2695 Fehler
Ein Cursor ist deklariert und geöffnet, wird aber nie verwendet.
Keine INTO-Klausel in SELECT-Anweisung
Mögliche Ursache
Fehlernummer Fehlertyp
2633 Fehler
Kein OPEN-Befehl für Cursor '%1'
Mögliche Ursache
Sie haben eine statische Embedded-SQL-SELECT-Anweisung angegeben,
aber keine INTO-Klausel für die Ergebnisse festgelegt.
Fehlernummer Fehlertyp
2694 Fehler
Ein Cursor ist deklariert und möglicherweise benutzt, wird aber nie geöffnet.
Kein ’Declare’-Abschnitt und keine INCLUDE SQLCA Anweisung
Mögliche Ursache
Fehlernummer Fehlertyp
2680 Fehler
Die EXEC SQL INCLUDE SQLCA-Anweisung fehlt in der Quelldatei.

Kapitel 13 Fehlermeldungen des SQL-Präprozessors
Nur eindimensionale Arrays werden für den 'char'-Typ unterstützt
Mögliche Ursache
Fehlernummer Fehlertyp
2603 Fehler
Sie haben versucht, eine Hostvariable als Array von Zeichen-Arrays zu
deklarieren. Dies ist kein zulässiger Hostvariablentyp.
Beim Dezimaltyp muss die Anzahl der Dezimalstellen angegeben
werden
Mögliche Ursache
Fehlernummer Fehlertyp
2611 Fehler
Sie müssen die Dezimalstellen angeben, wenn Sie eine gepackte dezimale
Hostvariable mit dem Makro DECL_DECIMAL deklarieren. Die
Gesamtstellenanzahl ist fakultativ.
Anweisung ’%1’ wurde vorher noch nicht vorbereitet
Mögliche Ursache
Fehlernummer Fehlertyp
2626 Fehler
Ein Embedded SQL-Anweisungsname wurde benutzt (EXECUTE), ohne
vorher vorbereitet worden zu sein.
Statische Anweisungsnamen funktionieren nicht richtig, wenn von
2 Threads benutzt
Fehlernummer Fehlertyp
2664 Warnung
463

SQLPP-Fehler
Mögliche Ursache
Subskriptionswert %1 zu groß
Mögliche Ursache
Token zu lang
Mögliche Ursache
Transact-SQL-Erweiterung
Mögliche Ursache
464
Sie haben einen statischen Anweisungsnamen benutzt und mit dem
Wiedereintrittsparameter -r im Präprozessor verarbeitet. Statische
Anweisungsnamen bewirken, dass statische Variable generiert werden, die
aus der Datenbank einfließen. Wenn zwei Threads dieselbe Anweisung
verwenden, kommt es wegen dieser Variablen zum Engpass. Benutzen Sie
eine lokale Hostvariable als Anweisungsbezeichner, und nicht einen
statischen Namen.
Fehlernummer Fehlertyp
2601 Fehler
Sie haben versucht, eine Hostvariable zu indizieren, die in einem Array mit
einem zu großen Wert für das Array liegt.
Fehlernummer Fehlertyp
2639 Fehler
Der SQL-Präprozessor hat eine maximale Tokenlänge von 2 KByte. Alle
Token über 2 KByte ergeben diesen Fehler. Für Konstantenzeichenfolgen in
Embedded SQL-Befehlen (Hauptursache für diesen Fehler) benutzen Sie
eine Zeichenfolgenverkettung, um eine längere Zeichenfolge zu
ermöglichen.
Fehlernummer Fehlertyp
2669 Markierung (Warnung oder Fehler)
Sie haben eine Sybase Transact-SQL-Funktion verwendet, die von SQL/92
nicht definiert wurde, und mit den Parametern -ee, -ei, -ef, -we, -wi oder -wf
im Präprozessor verarbeitet.

Temporäre Datei kann nicht geöffnet werden
Mögliche Ursache
Unbekannte SQL-Funktion ’%1’
Mögliche Ursache
Unbekannte Anweisung ’%1’
Mögliche Ursache
Nicht erkannte SQL-Syntax
Mögliche Ursache
Kapitel 13 Fehlermeldungen des SQL-Präprozessors
Fehlernummer Fehlertyp
2681 Fehler
Beim Öffnen einer temporären Datei ist ein Fehler aufgetreten.
Fehlernummer Fehlertyp
2662 Warnung
Sie haben eine SQL-Funktion benutzt, die dem Präprozessor nicht bekannt
ist und die wahrscheinlich einen Fehler generieren wird, sobald die
Anweisung an die Datenbankengine geschickt wurde.
Fehlernummer Fehlertyp
2628 Fehler
Sie haben versucht, eine Embedded SQL-Anweisung zu löschen, die nicht
existiert.
Fehlernummer Fehlertyp
2661 Warnung
Sie haben eine SQL-Anweisung benutzt, die wahrscheinlich einen
Syntaxfehler generieren wird, sobald sie an die Datenbankengine geschickt
wurde.
465

SQLPP-Fehler
Erweiterung des Herstellers
Mögliche Ursache
466
Fehlernummer Fehlertyp
2666 Markierung (Warnung oder Fehler)
Sie haben eine Adaptive Server Anywhere-Funktion verwendet, die von
SQL/92 nicht definiert wurde, und mit den Parametern -ee, -ei, -ef, -we, -wi
oder -wf im Präprozessor verarbeitet.
Falsche Anzahl von Parametern für SQL-Funktion '%1'
Mögliche Ursache
Fehlernummer Fehlertyp
2663 Warnung
Sie haben eine SQL-Funktion mit der falschen Anzahl von Parametern
verwendet. Dies wird wahrscheinlich einen Fehler generieren, sobald die
Anweisung an die Datenbankengine gesendet wurde.

Index
>
>>
Java in der Datenbank-Methoden, 77
A
a_backup_db, Struktur, 335
a_change_log, Struktur, 337
a_compress_db, Struktur, 339
a_compress_stats, Struktur, 340
a_create_db, Struktur, 341
a_crypt_db, Struktur, 343
a_db_collation, Struktur, 344
a_db_info, Struktur, 345
a_dblic_info, Struktur, 348
a_dbtools_info, Struktur, 349
a_name, Struktur, 351
a_stats_line, Struktur, 352
a_sync_db, Struktur, 352
a_syncpub, Struktur, 355
a_sysinfo, Struktur, 356
a_table_info, Struktur, 356
a_translate_log, Struktur, 357
a_truncate_log, Struktur, 358
a_validate_db, Struktur, 363
a_validate_type, Aufzählungstyp, 369
a_writefile, Struktur, 364
Abfragen
ADO-Recordset-Objekt, 377, 379
einzelne Zeilen, 214
Java in der Datenbank, 117
JDBC, 169
Abrollbare Cursor
JDBC-Unterstützung, 145
Abrollender Cursor, 23
Abrufen
Objekte, 174
ODBC, 300
SQLDA, 235
ActiveX-Datenobjekte
Info, 374
ADO
Abfragen, 377, 379
Aktualisierungen, 379
Befehle, 376
Befehlsobjekt, 376
Cursor, 28, 379
Cursortypen, 26
Einführung in die Programmierung, 3
Info, 374
Recordset-Objekt, 377, 379
SQL-Anweisungen in Anwendungen verwenden,
10
Verbindungen, 374
Verbindungsobjekt, 374
Aggregatfunktionen
Java in der Datenbank, Spalten, 120
467

A–A
Aktualisierungen
Cursor, 379
alloc_sqlda, Funktion, 253
alloc_sqlda_noind, Funktion, 253
ALTER DATABASE, Anweisung
Java in der Datenbank, 99, 100
an_erase_db, Struktur, 349
an_expand_db, Struktur, 350
an_unload_db, Struktur, 359
an_upgrade_db, Struktur, 361
Anforderungen
abbrechen, 257
Open Client-Anwendungen, 390
Anforderungen abbrechen
Embedded SQL, 247
Anforderungsverarbeitung
Embedded SQL, 247
Anführungszeichen
Java in der Datenbank, 78
Angeführte Bezeichner
SQL_needs_quotes-Funktion, 270
Anregungen
Dokumentation, xv
Antwortdatei
Definition, 422
Anweisungen
COMMIT, 52
DELETE, positionsbasiert, 24
INSERT, 12
PUT, 24
ROLLBACK, 52
ROLLBACK TO SAVEPOINT, 52
UPDATE, positionsbasiert, 24
Anweisungs-Handle
ODBC, 287
Anwendungen
bereitstellen, 426
Bereitstellung, 411
SQL, 10
Anwendungen bereitstellen
Embedded SQL, 433
468
Anwendungen mit mehreren Threads
ODBC, 278, 293
UNIX, 282
Anwendungen mit Threadverarbeitung
UNIX, 416
Arbeitstabellen
Cursor-Performance, 43
Array, Abrufe
Info, 218
ARRAY, Klausel
FETCH-Anweisung, 218
asademo.db, Datei
Info, xiv
asajdbc.zip
Datenbankserver bereitstellen, 438
Laufzeitklassen, 97
ASAJDBCDRV, JAR-Datei
Info, 98
ASAJRT, JAR-Datei
Info, 98
asajrt12.zip
Laufzeitklassen, 97
ASAJSystem, JAR-Datei
Info, 98
ASAProv
OLE DB-Provider, 372
Assistenten
JAR- und ZIP-Datei erstellen, 105
Java-Klasse hinzufügen, 104
Neue Java-Klasse erstellen, 85, 161
Upgrade einer Datenbank, Assistent, 101
Attribute
Java in der Datenbank, 133
Auffüllen mit Leerzeichen, 367
Aufzählungstypen
DBTools-Schnittstelle, 367
Ausführlichkeit, 367
Auslagerbar
Definition, 140
Ausnahmen
Java, 73

autocommit
ODBC, 289
steuern, 50
AutoCommit
JDBC, 164
Autocommit, Modus
Implementierung, 51
Transaktionen, 49
B
Befehle
ADO-Befehlsobjekt, 376
Befehlsobjekt
ADO, 376
Beispieldatenbank
Info über asademo.db, xiv
Java in der Datenbank, 94
Beispiele
DBTools-Programm, 319
Embedded SQL, 191
Embedded SQL-Anwendungen, 190
esqldll.c, 188
ODBC, 285
statische Cursor in Embedded SQL, 193
Windows-Dienste, 286
Benutzerdefinierte Klassen
Java in der Datenbank, 76
Berechnete Spalten
Begrenzungen, 139
erstellen, 137
INSERT-Anweisung, 138
Java in der Datenbank, 137
Neuberechnungen, 139
Trigger, 138
UPDATE-Anweisung, 138
Berechtigungen
JDBC, 173
Bereich
Java, 72
Bereitstellen
Anwendungen, 426
Datenbanken, 439
Datenbanken auf CD-ROM, 439
Datenbankserver, 438
dbconsole, Dienstprogramm, 437
eingebettete Datenbanken, 441
Embedded SQL, 433
Interactive SQL, 437
Java in der Datenbank, 438
jConnect, 435
JDBC-Clients, 435
JDBC-ODBC-Brücke, 435
ODBC, 427
ODBC-Treiber, 428
OLE DB-Provider, 426
Open Client, 436
Personal Datenbankserver, 441
schreibgeschützte Datenbanken, 439
SQL Remote, 442
Sybase Central, 437
Verwaltungstools, 437
Bereitstellung
Dateistandorte, 415
Datenbanken und Anwendungen, 411
Info, 411
InstallShield, 420
Methoden, 412
MobiLink-Synchronisationsserver, 422
ohne Dialog, 422
siehe auch Bereitstellung, Überblick, 412
Write-Dateien, 418
Beschreiben
Ergebnismengen, 47
Beständigkeit
Java in den Datenbankklassen, 80
Betriebssystem
Dateinamen, 417
Bezeichner
Anführungszeichen nötig, 270
Bibliotheken
Embedded SQL, 185
Bibliotheksfunktionen
Embedded SQL, 253
BINARY, Datentypen
Embedded SQL, 201
Bindevariable
Info, 223
B–B
469

C–C
Bindungsparameter
vorbereitete Anweisungen, 13
Bit-Felder
Verwendung, 319
BLOBs
Embedded SQL, 237
in Embedded SQL abrufen, 238
in Embedded SQL senden, 240
Block-Cursor, 22
ODBC, 29
Bookmarks
ODBC-Cursor, 303
Borland C++
Unterstützung, 184
Breite Ablagen, 218
Bytecode
Java-Klassen, 58
C
C, Programmiersprache
Datentypen, 201
Cache
Java in der Datenbank, 140
CALL, Anweisung
embedded SQL, 243
Callback, Funktionen
Embedded SQL, 247
registrieren, 261
Callbacks
DB_CALLBACK_DEBUG_MESSAGE, 262
Catch, Block
Java, 73
CD-ROM
Datenbanken bereitstellen, 439
Chained, Modus
Implementierung, 51
steuern, 50
Transaktionen, 49
CHAINED, Option
JDBC, 164
470
Class.forName, Methode
jConnect laden, 152
classes.zip
Datenbankserver bereitstellen, 438
Laufzeitklassen, 97
CLASSPATH, Umgebungsvariable
einrichten, 160
Info, 82
Java in der Datenbank, 82
jConnect, 150
Clientseitiges autocommit
Info, 51
CLOSE, Anweisung
Info, 215
com.sybase, Paket
Laufzeitklassen., 97
COMMIT, Anweisung
Autocommit-Modus, 49, 50
Cursor, 52
JDBC, 164
compareTo, Methode
Objektvergleiche, 120
Compiler
unterstützte, 184
COMPUTE, Klausel
CREATE TABLE, 137
CREATE DATABASE, Anweisung
Java in der Datenbank, 99, 100
CREATE PROCEDURE, Anweisung
embedded SQL-Syntax, 243
CS_CSR_ABS, 398
CS_CSR_FIRST, 398
CS_CSR_LAST, 398
CS_CSR_PREV, 398
CS_CSR_REL, 398
CS_DATA_BOUNDARY, 398
CS_DATA_SENSITIVITY, 398
CS_PROTO_DYNPROC, 398
CS_REG_NOTIF, 398

CS_REQ_BCP, 398
ct_command, Funktion
Open Client, 394, 396
CT_CURSOR, Funktion
Open Client, 395
ct_dynamic, Funktion
Open Client, 394
ct_results, Funktion
Open Client, 396
ct_send, Funktion
Open Client, 396
Cursor, 29
abbrechen, 25, 257
abrollende, 23
ADO, 28
aktualisieren, 379, 396
aktualisieren und löschen, 24
anfordern, 27
Arbeitstabellen, 43
Beispiel C-Code, 190
beschreiben, 47
DYNAMIC SCROLL, 21, 26, 39
Dynamisch, 37
eindeutig, 26
Einführung, 15
Embedded SQL, 28, 215
empfindlich, 37
Empfindlichkeit, 30, 31
Empfindlichkeit, Beispiele, 32, 34
Ergebnismengen, 15
Fat, 22
Fetch-Vorgänge für mehrere Zeilen, 22
Fetch-Vorgänge für Zeilen, 20, 22
gespeicherte Prozeduren, 244
Info, 15
Interna, 30
Isolationsstufe (isolation level), 21
löschen, 396
Mitgliedschaft, 30
nicht-empfindlich, 39
NO SCROLL, 26, 36
ODBC, 28, 299
ODBC-Aktualisierungen, 302
ODBC-Bookmarks, 303
ODBC-Cursor-Merkmale wählen, 299
ODBC-Ergebnismengen, 300
ODBC-Löschungen, 302
OLE DB, 28
Open Client, 395
Performance, 43, 44
Plattformen, 26
positionieren, 20
Reihenfolge, 30
Savepoints, 52
Schlüsselmengen-gesteuert, 40
Schreibschutz, 26
Schritt für Schritt, 17
SCROLL, 26, 40
sichtbare Änderungen, 31
Statisch, 36
Transaktionen, 52
unbestimmte Empfindlichkeit, 39
unempfindlich, 26, 36
Verfügbarkeit, 26
verwenden, 15, 20
vorbereitete Anweisungen, 19
Werte, 30
wert-empfindlich, 40
Cursor positionieren
Fehlerbehandlung, 21
D
JDBCExamples.java, 144
Dateien
Namenskonventionen, 416
Standorte für die Bereitstellung, 415
Dateinamen
Konventionen, 416
Sprache, 417
Versionsnummer, 416
Daten abrufen
Embedded SQL, 214
Datenbankdesign
Java in der Datenbank, 133
Datenbankeigenschaften
db_get_property-Funktion, 258
Datenbanken
bereitstellen, 439
Java in der Datenbank, 133
Java-aktivieren, 97, 99, 101
URL, 153
D–D
471

D–D
Datenbankoptionen
für jConnect eingestellt, 154
Datenbankserver
bereitstellen, 438
Funktionen, 267
Datenbank-Tools, Schnittstelle
a_backup_db-Struktur, 335
a_change_log-Struktur, 337
a_compress_db-Struktur, 339
a_compress_stats-Struktur, 340
a_create_db-Struktur, 341
a_crypt_db-Struktur, 343
a_db_collation-Struktur, 344
a_db_info-Struktur, 345
a_dblic_info-Struktur, 348
a_dbtools_info-Struktur, 349
a_name-Struktur, 351
a_stats_line-Struktur, 352
a_sync-db-Struktur, 352
a_syncpub-Struktur, 355
a_sysinfo-Struktur, 356
a_table_info-Struktur, 356
a_translate_log-Struktur, 357
a_truncate_log-Struktur, 358
a_validate_db-Struktur, 363
a_validate_type-Aufzählungstypen, 369
a_writefile-Struktur, 364
an_erase_db-Struktur, 349
an_expand_db-Struktur, 350
an_unload_db-Struktur, 359
an_upgrade_db-Struktur, 361
Auffüllen mit Leerzeichen, 367
Aufzählungstypen, 367
Ausführlichkeit, 367
DBBackup-Funktion, 323
DBChangeLogName-Funktion, 323
DBChangeWriteFile-Funktion, 324
DBCollate-Funktion, 324
DBCompress-Funktion, 325
DBCreate-Funktion, 325
DBCreateWriteFile-Funktion, 326
DBCrypt-Funktion, 326
DBErase-Funktion, 327
DBExpand-Funktion, 327
DBInfo, Funktion, 327
DBInfoDump-Funktion, 328
DBInfoFree-Funktion, 328
DBLicense-Funktion, 329
DBStatusWriteFile-Funktion, 329
DBToolsFini-Funktion, 330
472
DBToolsInit-Funktion, 331
DBToolsVersion-Funktion, 332
dbtran_userlist_type-Aufzählungstyp, 368
DBTranslateLog-Funktion, 332
DBTruncateLog-Funktion, 332
dbunload-Aufzählungstyp, 368
DBUnload-Funktion, 333
DBUpgrade-Funktion, 333
DBValidate-Funktion, 334
dbxtract, 333
Info, 311
Datentypen
Bereiche, 392
C-Datentypen, 201
dynamische SQL, 228
Embedded SQL, 196
Hostvariable, 201
Java in der Datenbank, 109
Open Client, 391
SQLDA, 230
Zuordnung, 391
Datentypkonvertierung
Indikatorvariable, 206
db_backup, Funktion
Info, 247, 254
DB_BACKUP_CLOSE_FILE, Parameter, 254
DB_BACKUP_END, Parameter, 254
DB_BACKUP_OPEN_FILE, Parameter, 254
DB_BACKUP_READ_PAGE, Parameter, 254
DB_BACKUP_READ_RENAME_LOG,
Parameter, 254
DB_BACKUP_START, Parameter, 254
DB_CALLBACK_CONN_DROPPED, Callback-
Parameter, 262
DB_CALLBACK_DEBUG_MESSAGE, Callback-
Parameter, 262
DB_CALLBACK_FINISH, Callback-Parameter,
262
DB_CALLBACK_MESSAGE, Callback-Parameter,
263
DB_CALLBACK_START, Callback-Parameter,
262

DB_CALLBACK_WAIT, Callback-Parameter, 262
db_cancel_request, Funktion, 257
Anforderungsverwaltung, 247
db_delete_file, Funktion, 257
db_find_engine, Funktion, 258
db_fini, Funktion, 258
db_fini_dll
aufrufen, 188
db_get_property, Funktion
Info, 258
db_init, Funktion, 259
db_init_dll
aufrufen, 188
db_is_working, Funktion, 260
Anforderungsverwaltung, 247
db_locate_servers, Funktion, 260
db_register_a_callback, Funktion, 261
Anforderungsverwaltung, 247
db_start_database, Funktion
Info, 263
db_start_engine, Funktion
Info, 264
db_stop_database, Funktion
Info, 265
db_stop_engine, Funktion
Info, 266
db_string_connect, Funktion
Info, 267
db_string_disconnect, Funktion
Info, 267
db_string_ping_server, Funktion
Info, 268
DBBackup, Funktion, 323
DBChangeLogName, Funktion, 323
DBChangeWriteFile, Funktion, 324
DBCollate, Funktion, 324
DBCompress, Funktion, 325
D–D
dbcon8.dll
Datenbank-Dienstprogramme bereitstellen, 441
Embedded SQL-Clients bereitstellen, 434
ODBC-Clients bereitstellen, 428
OLE DB-Clients bereitstellen, 426
dbconsole, Dienstprogramm
bereitstellen, 437
DBCreate, Funktion, 325
DBCreateWriteFile, Funktion, 326
DBCrypt, Funktion, 326
dbctrs8.dll
Datenbankserver bereitstellen, 438
dbeng8
Datenbankserver bereitstellen, 438
DBErase, Funktion, 327
DBExpand, Funktion, 327
dbextf.dll
Datenbankserver bereitstellen, 438
dbfile.dll
SQL Remote bereitstellen, 442
DBInfo, Funktion, 327
DBInfoDump, Funktion, 328
DBInfoFree, Funktion, 328
dbinit (Dienstprogramm)
Java in der Datenbank, 99, 100
dbipx8.dll
Embedded SQL-Clients bereitstellen, 434
ODBC-Clients bereitstellen, 428
dbjava8.dll
Datenbankserver bereitstellen, 438
dblgen8.dll
Datenbank-Dienstprogramme bereitstellen, 441
Datenbankserver bereitstellen, 438
Embedded SQL-Clients bereitstellen, 434
ODBC-Clients bereitstellen, 428
OLE DB-Clients bereitstellen, 426
SQL Remote bereitstellen, 442
dblib8.dll
Embedded SQL-Clients bereitstellen, 434
Schnittstellenbibliothek, 182
473

D–D
DBLicense, Funktion, 329
dbmapi.dll
SQL Remote bereitstellen, 442
dbmlsync, (Dienstprogramm)
C API für, 352
eigenes schreiben, 352
dbodbc8.dll
ODBC-Clients bereitstellen, 428
dbodbc8.lib
Windows CE ODBC-Importbibliothek, 282
dbodbc8.so
UNIX ODBC-Treiber, 283
dboledb8.dll
OLE DB-Clients bereitstellen, 426
dboledba8.dll
OLE DB-Clients bereitstellen, 426
dbremote
SQL Remote bereitstellen, 442
dbserv8.dll
Datenbankserver bereitstellen, 438
dbsmtp.dll
SQL Remote bereitstellen, 442
dbsrv8
Datenbankserver bereitstellen, 438
DBStatusWriteFile, Funktion, 329
DBSynchronizeLog, Funktion, 330
dbtool8.dll
Datenbank-Dienstprogramme bereitstellen, 441
SQL Remote bereitstellen, 442
Windows CE, 312
DBTools, Schnittstelle
beenden, 314
Einführung, 312
Info, 311
starten, 314
Verwendung, 314
DBToolsFini, Funktion, 330
DBToolsInit, Funktion, 331
474
DBTools-Schnittstelle
Beispielprogramm, 319
DBTools-Funktionen aufrufen, 315
Funktionen, 323
DBToolsVersion, Funktion, 332
dbtran_userlist_type, Aufzählungstyp, 368
DBTranslateLog, Funktion, 332
DBTruncateLog, Funktion, 332
dbunload, Aufzählungstyp, 368
dbunload, Dienstprogramm
eigenes schreiben, 359
Header-Datei, 359
DBUnload, Funktion, 333
dbupgrad (Dienstprogramm)
Java in der Datenbank, 100
dbupgrad, (Dienstprogramm)
Java in der Datenbank, 99
DBUpgrade, Funktion, 333
DBValidate, Funktion, 334
dbvim.dll
SQL Remote bereitstellen, 442
dbwtsp8.dll
Datenbank-Dienstprogramme bereitstellen, 441
SQL Remote bereitstellen, 442
dbxtract, (Dienstprogramm)
Datenbank-Tools-Schnittstelle, 333
dbxtract, Dienstprogramm
eigenes schreiben, 359
Header-Datei, 359
DECIMAL, Datentyp
Embedded SQL, 201
DECL_BINARY, Makro, 201
DECL_DECIMAL, Makro, 201
DECL_FIXCHAR, Makro, 201
DECL_LONGBINARY, Makro, 201
DECL_LONGVARCHAR, Makro, 201
DECL_VARCHAR, Makro, 201

DECLARE, Anweisung
Info, 215
Deklarationsabschnitt
Info, 200
Deklarieren
Embedded SQL-Datentypen, 196
Hostvariable, 200
DELETE, Anweisung
Java in der Datenbank-Objekte, 116
positionsbasiert, 24
DESCRIBE, Anweisung
Info, 226
mehrere Ergebnismengen, 246
SQLDA-Felder, 230
sqllen-Felder, 232
sqltype-Feld, 232
Deskriptoren
Ergebnismengen beschreiben, 47
Destruktoren
Java, 72
Dienste
Beispielcode, 195, 286
Windows, 286
Dienstprogramme
bereitstellen, 441
Datenbank-Dienstprogramme bereitstellen, 441
SQL-Präprozessor, 249
DISTINCT, Schlüsselwort
Java in der Datenbank, Spalten, 120
Distributed Transaction Coordinator
dreischichtige Datenverarbeitung, 403
DLL-Eintrittspunkte, 253
DLLs
mehrere SQLCAs, 212
Dokumentation
Konventionen, xi
Dokumentation zu SQL Anywhere Studio, viii
Dreischichtige Datenverarbeitung
Architektur, 401
Distributed Transaction Coordinator, 403
EAServer, 403
Info, 399
D–D
Microsoft Transaction Server, 403
Ressourcen-Manager, 402
Ressourcen-Verteiler, 402
verteilte Transaktionen, 402
DT_BIGINT Embedded SQL, Datentyp, 196
DT_BINARY Embedded SQL, Datentyp, 197
DT_BIT Embedded SQL, Datentyp, 196
DT_DATE Embedded SQL, Datentyp, 196
DT_DECIMAL Embedded SQL, Datentyp, 196
DT_DOUBLE Embedded SQL, Datentyp, 196
DT_FIXCHAR Embedded SQL, Datentyp, 197
DT_FLOAT Embedded SQL, Datentyp, 196
DT_INT Embedded SQL, Datentyp, 196
DT_LONGBINARY Embedded SQL, Datentyp,
198
DT_LONGVARCHAR Embedded SQL, Datentyp,
197
DT_SMALLINT Embedded SQL, Datentyp, 196
DT_STRING, Datentyp, 271
DT_TIME Embedded SQL, Datentyp, 196
DT_TIMESTAMP Embedded SQL, Datentyp, 197
DT_TIMESTAMP_STRUCT Embedded SQL,
Datentyp, 198
DT_TINYINT Embedded SQL, Datentyp, 196
DT_UNSINT Embedded SQL, Datentyp, 196
DT_UNSSMALLINT Embedded SQL, Datentyp,
196
DT_VARCHAR Embedded SQL, Datentyp, 197
DT_VARIABLE Embedded SQL, Datentyp, 198,
199
DTC
dreischichtige Datenverarbeitung, 403
DYNAMIC SCROLL, Cursor
Embedded SQL, 28
Fehlerbehandlung, 21
Info, 26, 39
475

E–F
Dynamische Cursor
Beispiel, 193
Info, 37
ODBC, 28
Dynamische SQL
Info, 223
SQLDA, 228
E
EAServer
dreischichtige Datenverarbeitung, 403
Komponenten-Transaktionsattribut, 408
transaction coordinator, 407
Verteilte Transaktionen, 407
Eigenschaften
db_get_property-Funktion, 258
Einbeziehung
verteilte Transaktionen, 402
Eindeutige Cursor
Info, 26
Eindeutige Spalten
Java in der Datenbank, Spalten, 120
Eingebettete Datenbanken
bereitstellen, 441
Einstellen
Werte mit SQLDA, 234
Embedded SQL
autocommit-Modus, 49, 50
Befehlszusammenfassung, 272
Beispielprogramm, 186
Berechtigungen, 251
Cursor, 28, 190, 215
Cursortypen, 26
Daten abrufen, 214
Dynamische Anweisungen, 223
Dynamische Cursor, 193
Einführung, 4
Entwicklung, 182
Funktionen, 253
Header-Dateien, 184
Hostvariable, 200
Importbibliotheken, 185
Info, 181
Kompilieren- und Verknüpfen-Prozess, 183
476
SQL-Anweisungen, 10
statische Anweisungen, 223
Zeichenfolgen, 251
Zeilennummern, 251
Empfindliche Cursor
Beispiele für Aktualisieren, 34
Beispiele für Löschen, 32
Einführung, 31
Embedded SQL, 28
Info, 37
Empfindlichkeit
Beispiele für Aktualisieren, 34
Beispiele für Löschen, 32
Cursor, 30, 31
Isolationsstufen und, 45
Entitäten
Java in der Datenbank, 133
Ergebnismengen
ADO-Recordset-Objekt, 377, 379
Cursor, 15
gespeicherte Prozeduren, 244
Java in der Datenbank, Gespeicherte Prozeduren,
125
Java in der Datenbank, Methoden, 125
Metadaten, 47
ODBC, 299, 304
ODBC abrufen, 300
Open Client, 396
verwenden, 20
Escapezeichen
Java in der Datenbank, 80
SQL, 80
EXEC SQL
Entwicklung in Embedded SQL, 187
EXECUTE, Anweisung, 223
Gespeicherte Prozeduren in Embedded SQL, 243
executeQuery, Methode
Info, 169
executeUpdate, JDBC-Methode, 14
Info, 166
F
Fat Cursor, 22

Feedback
geben, xv
Fehler
Codes, 208
SQLCODE, 208
sqlcode SQLCA-Feld, 208
Fehlerbehandlung
Cursor positionieren, 21
Java, 73
Java in der Datenbank, Methoden, 124
ODBC, 306
Fehlermeldungen
Embedded SQL-Funktion, 271
Felder
Instanz, 67
Java in der Datenbank, 66
Klasse, 67
private, 72
protected, 72
public, 72, 83
Festschreiben
Transaktionen aus ODBC, 289
Fetch
ODBC, 300
FETCH, Anweisung
dynamische Abfragen, 226
Info, 214, 215
mehrzeilig, 218
weit, 218
Fetch, Vorgänge
abrollende Cursor, 23
Beschränkungen, 20
Cursor, 22
Mehrere Zeilen, 22
fill_s_sqlda, Funktion
Info, 269
fill_sqlda, Funktion
Info, 269
Finally, Block
Java, 73
FIXCHAR, Datentyp
Embedded SQL, 201
ForceStart, Verbindungsparameter
db_start_engine, 265
Format
Java in der Datenbank, Objekte, 130
free_filled, Funktion
Info, 269
free_sqlda, Funktion
Info, 270
free_sqlda_noind, Funktion
Info, 270
Funktionen
DBTools, 323
DBTools-Funktionen aufrufen, 315
Embedded SQL, 253
G
Gemischte Cursor
ODBC, 28
Gespeicherte Prozeduren
Embedded SQL, 243
Ergebnismengen, 244
in dynamischem SQL ausführen, 243
in dynamischem SQL erstellen, 243
INOUT-Parameter und Java, 127
Java in der Datenbank, 125
OUT-Parameter und Java, 127
getConnection, Methode
Instanzen, 164
getObject, Methode
verwenden, 176
Gleichheit
Java in der Datenbank-Objekte, 119
GNU-Compiler
Unterstützung, 184
GRANT, Anweisung
JDBC, 173
Groß-/Kleinschreibung
Java in der Datenbank und SQL, 78
Java in der Datenbank, Datentypen, 109
GROUP BY, Klausel
Java in der Datenbank, Spalten, 120
G–G
477

H–I
H
Handles
ODBC zuweisen, 288
über ODBC, 287
Header-Dateien
Embedded SQL, 184
ODBC, 280
Heap-Größe
Java in der Datenbank, 141
Hintergrundverarbeitung
Callback-Funktionen, 247
Hinzufügen
JAR-Dateien, 105
Klassen für Java in der Datenbank, 104
Hostvariable
benutzen, 203
Datentypen, 201
deklarieren, 200
Info, 200
SQLDA, 230
I
Import, Anweisung
Java, 71
Java in der Datenbank, 81
jConnect, 151
Importbibliotheken
Alternativen, 187
DBTools, 314
Einführung, 183
Embedded SQL, 185
NetWare, 188
ODBC, 280
Windows CE ODBC, 282
INCLUDE, Anweisung
SQLCA, 208
Indikatorvariable
Datentypkonvertierung, 206
Info, 204
kürzen, 206
NULL, 205
SQLDA, 230
Zusammenfassungen der Werte, 206
478
Indizes
Java in der Datenbank, 120, 130, 137
INOUT, Parameter
Java in der Datenbank, 127
INSERT, Anweisung
Java in der Datenbank, 112
JDBC, 166, 168
mehrzeilig, 218
Objekte, 172
Performance, 12
weit, 218
INSTALL, Anweisung
Einführung, 76
Klassenversionen, 132
verwenden, 104, 105
Installation
ohne Dialog, 422
Installationsprogramme
Bereitstellung, 413
Installieren
JAR-Dateien in einer Datenbank, 105
Java-Klassen in einer Datenbank, 103, 104
InstallShield
Adaptive Server Anywhere-Anwendungen
bereitstellen, 420
Bereitstellung ohne Dialog, 422
Instanz, Felder
Info, 67
Instanz, Methoden
Info, 68
Instanzen
Java-Klassen, 71
Instanziert
Definition, 71
Interactive SQL
bereitstellen, 437
Isolationsstufen
Anwendungen, 51
Cursor, 21
Cursorempfindlichkeit und, 45

J
Jaguar
EAServer, 407
JAR- und ZIP-Datei erstellen
verwenden, 105
JAR, Dateien
aktualisieren, 106
hinzufügen, 105
installieren, 103, 105
Java, 71
löschen, 116
Versionen, 106
Java
Catch-Block, 73
Destruktoren, 72
Fehlerbehandlung, 73
Finally-Block, 73
JDBC, 144
Klassen, 71
Konstruktoren, 72
Objekte abfragen, 174
Schnittstellen, 73
Try-Block, 73
Java 2
unterstützte Versionen, 75
Java in der Datenbank
Abfragen, 117
API, 60, 75
Beispiel-Tabellen, 94
benutzen, 93
bereitstellen, 438
Beständigkeit, 80
compareTo-Methode, 120
Datenbankdesign, 133
Datentypen, 109
die Dokumentation verwenden, 55
die wichtigsten Funktionen, 57
eine Datenbank aktivieren, 99, 101
einfügen, 112
Einführung, 54, 64
Escapezeichen, 80
Fehler, Prozedur nicht gefunden, 124
Felder, 66
Fragen und Antworten, 57
Heap-Größe, 141
in der Datenbank aktivieren, 97
Indizes, 120, 130
Klassen installieren, 103
Klassen kompilieren, 65
Klassen löschen, 116
Klassenversionen, 131
Laufzeitklassen, 97
Laufzeitumgebung, 75, 96
main-Methode, 79, 123
Methoden, 66
Namensbereich, 141
NULL, 109
Objekte, 66
Objekte einfügen, 114
Objekte entladen und wieder laden, 132
Objekte replizieren, 132
Objekte vergleichen, 119
Performance, 130
Praktische Einführung, 84
Primärschlüssel, 120
Sicherheitsmanagement, Info, 128
Spalten aktualisieren, 115
Spalten berechnen, 137
Spalten erstellen, 109
Speicherfragen, 140
Speicherung, 130
Standardwerte, 109
unterstützte Klassen, 61
unterstützte Plattformen, 59
Überblick, 94
Version, 75
Virtual Machine, 57, 58, 141
Werte aktualisieren, 114
Zeilen löschen, 116
Java, Datentypen
abrufen, 172
einfügen, 172
Java, gespeicherte Prozeduren
Beispiel, 126
Info, 125
Java, Paket
Laufzeitklassen., 97
JAVA_HEAP_SIZE, Option, 141
JAVA_NAMESPACE_SIZE, Option
verwenden, 141
Java-Klasse erstellen, Assistant
verwenden, 85
Java-Klasse hinzufügen, Assistant
verwenden, 104, 161
J–J
479

K–K
Java-Klassen
Hinzufügen, 104
installieren, 104
Java-Sicherheitsmanagement
Info, 129
jcatalog.sql, Datei
jConnect, 151
jConnect
CLASSPATH, Umgebungsvariable, 150
Einrichtung der Datenbank, 151
gelieferte Versionen, 150
Info, 150
JDBC-Clients bereitstellen, 435
JDBC-Treiber wählen, 145
laden, 152
Pakete, 151
Systemobjekte, 151
URL, 152
Verbindungen, 157, 161
JDBC
Arten der Benutzung, 144
AutoCommit, 164
Autocommit-Modus, 49, 50
Beispiele, 144
Berechtigungen, 173
Bespiele, 157
clientseitig, 149
Client-Verbindungen, 157
Cursortypen, 26
Datenzugriff, 165
Einführung, 5
Info, 144
INSERT-Anweisung, 166, 168
jConnect, 150
JDBC-Clients bereitstellen, 435
Laufzeitklassen, 97
Nicht-Standardklassen, 146, 147
SELECT-Anweisung, 169
serverseitig, 149
serverseitige Verbindungen, 161
SQL-Anweisungen, 10
Standardwerte für die Verbindung, 164
Überblick über die Anwendungen, 145
verbinden, 157
Verbindung mit einer Datenbank, 153
Verbindungen, 149, 157
Verbindungscode, 158
Version, 75, 146, 147
Version 2.0-Funktionen, 146, 147
480
Voraussetzungen, 144
vorbereitete Anweisungen, 171
JDBCExamples, Klasse
Info, 165
JDBC-ODBC-Brücke
erforderliche Dateien, 155
JDBC-Clients bereitstellen, 435
JDBC-Treiber wählen, 145
verbinden, 155
verwenden, 155
JDBC-Treiber
Kompatibilität, 145
Performance, 145
wählen, 145
jdemo.sql
Beispieltabellen, 94
JDK
Definition, 60
Version, 75, 97
K
Kapazitäten
unterstützte, 398
Klassen
aktualisieren, 106
als Datentypen, 109
Beispiel, 111
erstellen, 103
importieren, 176
Info, 64
installieren, 103
Instanzen, 71
Java, 71
kompilieren, 65
Konstruktoren, 66
Laufzeit, 75
unterstützte, 61
Versionen, 106
Klassen, Felder
Info, 67
Klassen, Methoden
Info, 68

Klauseln
WITH HOLD, 21
Kompilieren und Verknüpfen, Prozess, 183
Komponenten
Transaktionsattribut, 408
Konsolendienstprogramm
bereitstellen, 437
Konstruktoren
Daten einfügen, 113
Info, 66
Java, 72
Konventionen
Dateinamen, 416
Dokumentation, xi
Konvertierung
Datentypen, 206
Kürzen
bei FETCH, 206
FETCH-Anweisung, 206
Indikatorvariable, 206
L
Laufzeitklassen
Inhalt, 97
installieren, 97
Laufzeitklassen, Java in der Datenbank, 75
Laufzeitumgebung
Java in der Datenbank, 96
length, SQLDA-Feld
Info, 230, 232
Lesezeichen, 29
LONG BINARY, Datentyp
Embedded SQL, 201, 237
in Embedded SQL abrufen, 238
in Embedded SQL senden, 240
LONG VARCHAR, Datentyp
Embedded SQL, 201, 237
in Embedded SQL abrufen, 238
in Embedded SQL senden, 240
Löschen
JAR-Dateien, 116
Java-Klassen, 116
M
main, Methode
Java in der Datenbank, 79, 123
Makros
_SQL_OS_NETWARE, 188
_SQL_OS_UNIX, 188
_SQL_OS_WINNT, 188
manual commit, Modus
Implementierung, 51
steuern, 50
Transaktionen, 49
MAX, Funktion
Java in der Datenbank, Spalten, 120
Mehrere Ergebnismengen
DESCRIBE-Anweisung, 246
Mehrere Threads in Anwendungen
Embedded SQL, 211
Java in der Datenbank, 124
Mehrfache Ergebnismengen
ODBC, 304
Mehrzeilige Abfragen
Cursor, 215
Mehrzeilige Abrufe, 218
Mehrzeilige Einfügungen, 218
Mehrzeiliges Speichern, 218
Meldungen
Callback, 263
Server, 263
println
Java in der Datenbank, 79
Methoden
>>, 77
deklarieren, 68
Instanz, 68
Java in der Datenbank, 66
Klasse, 68
private, 72
L–M
481

N–O
protected, 72
public, 72
Punktoperator, 77
statisch, 68
void-Rückgabewert, 125
Microsoft Transaction Server
dreischichtige Datenverarbeitung, 403
Microsoft Visual C++
Unterstützung, 184
MIN, Funktion
Java in der Datenbank, Spalten, 120
Mit Leerzeichen aufgefüllt
Zeichenfolgen in Embedded SQL, 196
Mitgliedschaft
Ergebnismengen, 30
mlxtract, Dienstprogramm
eigenes schreiben, 359
Header-Datei, 359
MobiLink, Synchronisationsserver
Bereitstellung, 422
MSDASQL
OLE DB-Provider, 372
N
name, SQLDA-Feld
Info, 230
Namensbereich
Java in der Datenbank, 141
NetWare
Embedded SQL-Programme, 188
Newsgroups
technische Unterstützung, xv
Nicht-empfindlicher Cursor
Beispiele für Aktualisieren, 34
Beispiele für Löschen, 32
Einführung, 31
Info, 39
NLM
Embedded SQL-Programme, 188
482
NO SCROLL, Cursor
Embedded SQL, 28
Info, 26, 36
ntodbc.h
Info, 280
NULL
Indikatorvariable, 204
Java in der Datenbank, 109
Nullabschlusszeichen für Zeichenfolge
Embedded SQL-Datentyp, 196
NULLWERT
dynamische SQL, 228
O
Objekte
abfragen, 174
abrufen, 172
einfügen, 172
entladen und wieder laden, 132
Java in der Datenbank, 66
Klassenversionen, 131
Replikation, 132
Speicherformat, 107
Speicherung von Java in der Datenbank, 130
Typen, 66
Objektorientierte Programmierung
Java in der Datenbank, 70
Stil, 83
ODBC
Abwärts-Kompatibilität, 279
Anwendungen mit mehreren Threads, 293
Autocommit-Modus, 49, 50
Beispielanwendung, 289
Beispielprogramm, 285
bereitstellen, 427
Cursor, 28, 299
Cursortypen, 26
Datenquellen, 431
Einführung, 278
Einführung in die Programmierung, 2
Ergebnismengen, 304
Fehlerprüfung, 306
gespeicherte Prozeduren, 304
Handles, 287
Header-Dateien, 280

Importbibliotheken, 280
kein Treiber-Manager, 284
Kompatibilität, 279
linken, 280
mehrfache Ergebnismengen, 304
programmieren, 277
Registrierungseinträge, 431
SQL-Anweisungen, 10
Treiber bereitstellen, 428
UNIX-Entwicklung, 282, 284
unterstützte Version, 278
Übereinstimmung, 278
vorbereitete Anweisungen, 297
Windows CE, 281, 282
ODBC, Treiber
UNIX, 283
odbc.h
Info, 280
ODBC-Einstellungen
bereitstellen, 428, 430
OLE DB
Adaptive Server Anywhere, 372
Aktualisierungen, 379
bereitstellen, 426
Cursor, 28, 379
Cursortypen, 26
Einführung in die Programmierung, 3
Info, 372
ODBC und, 372
Provider bereitstellen, 426
unterstützte Plattformen, 372
unterstützte Schnittstellen, 382
OLE, Transaktionen
dreischichtige Datenverarbeitung, 402
Online-Sicherungen
Embedded SQL-Funktionen, 247
Open Client
Adaptive Server Anywhere-Einschränkungen,
398
Anforderungen, 390
autocommit-Modus, 49, 50
Cursortypen, 26
Datentypbereiche, 392
Datentypen, 391
Datentyp-Kompatibilität, 391
Einführung, 6
Open Client-Anwendungen bereitstellen, 436
SQL, 394
SQL-Anweisungen, 10
OPEN, Anweisung
Info, 215
OpenClient
Einschränkungen, 398
Schnittstelle, 389
ORDER BY, Klausel
Java in der Datenbank, Spalten, 120
OUT, Parameter
Java in der Datenbank, 127
P
Pakete
installieren, 105
Java, 71
Java in der Datenbank, 81
jConnect, 151
Performance
Cursor, 43, 44
Java in der Datenbank, Werte, 130
JDBC, 171
JDBC-Treiber, 145
vorbereitete Anweisungen, 12, 297
Personal Server
bereitstellen, 441
Plattenspeicher
Java in der Datenbank, Werte, 130
Plattformen
Cursor, 26
Java in der Datenbank, 59
Platzhalter
dynamische SQL, 223
Positionsbasierte Lösch-Vorgänge, 24
Positionsbasierte Updates
Info, 21
Positionsbasierte Update-Vorgänge, 24
Präprozessor
ausführen, 184
Info, 182
P–P
483

Q–R
Prefetch
Cursor, 44
Cursor-Performance, 43
PREFETCH, Option
Cursor, 44
Prefetch-Vorgänge
mehrere Zeilen abrufen, 22
PREPARE TRANSACTION, Anweisung
und OpenClient, 398
PREPARE, Anweisung, 223
PreparedStatement, Klasse
setObject-Methode, 114
PreparedStatement, Schnittstelle
Info, 171
prepareStatement, Methode, 14
Primärschlüssel
Java in der Datenbank, Spalten, 120
Private
Java-Zugriff, 72
Programmeinstiegspunkte
DBTools-Funktionen aufrufen, 315
Programmstruktur
Embedded SQL, 187
Protected
Java, 71
Java-Zugriff, 72
Prozedur nicht gefunden, Fehlermeldung
Java-Methoden, 168
Prozeduren
Embedded SQL, 243
Ergebnismengen, 244
ODBC, 304
Public
Java-Zugriff, 72
Public, Felder
Wichtiges, 83
Punkt-Operator
Java und SQL, 77
PUT, Anweisung, 24
mehrzeilig, 218
weit, 218
484
PUT, Vorgang, 24
Q
QUOTED_IDENTIFIER, Option
jConnect-Einstellung, 154
R
Recordset-Objekt
ADO, 377, 379
Registrierung
bereitstellen, 428, 430
ODBC, 431
REMOTEPWD
verwenden, 153
Replikation
Java in der Datenbank, Objekte, 132
Reservierte Wörter
SQL und Java in der Datenbank, 81
Ressourcen-Manager
dreischichtige Datenverarbeitung, 402
Info, 400
Ressourcen-Verteiler
dreischichtige Datenverarbeitung, 402
ROLLBACK TO SAVEPOINT, Anweisung
Cursor, 52
ROLLBACK, Anweisung
Cursor, 52
rt.jar
Laufzeitklassen, 97
Rückgabecodes, 316
ODBC, 306
Rückrufe
DB_CALLBACK_CONN_DROPPED, 262
DB_CALLBACK_FINISH, 262
DB_CALLBACK_MESSAGE, 263
DB_CALLBACK_START, 262
DB_CALLBACK_WAIT, 262

S
Savepoints
Cursor, 52
Schlüsselmengen-gesteuerte Cursor
Info, 40
ODBC, 28
Schlüsselwörter
SQL und Java in der Datenbank, 81
Schnittstelle
Java, 73
Schnittstellenbibliothek
Dateiname, 182
dynamisch laden, 187
Info, 182
Schreibgeschützte Cursor
Info, 26
Schreibschutz
Datenbanken bereitstellen, 439
SCROLL, Cursor
Embedded SQL, 28
Info, 26, 40
SecurityManager, Klasse
Info, 128, 129
SELECT, Anweisung
dynamisch, 226
einzelne Zeilen, 214
Java in der Datenbank, 117
JDBC, 169
Objekte, 172
Serialisierung
Java in der Datenbank, Objekte, 130
Objekte, 175
Objekte in Tabellen, 107
verteilte Datenverarbeitung, 176
Server
suchen, 268
Serveradressen
Embedded SQL-Funktion, 258
setAutocommit, Methode
Info, 164
setObject, Methode
verwenden, 176
Setup-Programm
dialogfreie Installation, 422
Sicherheit
Java in der Datenbank, 128, 129
Sicherungen
DBBackup, DBTools-Funktion, 323
DBTools-Beispiel, 319
Embedded SQL-Funktionen, 247
Sichtbare Änderungen
Cursor, 31
Software
Rückgabecode, 316
Sortieren
Java in der Datenbank-Objekte, 119
sp_tsql_environment, Systemprozedur
Optionen für jConnect einstellen, 154
Spalten
Java in der Datenbank aktualisieren, 114
Java in der Datenbank, Datentypen, 109
Speicher
Java in der Datenbank, 140
Speicherung
Java in der Datenbank, Objekte, 130
Sprachen
Dateinamen, 417
Sprachen-DLL
erhalten, 417
spt_mda, gespeicherte Prozedur
Optionen für jConnect einstellen, 154
SQL
ADO-Anwendungen, 10
Anwendungen, 10
Embedded SQL-Anwendungen, 10
JDBC-Anwendungen, 10
ODBC-Anwendungen, 10
Open Client-Anwendungen, 10
SQL Anywhere Studio
Dokumentation, viii
SQL Remote
bereitstellen, 442
Java in der Datenbank, Objekte, 132
S–S
485

S–S
SQL, Kommunikationsbereich
Info, 208
SQL/92
SQL-Präprozessor, 250
SQL_ATTR_MAX_LENGTH, Attribut
Info, 300
SQL_CALLBACK, Typendeklaration, 261
SQL_CALLBACK_PARM, Typendeklaration, 261
SQL_ERROR
ODBC-Rückgabewert, 306
SQL_INVALID_HANDLE
ODBC-Rückgabewert, 306
SQL_NEED_DATA
ODBC-Rückgabewert, 306
sql_needs_quotes, Funktion
Info, 270
SQL_NO_DATA_FOUND
ODBC-Rückgabewert, 306
SQL_SUCCESS
ODBC-Rückgabewert, 306
SQL_SUCCESS_WITH_INFO
ODBC-Rückgabewert, 306
SQL92
SQL-Präprozessor, 250
SQLAllocHandle, ODBC-Funktion
Anweisungen ausführen, 294
Info, 287
Parameter binden, 295
verwenden, 288
SQL-Anweisungen
ausführen, 394
SQLBindCol, ODBC-Funktion
Info, 299, 300
SQLBindParameter, ODBC-Funktion, 14
gespeicherte Prozeduren, 304
Info, 295
Vorbereitete Anweisungen, 297
SQLBrowseConnect, ODBC-Funktion
Info, 290
486
SQLCA
ändern, 211
Felder, 208
Info, 208
Länge von, 208
mehrere, 211, 212
Threads, 211
sqlcabc SQLCA, Feld
Info, 208
sqlcaid
SQLCA-Feld, 208
sqlcode SQLCA, Feld
Info, 208
SQLConnect, ODBC-Funktion
Info, 290
SQLCOUNT
sqlerror SQLCA-Feldelement, 209
sqld, SQLDA-Feld
Info, 229
SQLDA
Deskriptoren, 48
Felder, 229
freigeben, 269
füllen, 269
Hostvariable, 230
Info, 223, 228
sqllen-Felder, 232
Zeichenfolgen, 269
zuweisen, 253
sqlda_storage, Funktion
Info, 271
sqlda_string_length, Funktion
Info, 271
sqldabc, SQLDA-Feld
Info, 229
sqldaif, SQLDA-Feld
Info, 229
sqldata, SQLDA-Feld
Info, 230
sqldef.h
Datentypen, 196
SQLDriverConnect, ODBC-Funktion
Info, 290

sqlerrd SQLCA, Feld
Info, 209
sqlerrmc SQLCA, Feld
Info, 209
sqlerrml SQLCA, Feld
Info, 209
sqlerror SQLCA, Feld
Elemente, 209
SQLCOUNT, 209
SQLIOCOUNT, 209
SQLIOESTIMATE, 211
SQLError, ODBC-Funktion
Info, 306
sqlerror_message, Funktion
Info, 271
sqlerrp SQLCA, Feld
Info, 209
SQLExecDirect, ODBC-Funktion
gebundene Parameter, 295
Info, 294
SQLExecute, ODBC-Funktion, 14
SQLExtendedFetch, ODBC-Funktion
gespeicherte Prozeduren, 304
Info, 300
SQLFetch, ODBC-Funktion
gespeicherte Prozeduren, 304
Info, 300
SQLFreeHandle, ODBC-Funktion
verwenden, 288
SQLFreeStmt, ODBC-Funktion, 14
SQLGetData, ODBC-Funktion
Info, 299, 300
sqlind, SQLDA-Feld
Info, 230
SQLIOCOUNT
sqlerror SQLCA-Feldelement, 209
SQLIOESTIMATE
sqlerror SQLCA-Feldelement, 211
SQLJ, Standards
Info, 54
sqllen, SQLDA-Feld
DESCRIBE-Anweisung, 232
Info, 230, 232
Werte abrufen, 235
Werte beschreiben, 232
Werte senden, 234
sqlname, SQLDA-Feld
Info, 230
SQLNumResultCols, ODBC-Funktion
gespeicherte Prozeduren, 304
SQLPP
Befehlszeile, 249
Info, 182
SQL-Präprozessor
ausführen, 184
Befehlszeile, 249
Info, 249
SQLPrepare, ODBC-Funktion, 14
Info, 297
SQLRETURN
Typ des ODBC-Rückgabewertes, 306
SQLSetConnectAttr, ODBC-Funktion
Info, 292
SQLSetPos, ODBC-Funktion
Info, 302
SQLSetStmtAttr, ODBC-Funktion
Cursor-Merkmale, 299
sqlstate SQLCA, Feld
Info, 209
SQLtransact, ODBC-Funktion
Info, 289
sqltype, SQLDA-Feld
DESCRIBE-Anweisung, 232
Info, 230
sqlvar, SQLDA-Feld
Info, 229, 230
Inhalt, 230
sqlwarn SQLCA, Feld
Info, 209
Standardausgabe
Java in der Datenbank, 79
S–S
487

T–U
Standards
SQLJ, 54
Standardwerte
Java in der Datenbank, 109
START JAVA, Anweisung
verwenden, 141
Starten
Datenbanken unter Verwendung von jConnect,
153
Statische Methoden
Info, 68
Statische SQL
Info, 223
Statischer Cursor
Info, 36
ODBC, 28
STOP JAVA, Anweisung
verwenden, 141
Strukturverdichten
Header-Dateien, 184
sun, Paket
Laufzeitklassen., 97
Sybase Central
bereitstellen, 437
Datenbnak für Java aktivieren, 101
JAR-Dateien hinzufügen, 105
Java-Klassen hinzufügen, 104
ZIP-Dateien hinzufügen, 105
sybase.sql, Paket
Laufzeitklassen., 97
sybase.sql.ASA, Paket
JDBC 2.0-Funktionen, 147
Sybase-Laufzeitklassen für Java
Info, 97
Symbole
in Handbüchern, xii
System Management Server
Systemeinführung, 424
Systemeinführung
ODBC-Einstellungen, 428, 430
Registrierungseinstellungen, 428, 430
System Management Server, 424
488
T
Technische Unterstützung
Newsgroups, xv
this
Java in der Datenbank, Methoden, 125
-gn, Option, 124
Threads
Embedded SQL, 211
Java in der Datenbank, 124
ODBC, 278
ODBC-Anwendungen, 293
UNIX-Entwicklung, 282
TIMESTAMP, Datentyp
Konvertierung, 392
Transaction coordinator
EAServer, 407
Transaktionen
Anwendungsentwicklung, 49
Autocommit-Modus, 49, 50
Cursor, 52
Isolationsstufe, 51
ODBC, 289
verteilt, 400, 405
Transaktionsattribut
Komponente, 408
Try, Block
Java, 73
Typen
Objekte, 66
U
Umgebungs-Handle
ODBC, 287
Unchained, Modus
Implementierung, 51
steuern, 50
Transaktionen, 49
Unempfindliche Cursor
Beispiele für Aktualisieren, 34
Beispiele für Löschen, 32
Einführung, 31

Embedded SQL, 28
Info, 36
Unempfindlicher Cursor
Info, 26
Unicode
ODBC, 281
Windows CE, 281
UNIX
Anwendungen mit mehreren Threads, 416
Hinweise zu Bereitstellungsmethoden, 415
ODBC, 282, 283
ODBC-Anwendung, 284
Verzeichnisstruktur, 415
unixodbc.h
Info, 280
Unterstützte Plattformen
OLE DB, 372
Unterstützung
Newsgroups, xv
UPDATE, Anweisung
Java in der Datenbank, 114
positionsbasiert, 24
set-Methoden, 115
Upgrade einer Datenbank, Assistant
Datenbank für Java aktivieren, 101
URL
Datenbank, 153
jConnect, 152
Ü
Überlauffehler
Datentyp-Konvertierung, 392
V
VARCHAR, Datentyp
Embedded SQL, 201
Veraltete Java-Klassen
Info, 75
Verbindungen
ADO-Verbindungsobjekt, 374
Funktionen, 267
jConnect, 153
jConnect-URL, 152
JDBC, 149
JDBC im Server, 161
JDBC-Beispiel, 157, 161
JDBC-Client-Anwendungen, 157
JDBC-Standardwerte, 164
ODBC, programmieren, 291
ODBC-Attribute, 292
ODBC-Funktionen, 290
Verbindungs-Handle
ODBC, 287
Verbindungsobjekt
ADO, 374
Verfügbarkeit
Verbindungen, 262
Verschlüsselung
DBTools-Schnittstelle, 326
Version
Java in der Datenbank, 75
JDBC, 75
JDK, 75
Versionen
Klassen, 131
Versionsnummer
Dateinamen, 416
Verteilte Anwendungen
Beispiele, 176
Info, 174
Voraussetzungen, 174
Verteilte Transaktionen
Architektur, 402, 404
dreischichtige Datenverarbeitung, 402
EAServer, 407
Einbeziehung, 402
Info, 399, 400, 405
Wiederherstellung, 406
Verzeichnisstruktur
UNIX, 415
Visual C++
Unterstützung, 184
Ü–V
489

W–
VM
Java Virtual Machine, 58
starten, 141
stoppen, 141
void
Java in der Datenbank, Methoden, 66, 125
Vorbereiten
zum Festschreiben, 403
Vorbereitete Anweisungen
Bindungsparameter, 13
Cursor, 19
Java in der Datenbank, Objekte, 114
JDBC, 171
löschen, 13
ODBC, 297
Open Client, 394
verwenden, 12
W
Watcom C/C++
Unterstützung, 184
Weite Abrufe, 22
Info, 218
Weite Einfügungen, 218
Wert-empfindlicher Cursor
Beispiele für Aktualisieren, 34
Beispiele für Löschen, 32
Einführung, 31
Info, 40
Wiederherstellung
verteilte Transaktionen, 406
490
Windows CE
dbtool8.dll, 312
Java in der Datenbank nicht unterstützt, 59
ODBC, 281, 282
OLE DB, 372
unterstützte Versionen, 372
Windows-Dienste
Beispielcode, 195
WITH HOLD, Klausel
Cursor, 21
Write-Dateien
bereitstellen, 418
Z
Zeichenfolgen, 251
Datentyp, 271
DT_STRING wird mit Leerzeichen aufgefüllt,
196
Java in der Datenbank, 78
Zeichensatzkonvertierung
JDBC-ODBC-Brücke, 156
Zeilenlänge
SQL-Präprozessor-Ausgabe, 250
Zeilennummern
SQL-Präprozessor, 251
Zip, Dateien
Java, 71
Zugriffsmodifizierer
Java, 72
Zwei-Phasen-Commit
dreischichtige Datenverarbeitung, 402, 403
und OpenClient, 398