Automatische Synchronisierung Ihrer OLTP- und OLAP-Tabellen in Actian X (Ingres 11)

Ein wesentliches Merkmal des jüngsten Updates unserer Hybrid-Datenbank Actian X (Ingres 11) ist die Integration der x100 Analytics Engine und die Unterstützung von x100 Tabellen. Die Ergänzung der unternehmensweiten OLTP-Fähigkeit(OnLine Transaction Processing) von Actian X durch eine erstklassige Analyse-Engine ermöglicht eine neue Klasse von Anwendungen, die OLTP- und Analyseabfragen kombinieren können - wobei jede Anfrage an die entsprechende Ausführungs-Engine weitergeleitet wird.

Die Ingenieure von Actian haben soeben eine Erweiterung für Actian X geliefert, die Unterstützung für X100-Tabellenreferenzen in Datenbankprozeduren bietet. Dadurch können Datenbankprozeduren und Regeln verwendet werden, um Aktualisierungen, Einfügungen und Löschungen gegen X100-Tabellen auszulösen, wenn Einfügungen, Aktualisierungen und Löschungen auf Ingres-Tabellen angewendet werden. Dies bedeutet, dass Sie Ihre OLTP- (Ingres) und OLAP-Tabellen (X100) automatisch synchronisieren können, um neue Transaktionsdaten zu Ihren Analysedaten hinzuzufügen.

Das folgende Beispiel führt Sie durch die Erstellung von zwei Tabellen (airport und airport_X100) und die Erstellung der Datenbankprozeduren und -regeln, die Einfügungen, Aktualisierungen und Löschungen aus der Ingres-Tabelle in die X100-Tabelle spiegeln werden. Schauen Sie es sich an und lassen Sie uns wissen, was Sie davon halten!

Diese Verbesserung wird über einen Patch bereitgestellt, der von esd.actian.com heruntergeladen werden kann hier.

Erstellen Sie eine OLTP-Tabelle (airport) und ein OLAP-Zielanalytische Verarbeitung online) (airport_x100):

CREATE TABLE airport ( ap_id INT, ap_iatacode NCHAR(3) NOT NULL, ap_place NVARCHAR(30), ap_name NVARCHAR(50), ap_ccode NCHAR(2))g
commit; g
CREATE TABLE airport_x100 ( ap_id INT, ap_iatacode NCHAR(3) NOT NULL, ap_place NVARCHAR(30), ap_name NVARCHAR(50), ap_ccode NCHAR(2)) mit structure=x100g
commitg

Zunächst erstellen wir eine Prozedur, mit der wir die Einfügungen von airport in airport_x100 spiegeln können:

CREATE PROCEDURE proc_ins_airport_x100 (apid INT NOT NULL NOT DEFAULT, apiatacode NCHAR(3) NOT NULL NOT DEFAULT, applace NVARCHAR(30) NOT NULL NOT DEFAULT, 
     apname NVARCHAR(50) NOT NULL NOT DEFAULT, apccode NCHAR(2) NOT NULL NOT DEFAULT)
     AS BEGIN
          INSERT INTO airport_x100 ( ap_id, ap_iatacode, ap_place, ap_name, ap_ccode)
          VALUES ( :apid, :apiatacode, :applace, :apname, :apccode);
     ENDg

Nun erstellen wir eine Regel, die bei einer Einfügung in airport automatisch ausgelöst wird und die Prozedur proc_ins_airport_x100 mit jedem Parameter auslöst, der die Spaltenwerte enthält, die Teil der Einfügung in airport waren:

CREATE RULE trg_ins_airport_x100 AFTER INSERT INTO airport
     EXECUTE PROCEDURE proc_ins_airport_x100 (apid = new.ap_id, apiatacode = new.ap_iatacode, applace = new.ap_place, apname = new.ap_name, apccode = new.ap_ccode)g

Wir fügen 4 Zeilen in die OLTP-Tabelle airport ein:

