SQL ist eine Sprache, die mit einem Verwaltungssystem für relationale Datenbanken kommuniziert. Dieses System steuert wiederum eine Datenbank, die Geschäftsinformationen in vernetzten Tabellen verwaltet.
Bei EGL besteht sogar die Möglichkeit, die beiden Verfahren zu kombinieren. Sie können über den EGL-Code auf die von EGL generierten SQL-Anweisungen zugreifen und diese ändern (siehe Implizite SQL-Anweisungen anzeigen).
In der folgenden Tabelle wird beschrieben, wie EGL für die Interaktion mit einer relationalen Datenbank verwendet werden kann.
| SQL-Ziel | EGL-Ansatz |
|---|---|
| Einfache SQL-Datenbearbeitung (SELECT, UPDATE, INSERT, DELETE). Primärschlüssel steuert WHERE und ORDER BY. | EGL-Schlüsselwörter (get, replace, add, delete) verwenden und EGL zur Generierung von implizitem SQL veranlassen. |
| Einfache SQL-Datenbearbeitung mit wiederverwendbarer angepasster WHERE-Klausel | Angepasste WHERE-Klausel in die Eigenschaft defaultSelectCondition einfügen. |
| SQL-SELECT-Anweisungen mit angepasster WHERE-Klausel | Explizites SQL über die #sql-Direktive verwenden. |
| SQL-Anweisung JOIN für Tabellen | Die Funktion 'SQL abrufen' in der Workbench verwenden und dann die Tabellen
in Primär- und Fremdschlüsseln mit der Eigenschaft defaultSelectCondition
korrekt verknüpfen:
|
| Abgeleitete Daten in SELECT-Befehl (z. B. MAX() ider AVG()) | Explizites SQL über die #sql-Direktive verwenden und die abgeleiteten Felder in die geschweiften Klammern einfügen. |
| Einen angepassten SQLRecord erstellen, wobei die Eigenschaft column für die einzelnen Felder den abgeleiteten oder berechneten Ausdruck angibt. | |
| Komplexe oder angepasste SQL-Anweisung UPDATE, INSERT oder DELETE | EGL-Anweisung replace, add oder delete mit explizitem SQL verwenden (#sql-Direktive). |
| Explizites SQL über die Anweisung execute #sql verwenden. | |
| Andere SQL-Anweisungen als die für einfache Datenbearbeitung (z. B. CREATE TABLE) | Explizites SQL über die Anweisung execute #sql verwenden. |
| Dynamisches SQL (vorbereitete SQL-Anweisung) | Explizites SQL über die Anweisung execute #sql verwenden. |
| Gespeicherte Prozedur | Explizites SQL verwenden. Beispiel: |
| Verarbeitung einzelner Zeilen der Ergebnisliste über eine SQL-Anweisung SELECT | EGL-Befehl open zum Öffnen der Ergebnisliste verwenden und
anschließend eine Schleife mit einer der folgenden Anweisungen auslösen:
|
| Programmatic Paging für Onlinesuchvorgänge | Assistenten für die Datenzugriffsanwendung verwenden. |
| Hinzufügen von Daten zur SQL-Tabelle | Tabelleneditor in der Datenperspektive der Workbench verwenden. |
| Gültigkeitsprüfung von SQL-Anweisungen | Im EGL-Editor 'Validate SQL' aus dem Kontextmenü auswählen. |
| Interactive SQL mit dem SQL-Editor in der Datenperspektive der Workbench ausführen. |
Die Anweisungen, die den Cursor öffnen und die Zeilen dieses Cursors bearbeiten, stehen über eine Ergebnismengen+++-ID miteinander in Beziehung, die für alle Ergebnismengen-IDs und Programmvariablen innerhalb des Programms eindeutig sein muss. Diese ID wird in der Anweisung open angegeben, die den Cursor öffnet, und sie wird in der Anweisung forEach referenziert, die die Schleife erstellt. Ferner kann die ID in den Anweisungen get next, delete und replace referenziert werden, die eine einzelne Zeile betreffen, sowie in der Anweisung close, die den Cursor schließt.
try
open selectEmp forUpdate for emp;
onException(sqlx SqlException)
myErrorHandler(sqlx); // exits program
end
foreach(emp)
emp.empname = emp.empname :: " " :: "III";
try
replace emp;
onException(sqlx SqlException)
myErrorHandler(sqlx); // exits program
end
end // end while; cursor is closed automatically
// when the last row in the result set is read
sysLib.commit();
Verwenden Sie zum regelmäßigen Festschreiben von Änderungen bei der Verarbeitung einer EGL-Anweisung open (unabhängig davon, ob Sie mit SQL-Datensätzen arbeiten) die Anweisungsoption hold, mit der die Cursorposition nach einer Festschreibung gehalten wird. Wenn ein für CICS bestimmtes Programm jedoch segmentiert ist, hat die Option hold keine Auswirkungen, da eine Umkehrung in einem segmentierten Programm die CICS-Transaktion beendet und das Programm an der Aufbewahrung von Dateien oder Datenbankpositionen hindert.
add myEmpRecord;
try
add myEmpRecord;
onException(sqlx SqlException)
if (myEmpRecord is unique) // if a table row had the same key
myErrorHandler(sqlx);
end
end
Das Definieren eines SQLRecord-Abschnitts und die Zuordnung der einzelnen Felder zu einer Spalte erfolgt in einer relationalen Tabelle oder Ansicht. EGL kann diese Aktionen automatisch ausführen (siehe SQL-Tabellendaten abrufen).
Eine Datenbankspalte kann nur durch Felder eines Basiselementtyps+++ repräsentiert werden.
Nach dem Definieren eines SQLRecord-Abschnitts wird eine Datensatzvariable basierend auf diesem Abschnitt deklariert.
Sie können eine Gruppe von EGL-Anweisungen erstellen, die alle die Datensatzvariable als E/A-Objekt in der Anweisung verwenden. EGL stellt für jede Anweisung eine implizite SQL-Anweisung bereit, die nicht in der Quelle enthalten ist, sondern durch die Kombination von Datensatzvariable und EGL-Anweisung impliziert ist. Beispielsweise fügt eine implizite SQL-Anweisung INSERT im Falle einer EGL-Anweisung add die Werte der Felder in einem Datensatz in die zugeordnete Tabellenspalte ein. Wenn die Datensatzvariable ein Feld enthält, für das keine Tabellenspalte zugeordnet wurde, erstellt EGL die implizite SQL-Anweisung unter der Annahme, dass der Name des Felds dem Namen der Spalte entspricht.
Die folgenden EGL-Anweisungen entsprechen den aufgeführten SQL-Anweisungen:
| EGL-Anweisung | SQL-Anweisung |
|---|---|
| add | INSERT |
| delete | DELETE |
| get, open | SELECT |
| replace | UPDATE |
Record Employee type sqlRecord
{ tableNames = [["EMPLOYEE"]],
keyItems = ["empnum"] }
empnum decimal(6,0);
empname char(40);
end
myEmpRecord Employee;
get myEmpRecord;
SELECT empnum, empname
FROM EMPLOYEE
WHERE empnum = :empnum
INTO :empnum, :empname
Einzelheiten zu impliziten SELECT-Anweisungen finden Sie in den verschiedenen Themen zu Schlüsselwörtern im Handbuch EGL Language Reference+++.
Bei Verwendung von SQL-Datensätzen können Anweisungen zur Cursorverarbeitung unter Verwendung derselben Datensatzvariablen in mehreren EGL-Anweisungen zueinander in Beziehung gesetzt werden. Die Vorgehensweise entspricht dabei weitgehend der Verwendung einer Ergebnismengen-ID. Eine über eine Ergebnismengen-ID angegebene anweisungsübergreifende Beziehung hat jedoch Vorrang vor einer über die Datensatzvariable angegebene Beziehung; in einigen Fällen muss eine Ergebnismengen-ID (resultSetID) angegeben werden.
Darüber hinaus kann für eine bestimmte Datensatzvariable nur ein Cursor geöffnet sein. Wenn eine EGL-Anweisung einen Cursor öffnet, solange ein anderer Cursor für dieselbe Datensatzvariable geöffnet ist, wird der erste Cursor automatisch vom generierten Code geschlossen.
Wenn Sie eine explizite SQL-Anweisung aus der Quelle entfernen, ist die implizite SQL-Anweisung (sofern vorhanden) bei der Generierung erneut verfügbar.
DataItem DeptNo { column = "deptNo" } end
Record Dept type SQLRecord
deptNo DeptNo;
managerID CHAR(6);
employees Employee[];
end
Record Employee type SQLRecord
employeeID CHAR(6);
empDeptNo DeptNo;
end
Function getDeptEmployees(myDeptRecord Dept)
get myDeptRecord.employees usingKeys myDeptRecord.deptNo;
end
Record Employee type SQLRecord
employeeID CHAR(6);
empDeptNo INT?;
end
if (myEmpRecord.empDeptNo == null)
...
end
myEmpRecord.empDeptNo = null;
set myEmpRecord.empDeptNo empty;
| Plattform | Problem |
|---|---|
| CICS für z/OS, z/OS-Stapelbetrieb, iSeriesC | Der generierte Code kann direkt auf DB2 UDB zugreifen. |
| AIX, HP-UX, iSeriesJ, Linux, Solaris, z/OS UNIX System Services, Windows 2000/NT/XP | JDBC bietet Zugriff auf DB2 UDB, Oracle, Informix und Microsoft SQL Server. |