{"id":55000470,"date":"2007-08-01T00:00:00","date_gmt":"2021-02-11T21:17:04","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=470"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Temporaere_Datenbanken_in_der_Praxis","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Temporaere_Datenbanken_in_der_Praxis\/","title":{"rendered":"Temporäre Datenbanken in der Praxis"},"content":{"rendered":"

\"\"<\/p>\n

In der letzten Ausgabe haben Sie erfahren, wie einfach es ist, die Basis für die Verwendung von temporären Tabellen zu schaffen. Durch Parameter und ein paar Zeilen Code erstellen Sie eine Datenbank, die bei jedem Start Ihrer Anwendung automatisch erzeugt wird. Dieser Artikel soll Ihnen nun die Anwendung temporärer Datenbanken in der Praxis demonstrieren.<\/b><\/p>\n<\/p><\/div>\n

\n

Der Hintergrund für den Einsatz einer temporären Datenbank ist, in Frontend-Backend-Szenarios oft verwendete, aber selten geänderte Daten – etwa zum Füllen von Kombinationsfeldern – für die Dauer einer Sitzung auf den lokalen Rechner zu kopieren. Dabei soll nicht nur eine temporäre Tabelle, sondern direkt eine temporäre Datenbank helfen, weil dies das Aufblähen des eigentlichen Frontends verringert.<\/p>\n

Im Beitrag Temporäre Datenbanken <\/b>(Shortlink 461) haben Sie erfahren, wie Sie mit einem geeigneten Formular die dafür anzulegende temporäre Datenbank konfigurieren. Der vorliegende Beitrag zeigt, wie Sie diese Lösung in der Praxis einsetzen und die Tabellen der temporären Datenbank mit den gewünschten Daten füllen.<\/p>\n

Anwendungsgebiet „Referenztabellen“<\/b><\/p>\n

Die Daten in Kombinations- oder Listenfeldern zur Anzeige von Kundennamen, Zahlungsbedingungen etc. holt Access normalerweise bei jedem öffnen des Formulars aus den Tabellen des Backends.<\/p>\n

Warum also nicht, um die Belastung des Backends zu verringern, diese „statischen“ Daten einfach beim Start Ihrer Anwendung in den Pool der temporären Datenbank überführen und anschließend die Listenfelder durch die Einträge aus den Tabelle der temporären Datenbank füllen<\/p>\n

Zur Demonstration dieser Vorgehensweise soll das nachfolgende Beispiel dienen: Das Backend enthält eine Tabelle mit Bundesländern, Kreisstädten und Gemeinden. Die Struktur dieser Tabelle entnehmen Sie Tab. 1.<\/p>\n\n\n\n\n\n\n\n\n\n\n
\n

Feldname<\/p>\n<\/td>\n

\n

Datentyp<\/p>\n<\/td>\n

\n

Länge<\/p>\n<\/td>\n<\/tr>\n<\/thead>\n

\n

Tab. 1: Struktur der Datenquelle<\/span><\/b><\/p>\n<\/td>\n<\/tr>\n<\/tfoot>\n

\n<\/td>\n\n<\/td>\n\n <\/td>\n<\/tr>\n
\n<\/td>\n\n<\/td>\n\n<\/td>\n<\/tr>\n
\n<\/td>\n\n<\/td>\n\n<\/td>\n<\/tr>\n
\n<\/td>\n\n<\/td>\n\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Das zu füllende Kombinationsfeld benötigen Sie zur Auswahl des Bundeslandes bei der Erfassung einer Adresse.<\/p>\n

Konfiguration der temporären Datenbank<\/b><\/p>\n

Starten Sie den Konfigurator (frm_app_Konfigurator<\/b>) und geben Sie dort den Datenbankpfad und den Namen der zu erstellenden temporären Datenbank an (siehe Bild 1). Dann müssen Sie die temporäre Tabelle namens tbl_ref_Bundeslaender<\/b> im Konfigurator anlegen (genaue Informationen zum Konfigurator siehe Shortlink 461).<\/p>\n

\n \"pic001.tif\"\n <\/div>\n
\n

Bild 1: Konfigurieren Sie die erste Tabelle für den Gebrauch als Referenztabelle.<\/span><\/b><\/p>\n<\/p><\/div>\n

Haben Sie den Namen festgelegt, müssen Sie noch die Felder für die neue Tabelle bestimmen. Dazu klicken Sie auf das Register Felder<\/b> und wählen die Tabelle tbl_ref_Bundeslaender <\/b>aus dem Kombinationsfeld aus (siehe Bild 2).<\/p>\n

\n \"pic002.tif\"\n <\/div>\n
\n

Bild 2: Konfiguration der benötigten Felder für die Referenztabelle <\/span><\/b><\/p>\n

tbl_ref_Bundeslaender<\/span><\/b><\/p>\n<\/p><\/div>\n

Die Feldgröße der Felder für die temporäre Tabelle leiten sich von der Struktur der Ausgangsdatenquelle ab. Wie in Tab. 1 beschrieben, enthält die temporäre Tabelle lediglich zwei Felder vom Datentyp Text<\/b> mit den passenden Feldgrößen.<\/p>\n

Zu guter Letzt legen Sie noch zwei Indizes für die temporäre Tabelle an (siehe Bild 3).<\/p>\n

\n \"pic003.tif\"\n <\/div>\n
\n

Bild 3: Indizes der temporären Tabelle<\/span><\/b><\/p>\n<\/p><\/div>\n

Der Index PrimaryKey <\/b>verhindert redundante Daten im Primärschlüssel während der zweite Index SortOrder <\/b>dazu verwendet wird, die Ausgabe der Bundesländer in sortierter Form zu beschleunigen.<\/p>\n

Lassen Sie, nachdem Sie die Konfiguration fertig gestellt haben, die temporäre Datenbank für einen ersten Testlauf erstellen. Sollten keine Fehler auftauchen, werden Sie über den Erfolg informiert und die verknüpfte Tabelle erscheint im Datenbankfenster.<\/p>\n

Wie kommen die Daten in die Tabelle<\/b><\/p>\n

Nun gut – die Datenbank und damit auch die konfigurierte Tabelle wurden erfolgreich erstellt. Aber wie bekommen Sie nun die Daten aus dem Backend in diese Tabelle Ziel ist es, alle Bundesländer aus der Tabelle tbl_app_LaenderKreiseGemeinden <\/b>der Backend-Datenbank in die temporäre Tabelle zu transferieren. Bundesländer sind diejenigen Datensätze mit dem Feldinhalt L<\/b> im Feld Type<\/b> (siehe Bild 4).<\/p>\n

\n \"pic004.tif\"\n <\/div>\n
\n

Bild 4: Bundesländer sind durch eine eindeutige Typen-kennzeichnung charakterisiert.<\/span><\/b><\/p>\n<\/p><\/div>\n

Datenübertragung mittels DAO und JET<\/b><\/p>\n

Die erste Möglichkeit besteht darin, die Quelldaten in einem RecordSet zu speichern und zu durchlaufen. Jeder Datensatz, der dem Kriterium für die temporäre Datenquelle entspricht, wird anschließend mittels VBA-Code in diese Tabelle eingetragen (s. Listing 1).<\/p>\n

\n

Listing 1: Import von Daten in die temporäre Tabelle via DAO<\/p>\n

Private Sub StartDAOImport()<\/pre>\n
     On Error GoTo ErrorHandler:<\/pre>\n
     Call DoCmd.Hourglass(True)<\/pre>\n
     Set db = DBEngine(0)(0)<\/pre>\n
     Set rstSource = db.OpenRecordset(\"tbl_app_LaenderKreiseGemeinden\", dbOpenForwardOnly)<\/pre>\n
     Set rstTarget = db.OpenRecordset(\"tbl_ref_Bundeslaender\", dbOpenDynaset)<\/pre>\n
     While Not rstSource.EOF<\/pre>\n
         If rstSource!Type = \"L\" Then<\/pre>\n
             rstTarget.AddNew<\/pre>\n
             rstTarget!Schluessel = rstSource!Gemeindeschluessel<\/pre>\n
             rstTarget!BundesLand = rstSource!RegionName<\/pre>\n
             rstTarget.Update<\/pre>\n
         End If<\/pre>\n
         rstSource.MoveNext<\/pre>\n
     Wend<\/pre>\n
ExitCode:<\/pre>\n
     On Error Resume Next<\/pre>\n
     Set rstSource = Nothing<\/pre>\n
     Set rstTarget = Nothing<\/pre>\n
     Set db = Nothing<\/pre>\n
     Call DoCmd.Hourglass(False)<\/pre>\n
     Exit Sub<\/pre>\n
ErrorHandler:<\/pre>\n
     Select Case Err.Number<\/pre>\n
         Case 3022: Resume Next<\/pre>\n
         Case Else: MsgBox Err.Description, vbInformation, \"Fehler: \" & Err.Number<\/pre>\n
     End Select<\/pre>\n
 Resume ExitCode<\/pre>\n
End Sub<\/pre>\n<\/p><\/div>\n
Im obigen Code werden zwei Recordsets initialisiert und geöffnet. Das Recordset rstSource <\/b>enthält die Datenmenge der zu übertragenden Daten, während das Recordset rstTarget <\/b>die temporäre Tabelle tmp_app_BundesLaender <\/b>abbildet.<\/p>\n
In einer kopfgesteuerten Schleife wird im Anschluss die Datenquelle durchlaufen. Sobald die Bedingung [Type] = „L“ <\/b>erfüllt ist, versucht die Routine, den gefundenen Datensatz in die Zieltabelle einzutragen. Da Sie nicht ausschließen können, dass eventuell bereits ein Datensatz mit gleichem Primärschlüsseleintrag in der Zieltabelle vorhanden ist, wird in der Fehlerroutine auf eine mögliche Schlüsselverletzung (Fehler 3022) reagiert und die Quelle einfach weiter durchlaufen.<\/p>\n
Datenübertragung mittels SQL<\/b><\/p>\n
Eine elegantere Lösung stellt die Verwendung einer passenden gespeicherten SQL-Abfrage für das Füllen der Zieltabelle dar.<\/p>\n
<\/p>\n
Ziel soll es auch hier sein, alle Bundesländer aus der Tabelle tbl_app_LaenderKreiseGemeinden <\/b>in die temporäre Tabelle tbl_ref_Bundeslaender <\/b>zu übertragen. Im Gegensatz zur codebasierten Lösung muss das SQL-Statement selbst berücksichtigen, dass eventuelle Daten in der Zieltabelle vorhanden sind. Der Lösungsansatz ist ein OUTER JOIN, der die Quell- und die Zieltabelle miteinander über ihre Schlüsselfelder verbindet. Bevor Sie das komplette SQL-Statement verwenden, schauen Sie sich zunächst das SQL-Statement für die Ermittlung der Daten an (siehe Bild 5). Die Quelltabelle tbl_app_LaenderKreiseGemeinden <\/b>und die Zieltabelle tbl_ref_BundesLaender <\/b>sind über die Felder Gemeindeschluessel <\/b>und Schluessel <\/b>miteinander verknüpft.<\/p>\n
\n                    \"pic005.tif\"\n                <\/div>\n
\n
Bild 5: Ein OUTER JOIN für die Ermittlung der benötigten Daten<\/span><\/b><\/p>\n<\/p><\/div>\n
Die Besonderheit dieser Verbindung ist die Richtung des unscheinbaren Pfeils. Bei dieser Art der Verbindung handelt es sich um einen OUTER JOIN, der Folgendes ausdrückt: „Zeige alle Daten aus tbl_app_LaenderKreiseGemeinden <\/b>an, unabhängig davon, ob es in der Tabelle tbl_ref_BundesLaender <\/b>Datensätze mit gleichem Schlüsselwert gibt.“<\/p>\n
Schauen Sie sich anschließend die Abfragekriterien an, dürfte Ihnen die Erklärung für die Einschränkungen leicht fallen. Die Zieltabelle soll ausschließlich mit den Bundesländern gefüllt werden; somit muss als erstes Kriterium die Einschränkung auf das Feld Type <\/b>gesetzt werden. Das zweite Kriterium definiert, dass ausschließlich Daten aus der Quelle angezeigt werden sollen, die noch nicht in der Zieltabelle vorhanden sind. Sofern sich in der Zieltabelle bereits Daten befinden, werden diese Daten durch die Abfrage ausgeschlossen. Angezeigt werden ausschließlich die Felder Gemeindeschlüssel <\/b>und RegionName<\/b>.<\/p>\n
Mit Hilfe einer Anfügeabfrage lassen sich nun die durch diese Abfrage ermittelten Daten in die Zieltabelle übertragen. Das vollständige SQL-Statement sieht dann wie folgt aus:<\/p>\n
INSERT INTO tbl_ref_BundesLaender<\/pre>\n
(Schluessel, BundesLand)<\/pre>\n
SELECT Gemeindeschluessel, RegionName<\/pre>\n
FROM tbl_app_LaenderKreiseGemeinden LEFT JOIN tbl_ref_Bundeslaender<\/pre>\n
ON (tbl_app_LaenderKreiseGemeinden.Gemeindeschluessel = tbl_ref_Bundeslaender.Schluessel)<\/pre>\n
WHERE Type=\"L\" AND Schluessel Is Null<\/pre>\n
Sowohl die Auswahl- als auch die Anfügeabfrage sind in der Beispieldatenbank vorhanden. Wenn Sie sich den Code für die Ausführung der Abfrage anschauen, werden Sie feststellen, dass er nicht so kompliziert und auch leichter zu pflegen ist (s. Listing 2). Letztendlich wird der eigentliche Aufruf auf zwei Zeilen reduziert. Zunächst wird eine Instanz des Datenbankobjektes referenziert, um anschließend über dieses Datenbankobjekt die eigentliche Abfrage qry_Append_Bundeslaender <\/b>auszuführen.<\/p>\n
\n
Listing 2: Import von Daten in die temporäre Tabelle via gespeicherter Abfrage<\/p>\n
Private Sub StartSQLImport()<\/pre>\n
     On Error GoTo ErrorHandler<\/pre>\n
     Call DoCmd.Hourglass(True)<\/pre>\n
     SQLStartTime = Now()<\/pre>\n
     Set db = DBEngine(0)(0)<\/pre>\n
     db.Execute \"qry_Append_BundesLaender\", dbFailOnError<\/pre>\n
ExitCode:<\/pre>\n
     On Error Resume Next<\/pre>\n
     Set db = Nothing<\/pre>\n
     SQLFinishTime = Now()<\/pre>\n
     Me.Recalc<\/pre>\n
     Call DoCmd.Hourglass(False)<\/pre>\n
     Exit Sub<\/pre>\n
ErrorHandler:<\/pre>\n
     MsgBox Err.Description, vbInformation<\/pre>\n
     Resume ExitCode<\/pre>\n
End Sub<\/pre>\n<\/p><\/div>\n
Hinweise zu den 
Ausführungsgeschwindigkeiten<\/b><\/p>\n
Bei den Tests mit den einzelnen Varianten war besonders interessant, welche Variante die schnellere ist. Letztendlich waren die Zeitunterschiede gering. Sofern Sie Wert darauf legen, Ihren Anwendern durch Aktivitäten auf dem Bildschirm den Fortschritt der übertragung anzuzeigen, sollten Sie die erste Variante verwenden. Sie lässt mehr Spielraum für Interaktivität.<\/p>\n
Anwendungsgebiet „Ergebnis-\/Zwischentabellen“<\/b><\/p>\n
Sicherlich haben Sie auch schon das eine oder andere Mal einen Bericht erstellt, für den Zwischenergebnisse erzeugt und angewendet werden müssen. Auch für diesen Anwendungsbereich bieten sich temporäre Tabellen an.<\/p>\n
Das vorliegende Beispiel demonstriert, wie Sie mit Hilfe von temporären Tabellen Verhältnisanteile von Mitgliedern ermitteln können. Sie finden in der Beispieldatenbank eine Tabelle mit dem Namen tbl_app_Mitglieder<\/b>. Der Aufbau dieser Tabelle ist recht einfach gehalten (s. Tab. 2).<\/p>\n\n\n\n\n\n\n\n\n
\n
Feldname<\/p>\n<\/td>\n
\n
Datentyp<\/p>\n<\/td>\n
\n
Länge<\/p>\n<\/td>\n<\/tr>\n
\n<\/td>\n\n<\/td>\n\n<\/td>\n<\/tr>\n
\n<\/td>\n\n<\/td>\n\n<\/td>\n<\/tr>\n
\n<\/td>\n\n<\/td>\n\n<\/td>\n<\/tr>\n
\n<\/td>\n\n<\/td>\n\n                            <\/td>\n<\/tr>\n
\n
Tab. 2: Struktur der Datenquelle<\/span><\/b><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Die Auswertung soll für das hier gezeigte Beispiel recht simpel sein und folgende Anforderungen erfüllen: Als Ergebnis soll in der temporären Tabelle mit dem Namen tbl_Mitgliederstatistik <\/b>der Name, die Mitgliedsart, das Datum des Beginns der Mitgliedschaft sowie der prozentuale Anteil aller Mitglieder im gleichen Jahr und der prozentuale Anteil über alle Mitglieder ausgegeben werden. Die temporäre Tabelle hat den Aufbau aus Tab. 3.<\/p>\n\n\n\n\n\n\n\n\n\n
\n
Feldname<\/p>\n<\/td>\n
\n
Datentyp<\/p>\n<\/td>\n
\n
Länge<\/p>\n<\/td>\n<\/tr>\n
\n<\/td>\n\n<\/td>\n\n<\/td>\n<\/tr>\n
\n<\/td>\n\n<\/td>\n\n<\/td>\n<\/tr>\n
\n<\/td>\n\n<\/td>\n\n                            <\/td>\n<\/tr>\n
\n<\/td>\n\n<\/td>\n\n                            <\/td>\n<\/tr>\n
\n<\/td>\n\n<\/td>\n\n                            <\/td>\n<\/tr>\n
\n
Tab. 3: Struktur der temporären Tabelle<\/span><\/b><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Auch hier gehen Sie wieder wie oben beschrieben vor und konfigurieren die Ausgabetabelle wie dem Konfigurator der Beispieldatenbank zu entnehmen.<\/p>\n
Erstellen des Berichtsergebnisses mittels VBA<\/b><\/p>\n
Die im Bericht anzuzeigenden Daten werden erst in dem Moment ermittelt, in dem der Bericht geöffnet wird. Da zu diesem Zeitpunkt die Daten noch nicht aus der Datenquelle abgerufen werden, können Sie die Daten noch nach Belieben bearbeiten. Während der Datenaufbereitung wird der Bericht Informationen über die aktuell auszuführende Operation liefern.<\/p>\n
Die nachfolgenden Operationen müssen vor der Anzeige des Berichts ausgeführt werden:<\/p>\n