INSERT INTO airport VALUES (50000, 'AAA', 'Vector', 'Aomori', 'AU')g
INSERT INTO airport VALUES (50001, 'AA1', 'Vektor', 'Tegel', 'AU')g
INSERT INTO flughafen VALUES (50002, 'AA2', 'Vektor', 'Tegel', 'NL')g
INSERT INTO airport VALUES (50003, 'AA3', 'Vektor', 'Tegel', 'NL')g

Jetzt sehen wir, ob unsere Ziel-OLAP-Tabelle (airport_x100) aktualisiert worden ist:

select ap_id, ap_iatacode as iatacode, cast(ap_place as varchar(20)) as ap_place, cast(ap_name as varchar(20)) as ap_name, ap_ccode from airport_x100;g

+-------------+--------+--------------------+--------------------+--------+
|ap_id |iatacode|ap_place |ap_name |ap_ccode|
+-------------+--------+--------------------+--------------------+--------+
| 50000|AAA |Vektor |Aomori |AU |
| 50001|AA1 |Vektor |Tegel |AU |
| 50002|AA2 |Vektor |Tegel |NL |
| 50003|AA3 |Vektor |Tegel |NL |
+-------------+--------+--------------------+--------------------+--------+
(4 Zeilen)

Die Einfügungen wurden also automatisch übertragen. Sehen wir uns nun die Aktualisierungen an. Mehrere Regeln, die aufgrund einer einzigen Bedingung ausgelöst werden, haben keine festgelegte Ausführungsreihenfolge. Wir achten also darauf, dass nur eine Regel ausgelöst wird oder dass die Reihenfolge keinen Einfluss auf das Endergebnis hat.

Zunächst erstellen wir eine Prozedur, die die Spalte ap_id von airport_x100 mit dem Wert des Parameters ap_id aktualisiert, wenn die Spalte ap_iatacode von airport_x100 dem Wert des Parameters apiatacodeold entspricht:

CREATE PROCEDURE proc_upd_airport_x100_01 ( apid INT NOT NULL NOT DEFAULT, apiatacodeold NCHAR(3) NOT NULL NOT DEFAULT)
     AS BEGIN
          UPDATE airport_x100 SET ap_id = :apid WHERE ap_iatacode = :apiatacodeold;
     ENDg

Nun erstellen wir die Regel, die die obige Prozedur auslöst. Sie wird nur ausgelöst, wenn die Spalte ap_id in der Tabelle airport aktualisiert wird. Es ist möglich, den neuen und/oder alten Wert aus einer Aktualisierung an die aufgerufene Prozedur zu übergeben:

CREATE RULE trg_upd_airport_x100_01 AFTER UPDATE(ap_id) of airport
     EXECUTE PROCEDURE proc_upd_airport_x100_01 ( apid = new.ap_id, apiatacodeold = old.ap_iatacode)g

Nun erstellen wir eine zweite Aktualisierungsprozedur, die auf ähnliche Weise die Spalte ap_iatacode von airport_x100 mit dem angegebenen Wert bedingt aktualisiert. Diese Tabelle wird nicht nur airport_x100 aktualisieren, sondern auch Popup-Meldungen erzeugen, wenn sie ausgeführt wird. Wir sind nicht auf einzelne Insert-, Delete- oder Update-Anweisungen beschränkt:

CREATE PROCEDURE proc_upd_airport_x100_02 (apiatacode NCHAR(3) NOT NULL NOT DEFAULT, apiatacodeold NCHAR(3) NOT NULL NOT DEFAULT)
     AS
     DECLARE
          str VARCHAR(30) not null;
     BEGIN
          str = 'apiatacode = ' + :apiatacode;
          MESSAGE :str;
          str = 'apiatacodeold = ' + :apiatacodeold;
          MESSAGE :str;
          UPDATE airport_x100 SET ap_iatacode = :apiatacode WHERE ap_iatacode = :apiatacodeold;
     ENDg

