Jun 08, 2012, updated at 16:47:21 (UTC)

7510

SQL Migration von MySQL zu Oracle

Viele der Beispiele habe ich mir aus verschiedenen Quellen zusammen gesucht und angepasst.

Inhaltsverzeichnis

Leere Zeichenketten werden zu NULL

Sortierung bei leeren Zeichenketten

Ergebnis Menge einschränken - LIMIT

einfach Menge einschränken

Mengen Bereiche abfragen

Zeitstempel - UNIX Timestamps

CONVERT_TZ()

FROM_UNIXTIME()

UNIX_TIMESTAMP()

Gruppierungen in Abfragen

Ersatz für "erstes Element der Gruppe"

Ersatz für GROUP_CONCAT()

Anwendung der neuen Aggregat Funktionen

Auto Increments

Last Insert ID

Schlusswort

Leere Zeichenketten werden zu NULL

In Oracle werden leere Zeichenketten als NULL gespeichert bzw interpretiert. Dies hat unmittelbar Auswirkungen auf Sortierungen und auch das Tabellen Schema selbst.

Sortierung bei leeren Zeichenketten

Während in MySQL eine leere Zeichenkette bei einem Sortiervorgang als kleinstes Ergebniss zurück gegeben wird, existiert dieser Datensatz in Oracle nur als NULL und wird als letztes zurück gegeben.

ORDER BY "feld" NULLS FIRST  
/* oder */
ORDER BY "feld" DESC NULLS LAST  

ist eine mögliche Lösung

Ergebnis Menge einschränken - LIMIT

Oracle kennt das LIMIT nicht, hat dafür aber das ROWNUM Token. Dabei ist aber zu beachten, das dies nur eingeschränkt nutzbar ist.

einfach Menge einschränken

WHERE ROWNUM <= 10

einfacher Ersatz für LIMIT 10

Mengen Bereiche abfragen

SELECT * FROM (
SELECT "TMP".*, ROWNUM AS "RN" FROM (  
/* die eigentliche Abfrage kommt hier rein */
) "TMP"  
)
WHERE "RN" >= 10 AND ROWNUM <= 5  

Ersatz für LIMIT 10,5

Zeitstempel - UNIX Timestamps

Oracle besitzt zwar ein TIMESTAMP Datentyp, dieser ist aber nicht unmittelbar kompatibel mit dem Integer Wert aus der MySQL DB.

CONVERT_TZ()

Diese Funktion ersetzt die unter MySQL bekannte Funktion CONVERT_TZ():

CREATE OR REPLACE FUNCTION F_CONVERT_TZ (oracle_date IN DATE, tz_from IN varchar, tz_to IN varchar)
RETURN DATE
IS
	return_date DATE;
BEGIN
	return_date := CAST( (FROM_TZ(CAST(oracle_date AS TIMESTAMP), tz_from) AT TIME ZONE tz_to) AS DATE);
	RETURN return_date;
END;

FROM_UNIXTIME()

Diese Funktion ersetzt die unter MySQL bekannte Funktion FROM_UNIXTIME():

CREATE OR REPLACE FUNCTION F_FROM_UNIXTIME(unixts IN PLS_INTEGER)
RETURN DATE
IS
	unix_epoch DATE := TO_DATE(19700101000000,'YYYYMMDDHH24MISS');  
	max_ts PLS_INTEGER := 2145916799;
	min_ts PLS_INTEGER := -2114380800;
	oracle_date DATE;
BEGIN
	IF unixts > max_ts THEN
		RAISE_APPLICATION_ERROR( -20901, 'UNIX timestamp too large for 32 bit limit');  
	ELSIF unixts < min_ts THEN
		RAISE_APPLICATION_ERROR( -20901, 'UNIX timestamp too small for 32 bit limit');  
	ELSE
		IF unixts IS NULL THEN
			oracle_date := SYSDATE;
		ELSE
			oracle_date := unix_epoch + NUMTODSINTERVAL(unixts, 'SECOND');  
		ENDIF;
	END IF;

	RETURN oracle_date;
END;

UNIX_TIMESTAMP()

Diese Funktion ersetzt die unter MySQL bekannte Funktion UNIX_TIMESTAMP():

CREATE OR REPLACE FUNCTION F_UNIX_TIMESTAMP(oracle_date IN DATE DEFAULT SYSDATE)
RETURN integer
IS
	unix_epoch DATE := TO_DATE(19700101000000,'YYYYMMDDHH24MISS');  
	timestamp PLS_INTEGER;
