{"id":55000460,"date":"2019-10-01T00:00:00","date_gmt":"2020-04-06T16:32:44","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=460"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Ligaverwaltung_Teil_2_Formulare","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_2_Formulare.html","title":{"rendered":"Ligaverwaltung, Teil 2: Formulare"},"content":{"rendered":"

Für die meisten Sportarten gibt es Wettbewerbe in Ligen. Oder zumindest Turniere, die ja meist auch als kleine Liga angesehen werden können mit Spielpaarungen und Tabellen. Jedenfalls gibt eine Verwaltung solcher Ligen jede Menge Stoff für eine Datenbankanwendung – mit Datenmodell, Abfragen, Formularen zur Eingabe der Daten und Berichten, um Spielpläne und Tabellen auszugeben. Im zweiten Teil der Artikelreihe programmieren wir die Formulare, die zur Eingabe der Daten der Ligaverwaltung nötig sind.<\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispiele dieses Artikels finden Sie in der Datenbank 1905_Ligaverwaltung.accdb<\/b>.<\/p>\n

Rapid Prototyping<\/h2>\n

Ich betreibe immer Rapid Prototyping. Das heißt, ich konzipiere nicht die komplette Anwendung durch, bevor ich sie programmiere, sondern ich fange einfach an zu programmieren. Dafür ist Microsoft Access auch das perfekte Tool, denn es gibt keine andere Entwicklungsumgebung für Datenbanken für Windows-Systeme, mit der Sie so schnell Ergebnisse erhalten.<\/p>\n

Im ersten Teil dieser Artikelreihe haben wir ein Datenmodell für eine Ligaverwaltung erstellt, wie es uns sinnvoll erscheint und dabei die eine oder andere Abwägung getroffen. Beim Definieren des Datenmodells sollte man sorgfältig arbeiten, denn jede Entscheidung, die nachträglich revidiert werden muss, wirkt sich auf alle folgenden Ebenen aus – auf die Abfragen, Formulare und Berichte sowie auf den VBA-Code der Anwendung.<\/p>\n

Wenn wir nun starten, die Benutzeroberfläche für die Ligaverwaltung zu programmieren, werden wir möglicherweise noch auf Probleme im Datenmodell stoßen, die wir dann direkt beheben werden.<\/p>\n

Wie starten wir beim Prototyping Wir wollen eine Anwendung erschaffen, die dem Benutzer eine Vorstellung von der Bedienung und den enthaltenen Funktionen gibt. Dazu gehört, dass der Benutzer damit auch alle Daten eingeben kann, die für den Betrieb der Anwendung nötig sind. Wir arbeiten uns deshalb am Datenmodell entlang und erstellen zuerst die Formulare, die für die Eingabe der grundlegenden Daten nötig sind – zum Beispiel die Ligen und die Spieljahre. Die Tabelle tblLigenSpieljahre <\/b>kombiniert die Ligen und die Spieljahre. Als Nächstes benötigen wir die Mannschaften. Wenn wir diese eingegeben haben, können wir sie einer Kombination aus Liga und Spieljahr zuordnen. Erst dann können wir die Spieltage und somit den Spielplan für eine Liga festlegen. Dazu wollen wir später einen praktischen Editor bereitstellen. Stehen die Spieltage, soll der Benutzer in einem eigenen Formular die Ergebnisse von Spieltagen eingeben können. Aus den Ergebnissen eines oder mehrerer Spieltage resultieren dann die Tabellenstände, die nur noch ausgegeben werden sollen. Dazu stellen wir geeignete Berichte bereit – das allerdings erst in einem späteren Teil der Artikelreihe. Nun starten wir erst einmal mit den Tabellen für die Basisdaten.<\/p>\n

Formular frmLigen<\/h2>\n

Das erste Formular soll der Eingabe und der Verwaltung der Ligen dienen. Dazu erstellen wir zunächst ein Unterformular namens sfmLigenVerwalten<\/b>. über die Eigenschaft Datensatzquelle <\/b>weisen wir ihm die Tabelle tblLigen <\/b>als Datenquelle zu. Damit es alle Daten dieser Tabelle in der Datenblattansicht ausgibt, ziehen wir alle drei Felder der Tabelle aus der Feldliste in den Detailbereich der Entwurfsansicht. Sie brauchen die Felder dort nicht ordentlich anzuordnen, denn wir stellen die Ansicht ohnehin über die Eigenschaft Standardansicht <\/b>auf Datenblatt <\/b>um. Das Ergebnis finden Sie in Bild 1.<\/p>\n

\"Entwurf<\/a><\/p>\n

Bild 1: Entwurf des Unterformulars sfmLigenVerwalten<\/p>\n

Nun schließen wir das Unterformular und erstellen das Hauptformular namens frmLigenVerwalten<\/b>. Diesem fügen wir per Drag and Drop den Eintrag für das Unterformular sfmLigenVerwalten <\/b>zum Detailbereich hinzu. Darunter ordnen wir noch eine Schaltfläche zum Schließen des Formulars an. Außerdem entfernen wir das Beschriftungsfeld, das automatisch mit dem Unterformular zum Formular hinzugefügt wurde und ändern die Eigenschaften Bildlaufleisten<\/b>, Navigationsschaltflächen <\/b>und Datensatzmarkierer <\/b>auf Nein <\/b>sowie Automatisch zentrieren <\/b>auf Ja<\/b>, sodass dieses wie in Bild 2 aussieht.<\/p>\n

\"Entwurf<\/a><\/p>\n

Bild 2: Entwurf des Formulars frmLigenVerwalten<\/p>\n

Für die Schaltfläche cmdOK <\/b>hinterlegen wir die folgende Ereignisprozedur:<\/p>\n

Private Sub <\/span>cmdOK_Click()\r\n    DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\n
Danach können wir schon die ersten Ligen eingeben, wie Bild 3 zeigt.<\/p>\n
\"Formular<\/a><\/p>\n
Bild 3: Formular zur Eingabe von Ligen<\/p>\n
Spieljahre verwalten<\/h2>\n
Danach kümmern wir uns direkt um ein Formular beziehungsweise ein Formular samt Unterformular zur Eingabe von Spieljahren. Das Unterformular soll sfmSpieljahreVerwalten <\/b>heißen und verwendet die Tabelle tblSpieljahre <\/b>als Datensatzquelle. Wir fügen auch hier alle Felder der Tabelle zum Detailbereich des Formulars hinzu. Dann stellen wir die Eigenschaft Standardansicht <\/b>auf Datenblatt <\/b>ein.<\/p>\n
Das Formular fügen wir nach dem Speichern und Schließen ebenfalls per Drag and Drop aus dem Navigationsbereich von Access in ein neues Formular namens frmSpieljahreVerwalten <\/b>ein. Hier führen wir die gleichen Schritte wie zuvor beim Hauptformular frmLigenVerwalten <\/b>durch, sodass sich in der Entwurfsansicht die Ansicht aus Bild 4 ergibt.<\/p>\n
\"Formular<\/a><\/p>\n
Bild 4: Formular zur Eingabe von Spieljahren<\/p>\n
Spieljahre und Ligen zusammenführen<\/h2>\n
An dieser Stelle taucht die erste interessante Frage auf: Zu welchem Zeitpunkt erstellen wir die Kombinationen aus Liga und Spieljahr Diese Kombination speichern wir ja in einer eigenen Tabelle namens tblLigenSpieljahre<\/b>. Die Einträge sollen unter anderem eine Bezeichnung wie Bundesliga 2019\/2020 <\/b>liefern. Die Idee ist: Wir legen immer neue Einträge an, wenn der Benutzer entweder eine neue Liga oder ein neues Spieljahr hinzufügt. Wir können in beiden Fällen die gleiche Prozedur aufrufen, die wie in Listing 1 aussieht. Diese Prozedur definiert zwei Recordsets auf Basis der Tabellen tblLigen <\/b>und tblSpieljahre<\/b>. Sie durchläuft die Datensätze der Tabelle tblLigen <\/b>in einer äußeren Do While<\/b>-Schleife und die der Tabelle tblSpieljahre <\/b>in einer inneren Do While<\/b>-Schleife. Damit die Einträge der inneren Schleife nach dem ersten Durchlauf der inneren und äußeren Schleife erneut durchlaufen werden, müssen wir den Datensatzzeiger der inneren Schleife danach mit rstSpieljahre.MoveFirst <\/b>wieder auf den ersten Datensatz einstellen. In der inneren Do While<\/b>-Schleife führen wir bei deaktivierter Fehlerbehandlung eine INSERT INTO<\/b>-Anweisung aus, die den Wert des Feldes ID <\/b>der beiden Recordsets sowie die Kombination der beiden Felder Liga <\/b>aus rstLigen <\/b>und Spieljahr <\/b>aus rstSpieljahre <\/b>in die Felder der Tabelle tblLigenSpieljahre <\/b>einträgt.<\/p>\n
<font color=blue>Public Sub <\/font>LigenUndSpieljahreAktualisieren()\r\n     <font color=blue>Dim <\/font>db<font color=blue> As <\/font>DAO.Database\r\n     <font color=blue>Dim <\/font>rstLigen<font color=blue> As <\/font>DAO.Recordset\r\n     <font color=blue>Dim <\/font>rstSpieljahre<font color=blue> As <\/font>DAO.Recordset\r\n     <font color=blue>Set<\/font> db = CurrentDb\r\n     <font color=blue>Set<\/font> rstLigen = db.OpenRecordset(\"tblLigen\", dbOpenDynaset)\r\n     <font color=blue>Set<\/font> rstSpieljahre = db.OpenRecordset(\"tblSpieljahre\", dbOpenDynaset)\r\n     <font color=blue>Do While<\/font> <font color=blue>Not<\/font> rstLigen.EOF\r\n         <font color=blue>Do While<\/font> <font color=blue>Not<\/font> rstSpieljahre.EOF\r\n             On Error Resume <font color=blue>Next<\/font>\r\n             db.Execute \"INSERT INTO tblLigenSpieljahre(LigaSpieljahr, LigaID, SpieljahrID) VALUES('\" & rstLigen!Liga & \" \" _\r\n                 & rstSpieljahre!Spieljahr & \"', \" & rstLigen!ID & \", \" & rstSpieljahre!ID & \")\", dbFailOnError\r\n             <font color=blue>If <\/font>Err.Number = 3022<font color=blue> Then<\/font>\r\n                 db.Execute \"UPDATE tblLigenSpieljahre SET LigaSpieljahr = '\" & rstLigen!Liga & \" \" & rstSpieljahre!Spieljahr _\r\n                     & \"' WHERE LigaID = \" & rstLigen!ID & \" AND SpieljahrID = \" & rstSpieljahre!ID, dbFailOnError\r\n             <font color=blue>End If<\/font>\r\n             <font color=blue>On Error GoTo<\/font> 0\r\n             rstSpieljahre.Move<font color=blue>Next<\/font>\r\n         <font color=blue>Loop<\/font>\r\n         rstSpieljahre.MoveFirst\r\n         rstLigen.Move<font color=blue>Next<\/font>\r\n     <font color=blue>Loop<\/font>\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Aktualisieren der Kombinationen aus Ligen und Spieljahren<\/p>\n
Es kann sein, dass dabei ein Fehler mit der Nummer 3022 <\/b>auftritt, wenn die Kombination aus Liga und Spieljahr schon in der Tabelle angelegt wurde – und zwar deshalb, weil wir einen eindeutigen, zusammengesetzten Index für diese beiden Tabellen angelegt haben. Wenn dieser Fehler auftritt, brauchen wir den Datensatz natürlich nicht erneut anzulegen. Aber gegebenenfalls hat der Benutzer in der Zwischenzeit den Namen der Liga geändert.<\/p>\n
Also prüfen wir nach der INSERT INTO<\/b>-Anweisung, ob Err.Number <\/b>den Wert 3022 <\/b>enthält, und führen in diesem Fall noch eine UPDATE<\/b>-Anweisung aus, welche die Kombination aus Liga und Spieljahr im Feld LigaSpieljahr <\/b>der Zieltabelle tblLigenSpieljahre <\/b>ergänzt. Nachdem wir in beiden Schleifen alle Kombinationen aus Liga und Spieljahr durchlaufen haben, sieht die Tabellen für unsere wenigen Beispieldatensätzen danach wie in Bild 5 aus.<\/p>\n
\"Die<\/a><\/p>\n
Bild 5: Die Tabelle tblLigenSpieljahre mit einigen Beispieldatensätzen<\/p>\n
Nun müssen wir nur noch den Aufruf dieser Prozedur überall dort einfügen, wo der Benutzer die Liga oder das Spieljahr ändern kann. Am einfachsten ist es, dies beim Schließen der beiden Formulare frmLigenVerwalten <\/b>und frmSpieljahreVerwalten <\/b>zu erledigen.<\/p>\n
Dazu nutzen wir das Ereignis Beim Entladen <\/b>der beiden Formulare. Die dadurch ausgelöste Ereignisprozedur sieht so aus:<\/p>\n
Private Sub <\/span>Form_Unload(Cancel As Integer<\/span>)\r\n    Call<\/span> LigenUndSpieljahreAktualisieren\r\nEnd Sub<\/span><\/pre>\n
Zur Sicherheit: Die Namen im Feld LigaSpieljahr <\/b>werden dabei immer und bei jeder änderung einer der beiden Tabellen an die Werte der dortigen Felder angepasst.<\/p>\n
Nun haben wir die beiden Formulare zur Verwaltung von Ligen und Spieljahren so erstellt, dass der Access-kundige Benutzer diese verwenden kann – er muss wissen, dass man zum Löschen beispielsweise einen Datensatz über den Datensatzmarkierer markieren und dann die Entfernen-Taste betätigen muss und er sollte wissen, wie er einen neuen Datensatz anlegen kann.<\/p>\n
Mannschaften verwalten<\/h2>\n
Auch die Mannschaften wollen erst einmal eingegeben werden, bevor man sich um die Zuteilung zu Ligen\/Spieljahren und Spielplänen kümmern kann.<\/p>\n
Also erstellen wir ein Hauptformular namens frmMannschaftenVerwalten <\/b>und ein Unterformular namens sfmMannschaftenVerwalten<\/b>, wobei das Unterformular wieder die Daten der Tabelle tblMannschaften <\/b>in der Datenblattansicht anzeigt und das Hauptformular das Unterformular sowie die Schaltfläche OK <\/b>enthält. Das erlaubt dann die Eingabe von Mannschaften wie in Bild 6.<\/p>\n
\"Mannschaften<\/a><\/p>\n
Bild 6: Mannschaften per Formular verwalten<\/p>\n
Ligen, Spieljahre und Mannschaften zuordnen<\/h2>\n
Danach können wir uns an ein etwas aufwendigeres Formular begeben. Dieses soll dazu dienen, die in der Tabelle tblLigenSpieljahre <\/b>definierten Kombinationen aus Ligen und Spieljahren mit den Mannschaften aus der Tabelle tblMannschaften <\/b>zu verknüpfen.<\/p>\n
Dieses Formular soll so aussehen, dass wir im Hauptformular mit einem Kombinationsfeld die Kombination aus Liga und Spieljahr auswählen und dann über ein Unterformular die Mannschaften zuordnen können. Dazu erstellen wir zunächst das Hauptformular und fügen diesem ein Kombinationsfeld namens cboLigaSpieljahr <\/b>hinzu. Dieses Kombinationsfeld erhält als Datensatzherkunft die folgende Abfrage auf Basis der Tabelle tblLigenSpieljahre<\/b>:<\/p>\n
SELECT ID, LigaSpieljahr FROM tblLigenSpieljahre;<\/pre>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Access [basics]<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 400 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t