Nun erstellen wir eine Regel, die die obige Prozedur auslöst, wenn der ap_iatacode in der Tabelle airport aktualisiert wird:

CREATE RULE trg_upd_airport_x100_02 AFTER UPDATE(ap_iatacode) of airport
     EXECUTE PROCEDURE proc_upd_airport_x100_02 ( apiatacode = new.ap_iatacode, apiatacodeold = old.ap_iatacode)g

Wir fahren damit fort, Verfahren und Regeln zu erstellen, die Aktualisierungen auf andere Spalten in airport_x100 anwenden. Dies ist keine Voraussetzung. Bei Bedarf können mehrere Spalten in einer einzigen Prozedur aktualisiert werden:

CREATE PROCEDURE proc_upd_airport_x100_03 (applace NVARCHAR(30) NOT NULL NOT DEFAULT, apiatacodeold NCHAR(3) NOT NULL NOT DEFAULT)
     AS BEGIN
          UPDATE airport_x100 SET ap_place = :applace WHERE ap_iatacode = :apiatacodeold;
     ENDg

CREATE RULE trg_upd_airport_x100_03 AFTER UPDATE(ap_place) of airport
     EXECUTE PROCEDURE proc_upd_airport_x100_03 ( applace = new.ap_place, apiatacodeold = old.ap_iatacode)g

CREATE PROCEDURE proc_upd_airport_x100_04 (apname NVARCHAR(30) NOT NULL NOT DEFAULT, apiatacodeold NCHAR(3) NOT NULL NOT DEFAULT)
     AS BEGIN
          UPDATE airport_x100 SET ap_name = :apname WHERE ap_iatacode = :apiatacodeold;
     ENDg

CREATE RULE trg_upd_airport_x100_04 AFTER UPDATE(ap_name) of airport
     EXECUTE PROCEDURE proc_upd_airport_x100_04 ( apname = new.ap_name, apiatacodeold = old.ap_iatacode)g

CREATE PROCEDURE proc_upd_airport_x100_05 (apccode NVARCHAR(30) NOT NULL NOT DEFAULT, apiatacodeold NCHAR(3) NOT NULL NOT DEFAULT)
     AS BEGIN
          UPDATE airport_x100 SET ap_ccode = :apccode WHERE ap_iatacode = :apiatacodeold;
     ENDg

CREATE RULE trg_upd_airport_x100_05 AFTER UPDATE(ap_ccode) of airport
     EXECUTE PROCEDURE proc_upd_airport_x100_05 ( apccode = new.ap_ccode, apiatacodeold = old.ap_iatacode)g

Nun werden wir Aktualisierungen unserer Transaktionsdaten in der Flughafentabelle vornehmen, um zu zeigen, wie die oben genannten Verfahren und Regeln automatisch Änderungen auf unsere Analysetabelle airport_x100 anwenden:

update airport set ap_id = 99999 where ap_id = 50000g

Der Select zeigt, dass trg_upd_airport_x100_01 ausgelöst wurde und die Prozedur proc_upd_airport_x100_01 ausgeführt wurde. Die einspaltige Aktualisierung wurde in die Tabelle airport_x100 gespiegelt:

select ap_id, ap_iatacode as iatacode, cast(ap_place as varchar(20)) as ap_place, cast(ap_name as varchar(20)) as ap_name, ap_ccode from airport_x100;g

+-------------+--------+--------------------+--------------------+--------+
|ap_id |iatacode|ap_place |ap_name |ap_ccode|
+-------------+--------+--------------------+--------------------+--------+
| 99999|AAA |Vektor |Aomori |AU |
| 50001|AA1 |Vektor |Tegel |AU |
| 50002|AA2 |Vektor |Tegel |NL |
| 50003|AA3 |Vektor |Tegel |NL |
+-------------+--------+--------------------+--------------------+--------+
(4 Zeilen)

