SELECT
SYSDATE AS DATE
FROM
DUAL;
DATE
--------
01.12.22
Dual ist bis 23c eine häufig benötigte Pseudo Tabelle, da der Oracle SQL-Interpreter eine FROM-Klausel zwangsläufig erwartet und sonst „ORA-00923: Schlüsselwort FROM nicht an erwarteter Stelle gefunden“ auswirft. Mit 10g R2 wurde Dual von einer physischen Tabelle die DML-Statements ermöglichte, zur einer logische Pseudo Tabelle. Mit 23c verliert die Dual Tabelle auch die Bedeutung im SQL-Kontext, wodurch obiges Statement in Zukunft so gekürzt werden kann.
SELECT
SYSDATE AS DATE;
DATE
--------
01.12.22
Die zurzeit sehr beliebt und verbreitet Skriptsprache JavaSkript hatte bereits mit 21c ihren Weg in die Oracle Datenbank gefunden. Die Integration von JavaSkript in 21c verursachte einiges an Kritik. Der größte Kritikpunkt war, die manuelle Verwaltung von ressourcenintensiven Runtime Environments. Oracle ist auf die Kritik eingegangen und hat die Implantation von Java Skript für 23c überarbeitet.
Um JavaSkript Code in einer 23c Datenbank zu speichern, erstellt man ein MLE-Modul, welches man eine oder mehrere JS-Funktionen anhängen kann. MLE steht für „Multi Language Engine“, wodurch sich erklären lässt, dass man bei der Erstellung eines MLE-Modules als Sprache Java Skript angeben muss. Aktuell ist für dieser Technik jedoch nur JS bestätigt, sofern es sich durchsetzt, könnten weitere Sprachen folgen.
Als Beispiel erstellen wir ein MLE-Modul mit dem Namen „MY_JS_MOD“ und hängen diesen zwei Funktionen an. Erstere soll „conca“ heißen und verkettet zwei Zeichenketten miteinander. Zweitere soll zwei Zahlen addieren und entsprechend auf den Namen „add“ hören.
Für die Code Beispiele dieses Abschnittes gilt folgendes:
Schwarze Schrift: PL/SQL Code
Grüne Schrift: Java Skript Code
CREATE
MLE MODULE MY_JS_MOD
LANGUAGE
JAVASCRIPT
AS
export function conca(str1, str2)
{ return str1 + str2; }
export function add(num1, num2)
{ return num1 + num2; }
Um eine der JS-Funktionen für SQL-Statements zu benutzen, müssen wir eine PL/SQL Funktionen erstellen, welche dann auf die in JavaSkript geschriebene Funktionen verweisen. Als Beispiel erstellen wir eine Funktion mit PL/SQL Namens „JS_CONCA“, die auf die Funktion „conca“ von unserem MLE-Modul „MY_JS_MOD“ verweist. Wichtig ist bei solchen Statements, dass beim Konstruktor sowie in der RETURN-Klausel mit Oracle Datentypen und in der SIGNATURE-Klausel mit JS-Datentypen gearbeitet wird.
CREATE
FUNCTION JS_CONCA(STR1 IN NUMBER, STR2 IN NUMBER)
RETURN
VARCHAR2
AS
MLE MODULE MY_JS_MOD
SIGNATURE
'conca(string, string)';
SELECT
JS_CONCA(2, 2) AS RESULT;
RESULT
----------------
22
Dieses Feature wird es ermöglichen, dass mehr Entwickler, z. B. unausgelastete Webentwickler mit für eine Datenbank entwickeln können. Ein weiterer interessanter Punkt wird sein, inwiefern Oracle einen „Package Manager“ wie z .B. NPM mit implementiert. Sollte man auf beliebte Pakete von JS zugreifen können, so gäbe es für die Entwickler zusätzlich eine größere verwendbare Codebasis.
Vor Version 23c wurden Werte, welche in Tabellen geändert werden, gesperrt bis die getätigten Änderungen mittels „COMMIT“ bestätigt oder per „ROLLBACK“ zurückgerollt werden. Erst danach konnte man wieder mittels einer anderen Session auf die Daten schreibend zugreifen. Mit 23c ändert sich dieses grundlegende Prinzip, sodass von mehreren Sessions aus gleichzeitig schreibend auf dieselben Daten zugegriffen werden kann. Geht man mal beispielsweise davon aus, dass das Gehalt von „CLARK“ aus der Tabelle EMP parallel von der Buchhaltung um 50 und von seinem Manager um 500 gesteigert wird, so könnte es wie folgt ablaufen.
Session A der Buchhaltung um 10:00 Uhr:
SELECT
SAL
FROM
EMP
WHERE
ENAME = 'CLARK';
SAL
----------
2450
UPDATE
EMP E
SET
SAL = SAL+50
WHERE
ENAME='CLARK';
Session B des Managers um 10:05 Uhr:
UPDATE
EMP E
SET
SAL = SAL+500
WHERE
ENAME='CLARK';
COMMIT;
SELECT
SAL
FROM
EMP
WHERE
ENAME = 'CLARK';
SAL
----------
2950
Session A der Buchhaltung um 10:10 Uhr:
COMMIT;
SELECT
SAL
FROM
EMP
WHERE
ENAME = 'CLARK';
SAL
----------
3000
Weiteres zu diesem Thema wird in zukünftigen Beiträgen thematisiert.
23c wird das Arbeiten mit JSON-Inhalten durch neue Features vereinfachen.
Die „JSON Relation Duality“ ist ein neues Feature, welches eine Schnittstelle bildet, wie Datenbanken und Anwendungen Daten verwenden. Daten, die mittels dieser Neurungen gespeichert werden, können dann mittels SQL, HTTP-Request und einigen anderen Arten aufgerufen werden. Genauer darauf einzugehen, würde den Rahmen dieses Beitrags sprengen.
Zusätzlich können JSON-Inhalte innerhalb der Oracle Datenbank auf ihre Richtigkeit geprüft werden, wenn diese nicht korrekt sind, bekommt man umfangreichen und hilfreichen Output.
SQL-Domänen sind als selbst definierte und zentral gespeicherte Datentypen zu sehen. PostgreSQL Nutzern sollten SQL-Domänen schon bekannt sein, Mit Version 23c kriegt man diese ebenfalls unter Oracle. Diese sind syntaktisch leicht abgeändert, jedoch im Kern dasselbe wie unter PostgreSQL.
Oracle erweitert exklusiv die SQL-Domänen um eine DISPLAY und ORDER-Klausel, deren Inhalt durch einen Aufruf der Methoden „DOMAIN_DISPLAY“ und „DOMAIN_ORDER“ genutzt werden kann. In der Display-Klausel kann man eine alternative Darstellung definieren und unter der Order-Klausel eine alternative Sortierung. Als Beispiel erstellen wir eine SQL-Domäne für Hausnummern, wie sie in Deutschland verbreitet sind. Entscheidend ist hier die Constraint-Klausel, welche durch einen Vergleich mit einen Regulären Ausdruck die Werte auf maximal drei Ziffern und einen oder keinen Buchstaben limitiert. Bei der Display-Klausel legen wir eine alternative aufbereitete Darstellungsweiße fest. Zuletzt legen wir in der ORDER-Klausel fest, dass alternative erst nach der Zahl der Ausnummer sortiert wird und danach nach den Buchstaben.
CREATE DOMAIN FULL_HOUSE_NR AS VARCHAR2(4)
CONSTRAINT POS_HOUSE_NR CHECK (
REGEXP_LIKE (FULL_HOUSE_NR, '^[0-9]{1,3}[a-z]?$'))
DISPLAY
'NR. ' ||
NVL(SUBSTR(HAUS_NR, 1, REGEXP_INSTR(HOUSE_NR, '[a-z]')-1), HOUSE_NR) ||
' Letter: ' ||
NVL(REGEXP_SUBSTR(HOUSE_NR, '[a-z]'), 'NON')
ORDER
NVL(SUBSTR(HOUSE_NR, 1, REGEXP_INSTR(HOUSE_NR, '[a-z]')-1), HOUSE_NR) ||
NVL(REGEXP_SUBSTR(HOUSE_NR, '[a-z]'), 'non');
Erstellen wir mal eine Beispiel Tabelle Immobilien, die die Spalte „HOUSE_NR“ enthält, welche der eben erstellten SQL-Domäne zugeordnet wird. Danach wurden vier gültige Datensätze hinzugefügt.
CREATE TABLE IMMOBILIEN (
I_ID NUMBER(25) NOT NULL PRIMARY KEY,
STREET VARCHAR2(70) NOT NULL,
HOUSE_NR VARCHAR2(4) DOMAIN FULL_HOUSE_NR);
Eine Abfrage über sämtlichem Daten mit Sortierung nach der Hausnummer könnte wie folgt aussehen.
I-ID STREET HOUSE_NR
---- -------------------------- ----------
2 Hauptstraße 11a
3 Kirchwaldweg 11
1 Leipziger Straße 5
4 Geschwister-Soll-Straße 60b
Wie es zu erwarten war macht hier die Sortierung nach Hausnummern keinen Sinn, dies hängt damit zusammen das Aufgrund des Datentyps VARCHAR2 alphanumerisch sortiert wird. Für diesen Zweck wurde unter der ORDER-Klausel der Domäne eine angepasste Sortierung definiert, die wir über den Aufruf der Methode DOMIAN-ORDER verwenden. Bei der Selection nützen wir zusätzlich die Methode DOMAIN-DISPLAY um die selbst definierte Darstellweiße für die Domäne zu nutzen.
SELECT
I_ID,
STREET,
DOMAIN_DISPLAY(HOUSE_NR)
FROM
IMMOBILIEN
ORDER BY
DOMAIN_ORDER(HOUSE_NR);
I-ID STREET HOUSE_NR
---- ----------------------- ------------
1 Leipziger Straße Nr. 5 Letter: non
3 Kirchwaldweg Nr. 11 Letter: non
2 Hauptstraße Nr. 11 Letter: a
4 Geschwister-Soll-Straße Nr. 60 Letter: b
Mal angenommen wir wollen allen Mitarbeitern der Tabelle EMP, welche laut Tabelle SALGRADE sich auf der niedrigsten Gehaltstufe befinden, das Gehalt um 10%t erhöhen,. Das Problem hierbei ist, dass die Tabelle EMP keine Informationen zu Gehaltstufen enthält, diese müssen von der Tabelle SALGRADE entnommen werden. Einer der möglichen Wege ist es, mittels Unterabfrage die Ober- und Untergrenze der niedrigsten Gehaltstufe abzufragen und diese mit den Gehalt entsprechend zu vergleichen.
UPDATE
EMP E
SET
E.SAL = E.SAL*1.1
WHERE
SAL BETWEEN (
SELECT
HISAL
FROM
SALGRADE
WHERE
GRADE = 1
)
AND(
SELECT
LOSAL
FROM
SALGRADE
WHERE
GRADE = 1
);
23c wird es ermöglichen in UPDATE-Statement Tabellen via „JOIN“ zu verbinden, wodurch als Resultat UPDATE-Statement einfacher und kürzer werden können, bei unserem Beispiel schaut es wie folgt aus.
UPDATE
EMP E
SET
E.SALARY = E.SALARY*1.1
FROM
SALGRADE S
WHERE
E.SAL BETWEEN S.LOSAL AND S.HISAL
AND
S.GRADE=1;
In diesem Beispiel wird die Anzahl der Mitarbeiter gebraucht, die ein jährliches gerundetes Gehalt von 30.000 Euro haben. Eine der Lösungen ist folgendes SQL-Statement..
SELECT
COUNT(*) AS AMOUNT,
ROUND((SAL+NVL(COMM,0))*12, -4) AS ROUNDED_SAL_PER_YEAR
FROM
EMP
GROUP BY
ROUND((SAL+NVL(COMM,0))*12, -4)
HAVING
ROUND((SAL+NVL(COMM,0))*12, -4) = 30000;
Wenn man sich das obere Statement ansieht, kommt einem schnell der Gedanke, dass es unschön ist, im Statement dreimal denselben Code stehen zu haben. Das gezeigte Statement konnte bis 21c nur bedingt gekürzt werden, indem man bei der Group By Klausel die Spaltenzahl aus der SELECT-Klausel nach der gruppiert werden soll, angibt.
Oracle 23c wird es uns ermöglichen das Statement weiter zu kürzen, da man bei der Group By und Having-Klausel ab sofort den Spalten Alias verwenden kann, was die Störanfälligkeit gegen Änderungen der Spalten Reihenfolge unserer Sonderlösung ausmerzt und in folgendes Statement resultiert.
SELECT
COUNT(*) AS AMOUNT,
ROUND((SAL+NVL(COMM,0))*12, -4) AS ROUNDED_SAL_PER_YEAR
FROM
EMP
GROUP BY
ROUNDED_SAL_PER_YEAR
HAVING
ROUNDED_SAL_PER_YEAR = 30000;
GRANT SELECT ON
PROD.CUSTOMERS,
PROD.PAYMENTS,
…
TO SOMEBODY;
Welcher DBA kennt und hasst es nicht:
Man muss jedes Recht auf jede einzelne Tabelle eines Schemas vergeben. Zum Glück ist das ab 23c Geschichte, da man ab dann, Rechte auf Schemaebene vergeben kann.
GRANT SELECT ANY TABLE
ON SCHEMA PROD
TO SOMEBODY;
Bis 23c musste man in Skripten und Funktion beim Erstellen und Löschen von Tabellen mit Exception Handling arbeiten, sobald es für den Programmablauf nicht mehr klar war, ob eine Tabelle bereits existiert. Was z. B.für folgenden Code Block für das Löschen von Tabellen sorgte.
BEGIN
EXECUTE IMMEDIATE 'DROP TABLE TEST_TABLE’;
EXCEPTION
WHEN OTHERS THEN
IF SQLCODE != -942 THEN
RAISE;
END IF;
END;
/
Ganz schön viel Code, um abbrechenden Abläufe aufgrund von ORA-00942 zu verhindern. Mit 23c wird für DROP-Statements der Ausdruck „IF EXIST“ hinzugefügt, der den oberen Code obsolet werden lässt.
DROP TABLE IF EXIST TEST_TABLE;
Vor 23c gab es fast dasselbe Problem beim Erstellen von Tabellen. Einziger Unterschied, das es sich um die ORA-00955 Meldung handelte. Mit der neuen Datenbank Version 23c gibt es auch hierfür eine Lösung.
CREATE TABLE IF NOT EXIST TEST_TABLE (
…);
Im Folgenden werden die weiteren Features in Stichpunkten zusammengefasst, die meisten sind selbsterklärend, für andere ist eine eigener Tipp notwendig.
Oracle 23c hat zahlreiche neue Features, somit sollte für jeden, egal ob Administrator oder Entwickler, etwas dabei sein. Es lohnt sich den neuen Release der Oracle Datenbank im Auge zu behalten. Der aktuelle Stand ist das 23c bis Ende Februar in der Betaphase bleiben soll, somit wird bis zur Veröffentlichung dieses Releases noch einige Monate vergehen. Wie bei jeder anderen Software sollte man ein paar Monate nach der Veröffentlichung warten, bevor man mit einer Migration auf die eigene produktive Umgebung beginnt.
In unserer Know-How Datenbank finden Sie mehr als 300 ausführliche Beiträge zu den
Oracle-Themen wie DBA, SQL, PL/SQL, APEX und vielem mehr.
Hier erhalten Sie Antworten auf Ihre Fragen.