BEGIN
	timestamp := FLOOR((oracle_date - unix_epoch) * 86400);
	RETURN timestamp;
END;

Gruppierungen in Abfragen

Oracle ist nicht so tolerant wie MySQL und duldet es nicht wenn in SELECT Felder verwendet werden, die weder in GROUP BY verwendet noch in einer Agregat Funktion stehen.

Ersatz für "erstes Element der Gruppe"

Dies ist das Standard Verhalten von MySQL wenn ein Feld weder gruppiert werden soll, noch in einer Aggregat Funktion steht. Um das Erste Element bei einer Gruppierung zu erhalten hilft diese Funktion:

CREATE OR REPLACE FUNCTION AF_FIRST(data in varchar2_t)
RETURN varchar2
AS
	ret varchar2(2000) := '';  
BEGIN
	IF data IS EMPTY THEN
		RETURN NULL;
	ELSE
		ret := data( data.FIRST );
		data.DELETE;
		RETURN ret;
	END IF;
END;

Ersatz für GROUP_CONCAT()

Diese Funktion ersetzt die unter MySQL bekannte Aggregat Funktion GROUP_CONCAT():

CREATE OR REPLACE FUNCTION AF_GROUP_CONCAT(data in varchar2_t, seperator in varchar2 DEFAULT ', ')  
RETURN varchar2
AS
	ret varchar2(2000) := '';  
	i number;
BEGIN
	IF data IS EMPTY THEN
		RETURN NULL;
	ELSE
		FOR i IN data.FIRST .. data.LAST
		LOOP
			IF data(i) IS NOT NULL THEN
				IF ret IS NOT NULL THEN
					ret := ret || seperator;
				END IF;
				ret := ret || data(i);
			END IF;
		END LOOP;
		data.DELETE;
		RETURN ret;
	END IF;
END;

Anwendung der neuen Aggregat Funktionen

Um die zuvor genannten Funktionen nutzen zu können, wird noch ein Tabellen Datentyp benötigt um die zu gruppierenden Daten auf zu nehmen.

CREATE OR REPLACE TYPE varchar2_t AS TABLE OF varchar2(2000)

Jetzt kann man die Funktionen compilieren und verwenden.

SELECT
	AF_FIRST( CAST(COLLECT(CAST("STRING" AS varchar2(100))) AS varchar2_t) ) AS "AF_FIRST",  
	AF_GROUP_CONCAT( CAST(COLLECT(CAST("STRING" AS varchar2(32))) AS varchar2_t), ' - ' ) AS "AF_GROUP_CONCAT",  
/* ... */

Auto Increments

Auto Increments werden über Sequenzen realisiert.

CREATE SEQUENCE "SCHEMA"."seq_TABELLE"  
	START WITH 1
	INCREMENT BY 1
	NOMINVALUE
	NOMAXVALUE
	CACHE 20;
/
CREATE OR REPLACE TRIGGER "SCHEMA"."tri_TABELLE" BEFORE INSERT  
ON "SCHEMA"."TABELLE" FOR EACH ROW  
BEGIN
	IF :NEW."FELD_ID" IS NULL THEN  
		:NEW."FELD_ID" := "seq_TABELLE".NEXTVAL;  
	END IF;
END;
/
CREATE OR REPLACE TRIGGER "SCHEMA"."tru_TABELLE" AFTER UPDATE OF "FELD_ID"  
ON "SCHEMA"."TABELLE" FOR EACH ROW  
BEGIN
	RAISE_APPLICATION_ERROR( -20010, 'Cannot update column "FELD_ID" in table "TABELLE" as it uses sequence "seq_TABELLE".' );  
END;

Der INSERT Trigger im Beispiel Code, beinhaltet die IF Abfrage um eine Rückgabe der LAST_INSERT_ID zu realisieren.

Last Insert ID

Beispiel:

BEGIN
	SELECT "seq_TABELLE".NEXTVAL INTO :LAST_INSTERT_ID FROM DUAL;  
	INSERT INTO "TABELLE" (  
		"FELD_ID"  
	) VALUES(
		:LAST_INSTERT_ID
	);
END;

die :LAST_INSTERT_ID ist ein SQL Parameter und kann so abgefragt werden.

Schlusswort

Dies sollte alles nur als "Notlösung" betrachtet werden um ein möglichst schnellen Umzug zu erlauben. Man sollte immer versuchen seine Anwendung auf die jeweilige Datenbank zu optimieren und nicht die Datenbank an die Anwendung anzupassen.