Die nächste Aktualisierung löst die Prozedur proc_upd_airport_x100_02 aus, die ebenfalls eine Meldung anzeigt, wenn sie ausgelöst wird. Wir wenden eine Reihe von Aktualisierungen auf die Flughafentabelle an und wählen dann aus der Analysetabelle airport_x100 aus, um zu zeigen, wie die oben genannten Datenbanken und Regeln automatisch Änderungen an unseren Analysedaten auf der Grundlage von Transaktionen vornehmen, die unsere Transaktionsdaten betreffen:

update airport set ap_iatacode = 'AA9' where ap_iatacode = 'AA1'g

     MESSAGE 0: apiatacode = AA9
     NACHRICHT 0: apiatacodealt = AA1
     (1 Zeile)

select ap_id, ap_iatacode as iatacode, cast(ap_place as varchar(20)) as ap_place, cast(ap_name as varchar(20)) as ap_name, ap_ccode from airport_x100;g

+-------------+--------+--------------------+--------------------+--------+
|ap_id |iatacode|ap_place |ap_name |ap_ccode|
+-------------+--------+--------------------+--------------------+--------+
| 99999|AAA |Vektor |Aomori |AU |
| 50001|AA9 |Vektor |Tegel |AU |
| 50002|AA2 |Vektor |Tegel |NL |
| 50003|AA3 |Vektor |Tegel |NL |
+-------------+--------+--------------------+--------------------+--------+
(4 Zeilen)

update airport set ap_place = 'VectorUPD' where ap_place = 'Vector'g

(4 Zeilen)

select ap_id, ap_iatacode as iatacode, cast(ap_place as varchar(20)) as ap_place, cast(ap_name as varchar(20)) as ap_name, ap_ccode from airport_x100;g

+-------------+--------+--------------------+--------------------+--------+
|ap_id |iatacode|ap_place |ap_name |ap_ccode|
+-------------+--------+--------------------+--------------------+--------+
| 99999|AAA |VectorUPD |Aomori |AU |
| 50001|AA9 |VectorUPD |Tegel |AU |
| 50002|AA2 |VectorUPD |Tegel |NL |
| 50003|AA3 |VectorUPD |Tegel |NL |
+-------------+--------+--------------------+--------------------+--------+
(4 Zeilen)

update airport set ap_name = 'TegelUPD' where ap_name = 'Tegel'g

(3 Zeilen)

select ap_id, ap_iatacode as iatacode, cast(ap_place as varchar(20)) as ap_place, cast(ap_name as varchar(20)) as ap_name, ap_ccode from airport_x100;g

+-------------+--------+--------------------+--------------------+--------+
|ap_id |iatacode|ap_place |ap_name |ap_ccode|
+-------------+--------+--------------------+--------------------+--------+
| 99999|AAA |VectorUPD |Aomori |AU |
| 50001|AA9 |VectorUPD |TegelUPD |AU |
| 50002|AA2 |VectorUPD |TegelUPD |NL |
| 50003|AA3 |VectorUPD |TegelUPD |NL |
+-------------+--------+--------------------+--------------------+--------+
(4 Zeilen)

Jetzt erstellen wir eine Prozedur und eine Regel zur Spiegelung von Löschungen. In vielen Fällen möchten wir historische Daten in unseren Analysetabellen beibehalten, müssen aber möglicherweise aus Gründen der Einhaltung von Vorschriften Zeilen löschen. Die nächste Prozedur und Regel, die wir erstellen, wird automatisch Daten aus airport_x100 löschen, wenn Zeilen aus der Tabelle airport gelöscht werden:

CREATE PROCEDURE proc_del_airport_x100_01 (apiatacodeold NCHAR(3) NOT NULL NOT DEFAULT)
     AS BEGIN
          DELETE from airport_x100 WHERE ap_iatacode = :apiatacodeold;
     ENDg
CREATE RULE trg_del_airport_x100_01 AFTER DELETE FROM airport
     EXECUTE PROCEDURE proc_del_airport_x100_01 (apiatacodeold = old.ap_iatacode)g

delete from airport where ap_iatacode = 'AA9'g

(1 Zeile)

Dieser Select zeigt, dass die aus airport gelöschte Zeile automatisch aus airport_x100 gelöscht wurde:

select ap_id, ap_iatacode as iatacode, cast(ap_place as varchar(20)) as -
     ap_place, cast(ap_name as varchar(20)) as ap_name, ap_ccode from airport_x100;g

+-------------+--------+--------------------+--------------------+--------+
 |ap_id |iatacode|ap_place |ap_name |ap_ccode|
 +-------------+--------+--------------------+--------------------+--------+
 | 99999|AAA |VectorUPD |Aomori |AU |
 | 50002|AA2 |VectorUPD |TegelUPD |NL |
 | 50003|AA3 |VectorUPD |TegelUPD |NL |
 +-------------+--------+--------------------+--------------------+--------+
 (3 Zeilen)

delete from airport where ap_name = 'TegelUPD'g

(2 Zeilen)

Select zeigt, dass 2 aus airport gelöschte Zeilen automatisch aus airport_x100 gelöscht werden:

select ap_id, ap_iatacode as iatacode, cast(ap_place as varchar(20)) as ap_place, cast(ap_name as varchar(20)) as ap_name, ap_ccode from airport_x100;g

+-------------+--------+--------------------+--------------------+--------+
|ap_id |iatacode|ap_place |ap_name |ap_ccode|
+-------------+--------+--------------------+--------------------+--------+
| 99999|AAA |VectorUPD |Aomori |AU |
+-------------+--------+--------------------+--------------------+--------+
(1 Zeile)

Diese Beispiele zeigen grundlegende Spiegelungen von Einfügungen, Aktualisierungen und Löschungen von Transaktions- in Analysetabellen, um Ihnen den Einstieg zu erleichtern. Es lassen sich weitaus ausgefeiltere Datenbankprozeduren erstellen, und die auf Ihre Analysedaten angewendeten Änderungen müssen nicht zwangsläufig eine Spiegelung der Änderungen an Ihren Transaktionsdaten sein. Vielleicht möchten Sie eine Einfügung in Ihre Analysetabelle auslösen, nachdem eine Zeile aus Ihren Transaktionsdaten gelöscht wurde, um ein Protokoll erstellen.

Wir würden uns freuen zu hören, wie Sie Ihre Analysedaten nahtlos und automatisch aus Ihren bestehenden Transaktionstabellen generieren. Bitte posten Sie eine Antwort in unseren Community-Foren und lassen Sie uns wissen, welche coolen Dinge Sie mit der Actian X Hybrid Database machen.

Über Alex Hanshaw

Alex Hanshaw ist Director of Engineering bei Actian und verfügt über mehr als 20 Jahre praktische Erfahrung in der Entwicklung von Lösungen für komplexe Kundenprobleme. Alex Hanshaw ist seit 1997 Mitglied des Ingres Sustaining Engineering Teams und hat sich kontinuierlich um die Lösung von Kundenproblemen in Actian X, Ingres und Vector gekümmert. Er hat zahlreiche Produktverbesserungen betreut, die Ausfallzeiten reduzieren und die Wartung vereinfachen. Alex arbeitet häufig mit Branchenkollegen auf Konferenzen und in Benutzergruppen (z. B. Ingres-Community-Treffen) zusammen, um Best Practices auszutauschen. Setzen Sie sich mit Alex auf LinkedIn in Verbindung, um mehr über seine technischen Vorträge und Beiträge zur Community zu erfahren. Im ActianBlog behandelt Alex Themen wie Datenbankmigrationsstrategien, Leistungsoptimierung und Fehlerbehebung. In seinen aktuellen Beiträgen finden Sie praktische Tipps für den reibungslosen Betrieb Ihrer Datensysteme.