![\"Aufrufen](\"..\/fileadmin\/_temp_\/2022_02\/pic_1359_002.png\")
<\/p>\nDas Produzieren von Beispieldaten ist immer wieder eine mühselige Aufgabe. Beispieldaten benötigen Sie, um beim Entwickeln neuer Anwendungen die Funktionen zu testen, die mit der Anzeige, dem Bearbeiten oder Löschen von Daten zusammenhängen. Und auch zum Testen des Hinzufügens von Daten benötigen Sie gegebenenfalls schon Daten in verknüpften Tabellen zur Auswahl. Unter .NET gibt es verschiedene Bibliotheken, die das Generieren von Beispieldaten erleichtern. Leider sind diese nicht so ohne Weiteres unter Access verfügbar. Zum Glück gibt es Tools, mit denen Sie diese Bibliotheken dennoch für Ihre Zwecke einsetzen können. In diesem Beitrag nutzen wir den Editor LINQPad, um Beispieldaten mit der Bogus-Bibliothek zu erzeugen und diese dann mit der Bibliothek LINQ to DB den Tabellen einer Beispieldatenbank hinzuzufügen.<\/b><\/p>\nVorbereitungen<\/h2>\n
Für die beschriebenen Techniken benötigen Sie die Entwicklungsumgebung LINQPad sowie die Datenzugriffsbibliothek LINQ to DB. Wie Sie diese beiden herunterladen, installieren und verwenden, beschreiben wir im Beitrag Datenzugriff mit .NET, LINQPad und LINQ to DB <\/b>(www.access-im-unternehmen.de\/1358<\/b>).<\/p>\n
Wie Sie diese beiden nutzen, um mit einer weiteren Bibliothek namens Bogus zufällige Beispieldaten für eine Datenbank zu erzeugen, zeigen wir im vorliegenden Beitrag.<\/p>\n
Zum Ermitteln der Beispieldaten, die wir zu den Tabellen der Anwendung hinzufügen wollen, nutzen wir die bereits eingangs erwähnte Bibliothek Bogus<\/b>.<\/p>\n
Diese müssen wir genau wie LINQ to DB <\/b>zunächst verfügbar machen. Dazu klicken Sie unter LINQPad <\/b>mit der rechten Maustaste auf den Registerreiter des Query<\/b>-Bereichs und wählen den Eintrag Query Properties… <\/b>aus (siehe Bild 1).<\/p>\n
<\/p>\n
Bild 1: Aufrufen des Dialogs Query Properties per Kontextmenü<\/span><\/b><\/p>\n Im nun erscheinenden Dialog Query Properties <\/b>klicken Sie auf die Schaltfläche Add NuGet… <\/b>und geben im folgenden Dialog unter Search online <\/b>den Suchbegriff Bogus <\/b>ein. Den nun angezeigten Eintrag aus Bild 2 fügen Sie dann mit einem Klick auf die Schaltfläche Add to Query <\/b>hinzu.<\/p>\n Bild 2: Hinzufügen des Bogus-Pakets<\/span><\/b><\/p>\n Es erscheint nun ein neuer Eintrag im linken Bereich des Dialogs LINQPad NuGet Manager<\/b>. Hier klicken Sie noch auf Add namespaces<\/b> (siehe Bild 3).<\/p>\n Bild 3: Hinzufügen des Bogus-Namespaces<\/span><\/b><\/p>\n Dies öffnet einen weiteren Dialog namens Add Namespaces From NuGet Assemblies<\/b>. Hier wählen Sie den Eintrag Bogus <\/b>aus und klicken auf OK<\/b> (siehe Bild 4).<\/p>\n Bild 4: Hinzufügen eines Verweises auf den Bogus-Namespace<\/span><\/b><\/p>\n Nachdem Sie diesen Dialog und auch den Dialog LINQPad NuGet Manager <\/b>geschlossen haben, finden Sie im Dialog Query Properties <\/b>unter Additional References <\/b>den Eintrag Bogus <\/b>vor (siehe Bild 5).<\/p>\n Bild 5: Der Verweis auf den Bogus-Namespace<\/span><\/b><\/p>\n Damit sind die Vorbereitungen abgeschlossen und wir können uns dem Einsatz von Bogus zum Generieren von Beispieldaten zuwenden.<\/p>\n Einen Schritt erledigen wir allerdings noch vorneweg – das Anlegen der Datensätze in der Tabelle tblAnreden<\/b>. Für diese benötigen wir keinen Zufallsgenerator und somit auch nicht die Bibliothek Bogus<\/b>. Wir fügen die Anreden einfach mit der folgenden Prozedur hinzu:<\/p>\n Den Code können wir mit Visual Basic übrigens auch wie folgt schreiben und sparen dabei nicht nur eine Variable, sondern auch einige Zeilen Code:<\/p>\n Damit wir immer mit einer frisch aufgesetzten Tabelle tblAnreden<\/b> starten, können wir zuvor die vorhandenen Anreden löschen:<\/p>\n Und schließlich geben wir die frisch erzeugten Anreden nachher einmal im Direktbereich von LINQPad aus:<\/p>\n Bogus bietet verschiedene Klassen, die Funktionen zum Erstellen von Zufallsdaten thematisch zusammenfassen. Diese werden unter folgendem Link ausführlicher beschrieben:<\/p>\n Es gibt die folgenden Klassen:<\/p>\n Mit den in den Klassen enthaltenen Funktionen können Sie die verschiedensten Daten ermitteln. Um dies auszuprobieren, erstellen Sie einfach eine neues Objekt auf Basis der Klasse Bogus.Faker <\/b>und greifen dann direkt auf die Klassen aus der obigen Auflistung und die darin enthaltenen Funktionen zu.<\/p>\n Im folgenden Beispiel schreiben wir den Code direkt in die Main<\/b>-Klasse der LINQPad-Datei:<\/p>\n Dies gibt einfach einen zufällig gewählten Nachnamen im Direktbereich aus. Auf die gleiche Weise probieren Sie auch die anderen Funktionen dieser und anderer Klassen aus.<\/p>\n Beim Ausprobieren von Funktionen wie Address.Street-Address<\/b>, Address.ZipCode <\/b>oder Address.City <\/b>werden Sie feststellen, dass die Daten sich auf englische Adressen beziehen.<\/p>\n Sie können allerdings leicht auf deutsche Anschriften umschwenken, indem Sie beim Erstellen der Faker<\/b>-Klasse den Wert „de“ <\/b>als Parameter übergeben. Die folgenden Zeilen liefern beispielsweise direkt deutsche Namen und Adressdaten:<\/p>\n Nachdem Sie aus dem Beitrag Datenzugriff mit .NET, LINQPad und LINQ to DB <\/b>(www.access-im-unternehmen.de\/1358<\/b>) wissen, wie Sie neue Datensätze mit den gewünschten Feldwerten zu einer Tabelle wie tblKunden <\/b>hinzufügen, haben Sie nun prinzipiell alle Techniken zum Erstellen von auf Zufallsdaten basierenden Datenbankinhalten zur Hand.<\/p>\n Sie brauchen die Anweisungen zum Füllen der Felder nur noch mit den oben vorgestellten Funktionen der verschiedenen Klassen des Bogus.Faker<\/b>-Objekts zu füllen.<\/p>\n Dann müssten wir allerdings für jeden Kunden ein neues Bogus.Faker<\/b>-Objekt erstellen. Das brauchen wir jedoch nur ein einziges Mal zu tun, denn die Bogus.Faker<\/b>-Klasse bietet eine Methode namens Generate <\/b>an. Mit der können Sie, wenn Sie für den Parameter einen Zahlenwert angeben, eigentlich sogar gleich mehrere Objekte gleichzeitig erzeugen, aber diese können wir im aktuellen Kontext nicht verarbeiten. Also nutzen wir die Generate<\/b>-Methode nur zum Erstellen eines Kunden gleichzeitig.<\/p>\n Bevor wir mit dem eigentlichen Code zum Erstellen einsteigen, deklarieren wir noch eine Enum<\/b>-Auflistung für das Geschlecht – wozu wir diese benötigen, erläutern wir anschließend:<\/p>\n Die Prozedur KundenAnlegen <\/b>erwartet die Anzahl der anzulegenden Kunden als Parameter. Dann deklariert sie die benötigten Variablen:<\/p>\n <\/p>\n Sie erstellt dann ein UserQuery<\/b>-Objekt auf Basis der Tabelle tblKunden <\/b>und ein neues Bogus.Faker<\/b>-Objekt, dem Sie die Klasse tblKunden <\/b>als Typ zuweisen.<\/p>\n Außerdem fügen wir noch den Wert „de“ <\/b>als Parameter an, damit Bogus deutsche Daten liefert:<\/p>\n Dann folgt ein Teil, von dem nur die inneren Zeilen interessant sind – und mit dem wir die Regeln festlegen, nach denen wir neue Objekte des Typs tblKunden <\/b>füllen.<\/p>\n Wichtig ist nur, dass Sie wissen, dass der Buchstabe k <\/b>für das tblKunden<\/b>-Objekt steht und f <\/b>für das Bogus.Faker<\/b>-Objekt. In der ersten Anweisung nutzen wir die Funktion PickRandom<\/b>, um zufällig einen der beiden Werte der Enumeration Gender <\/b>zu ermitteln (also 0 <\/b>für männlich und 1 <\/b>für weiblich) und schreiben das Ergebnis in die Variable intGender<\/b>:<\/p>\n Diesen Wert benötigen wir anschließend gleich zwei Mal. Als Erstes addieren wir den Wert 1 <\/b>hinzu und tragen das Ergebnis für die Eigenschaft AnredeID <\/b>ein, von der wir wissen, dass der Wert 1 <\/b>der Anrede Herr <\/b>und der Wert 2 <\/b>der Anrede Frau <\/b>entspricht:<\/p>\n Dann übergeben wir intGender <\/b>als Parameter der Funktion FirstName <\/b>zum Ermitteln eines zufälligen Vornamens. Durch diesen Parameter legen wir fest, ob FirstName <\/b>einen männlichen oder einen weiblichen Nachnamen liefert:<\/p>\n Die übrigen Zeilen legen fest, aus welchen Funktionen und Klassen von Bogus.Faker <\/b>die Daten für die übrigen Felder bezogen werden sollen:<\/p>\n Damit haben wir die Vorlage für das Erstellen von Elementen des Typs tblKunden <\/b>definiert.<\/p>\n Damit können wir nun in eine For…Next<\/b>-Schleife einsteigen, welche die Werte von 1 <\/b>bis zur Anzahl der zu erstellenden Elemente aus dem Parameter intMerge <\/b>durchläuft. Innerhalb der Schleife erstellen wir mit der Generate<\/b>-Methode auf Basis des objFaker<\/b>-Objekts ein neues Element des Typs tblKunden <\/b>und referenzieren es mit der Variablen Beispielkunde<\/b>.<\/p>\n Diesem weisen wir dann noch den Wert aus der Laufvariablen i <\/b>für das Feld ID <\/b>hinzu und speichern es mit der Insert<\/b>-Methode in dem mit objUserQuery <\/b>referenzierten UserQuery<\/b>-Objekt auf Basis der Tabelle tblKunden<\/b>:<\/p>\n Die so erzeugten Kunden können Sie sich in der Beispieldatenbank ansehen oder Sie lassen sich diese mit einer einfachen Prozedur in LINQPad ausgeben:<\/p>\n Damit wir immer frisch loslegen können, erstellen wir noch eine Prozedur zum Löschen der bereits vorhandenen Kunden:<\/p>\n Wenn Sie nun noch die folgenden Prozeduraufrufe in der Hauptmethode Main<\/b> platzieren, erstellt diese die Daten in den Tabellen tblAnreden <\/b>und tblKunden <\/b>nach dem Löschen jeweils neu und gibt diese im Direktbereich von LINQPad aus:<\/p>\n Nachdem wir uns die Grundlagen angesehen haben, wollen wir nun noch ein etwas umfangreicheres Datenmodell mit Beispieldaten füllen.<\/p>\n Dabei wollen wir die gängigsten Beziehungstypen abdecken – also 1:n- und m:n-Beziehungen. Dazu schauen wir uns das Datenmodell aus Bild 6 an. Die Reihenfolge beim Befüllen der Tabellen sieht wie folgt aus:<\/p>\n Bild 6: Datenmodell zum Füllen mit Beispieldaten<\/span><\/b><\/p>\n Dies ist die Reihenfolge zum Füllen mit Daten. Wenn wir die Tabellen vor dem Füllen mit Beispieldaten leeren wollen, müssen wir das in umgekehrter Reihenfolge erledigen – zumindest, wenn referenzielle Integrität ohne Löschweitergabe aktiviert ist und beispielsweise das Löschen von Daten aus der Tabelle tblAnreden <\/b>nicht möglich ist, wenn es noch Datensätze in der Tabelle tblKunden <\/b>gibt, die noch mit den zu löschenden Daten verknüpft sind.<\/p>\n Die Produkte-Tabelle haben wir mit einem speziellen Feature ausgestattet. Es enthält ein Anlage-Feld zum Speichern von Bildern. Wir wollen sehen, ob und wie sich das füllen lässt. <\/p>\n Dazu testen wir es zunächst einmal mit der folgenden Version:<\/p>\n Hier referenzieren wir nun die Tabelle tblProdukte <\/b>und legen im Rules<\/b>-Abschnitt Folgendes fest:<\/p>\n Den Aufruf dieser Prozedur fügen wir der Methode Main <\/b>hinzu und rufen diese dann auf:<\/p>\n Das Ergebnis ist allerdings ernüchternd: Wir erhalten die Fehlermeldung aus Bild 7. LINQ to DB <\/b>stellt also offensichtlich eine INSERT INTO<\/b>-Anweisung zusammen, die alle Felder der zugrunde liegenden Tabelle enthält – und berücksichtigt somit auch das Anlagefeld Bild<\/b>. Dies führt zu einem Fehler, weil INSERT INTO<\/b>-Abfragen nicht mit Anlagefeldern harmonieren.<\/p>\n Bild 7: Problem mit mehrwertigen Feldern<\/span><\/b><\/p>\n Welche Möglichkeit haben wir nun Wenn wir in den Bereich mit den Verbindungen schauen, sehen wir dort neben Tables <\/b>auch noch einen Untereintrag namens Views<\/b>. Können wir also gegebenenfalls eine Abfrage nutzen, um Daten zur Tabelle tblProdukte <\/b>hinzuzufügen und dabei das Anlagefeld Bild <\/b>auslassen Wir erstellen zunächst in der Access-Datenbank eine passende Abfrage namens qryProdukteOhneBild<\/b>.<\/p>\n Dazu müssen Sie LINQPad vermutlich schließen, da wahrscheinlich noch eine offene Verbindung zur .accdb<\/b>-Datei besteht (das erkennen sie auch an der noch vorhandenen .laccdb<\/b>-Datei).<\/p>\n Anschließend öffnen Sie die Access-Datenbank und erstellen eine Abfrage wie in Bild 8. Hier fügen Sie alle Felder mit Ausnahme des Feldes Bild <\/b>zum Entwurfsraster der Abfrage hinzu.<\/p>\n Bild 8: Abfrage zum Ermitteln der Produkte ohne Bilder<\/span><\/b><\/p>\n Danach schließen Sie die Datenbank und öffnen die LINQPad<\/b>-Datei erneut (wenn die Datenbank noch geöffnet ist, erhalten Sie in LINQPad einen Hinweis, dass die Datenbank erst geschlossen werden muss).<\/p>\n Unter den Connections finden Sie im Bereich Views<\/b> nun die Abfrage qryProdukteOhneBilder<\/b> (siehe Bild 9).<\/p>\n Bild 9: Die Abfrage im Bereich Views<\/span><\/b><\/p>\n Damit wir diese Abfrage nun auch in der Prozedur ProdukteAnlegen <\/b>nutzen können, passen Sie diese an, indem Sie alle Vorkommen von tblProdukte <\/b>durch qryProdukteOhneBilder <\/b>ersetzen, was an drei Stellen der Fall ist:<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2022_02\/pic_1359_009.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2022_02\/pic_1359_010.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2022_02\/pic_1359_011.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2022_02\/pic_1359_012.png\")
<\/p>\nVorweg: Anreden anlegen<\/h2>\n
Public Sub <\/span>AnredenAnlegen\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n Dim <\/span>objAnrede As <\/span>tblAnreden\r\n objUserQuery = tblAnreden.DataContext\r\n objAnrede = New<\/span> tblAnreden \r\n With<\/span> objAnrede \r\n .ID = 1\r\n .Anredebezeichnung = \"Herr\"\r\n End With<\/span>\r\n objUserQuery.Insert(objAnrede)\r\n objAnrede = New<\/span> tblAnreden()\r\n With<\/span> objAnrede\r\n .ID = 2\r\n .Anredebezeichnung = \"Frau\"\r\n End With<\/span>\r\n objUserQuery.Insert(objAnrede)\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>AnredenAnlegen\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n objUserQuery = tblAnreden.DataContext\r\n objUserQuery.Insert(New<\/span> tblAnreden With<\/span> {.ID = 1, .Anredebezeichnung = \"Herr\"})\r\n objUserQuery.Insert(New<\/span> tblAnreden With<\/span> {.ID = 2, .Anredebezeichnung = \"Frau\"})\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>AnredenLoeschen\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n objUserQuery = tblAnreden.DataContext\r\n objUserQuery.Execute(\"DELETE FROM tblAnreden\")\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>AnredenAusgeben\r\n Dim <\/span>objAnrede As <\/span>tblAnreden\r\n For Each objAnrede In tblAnreden\r\n Debug.Print<\/span>(objAnrede.ID & \" \" & objAnrede.Anredebezeichnung)\r\n Next<\/span> objAnrede\r\nEnd Sub<\/span><\/pre>\nZufallsdaten mit Bogus ermitteln<\/h2>\n
https:\/\/github.com\/bchavez\/Bogus#bogus-api-support<\/pre>\n
\n
Zufallsdaten mit der Faker-Klasse<\/h2>\n
Sub <\/span>Main\r\n Dim <\/span>objFaker As <\/span>New<\/span> Bogus.Faker\r\n Debug.Print<\/span>(objFaker.Name.FirstName)\r\nEnd Sub<\/span><\/pre>\nAdressdaten für Deutschland<\/h2>\n
Dim <\/span>objFaker As <\/span>New<\/span> Bogus.Faker(\"de\")\r\nDebug.Print<\/span>(objFaker.Name.FirstName)\r\nDebug.Print<\/span>(objFaker.Address.StreetAddress)\r\nDebug.Print<\/span>(objFaker.Address.ZipCode)\r\nDebug.Print<\/span>(objFaker.Address.City)<\/pre>\nKunden anlegen<\/h2>\n
Public <\/span>Enum Gender\r\n Male = 0\r\n Female = 1\r\nEnd Enum<\/pre>\nPublic Sub <\/span>KundenAnlegen(intMenge As <\/span>Int32)\r\n Dim <\/span>Beispielkunde As <\/span>New<\/span> tblKunden\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n Dim <\/span>i As <\/span>Int32\r\n Dim <\/span>intGender As <\/span>int32<\/pre>\n objUserQuery = tblKunden.DataContext\r\n Dim <\/span>objFaker As <\/span>New<\/span> Bogus.Faker(Of tblKunden)(\"de\")<\/pre>\n objFaker.Rules(Function(f, k)\r\n intGender = f.PickRandom(Of Gender)<\/pre>\n
k.AnredeID = intGender + 1<\/pre>\n
k.Vorname = f.Name.FirstName(intGender)<\/pre>\n
k.Nachname = f.Name.LastName()\r\n k.Strasse = f.Address.StreetAddress\r\n k.PLZ = f.Address.ZipCode\r\n k.Ort = f.Address.City\r\n k.Land = f.Address.Country\r\n k.EMail = f.Internet.Email\r\n k.Telefon = f.Phone.PhoneNumber\r\n k.Telefax = f.Phone.PhoneNumber\r\n End Function)<\/pre>\n
For i = 1 To intMenge\r\n Beispielkunde = objFaker.Generate\r\n Beispielkunde.ID = i\r\n objUserQuery.Insert(Beispielkunde)\r\n Next<\/span> \r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>KundenAusgeben\r\n Dim <\/span>objKunde As <\/span>tblKunden\r\n For Each objKunde In tblKunden\r\n Debug.Print<\/span>(objKunde.ID & \" \" & objKunde.AnredeID & \" \" & objKunde.Vorname & \" \" & objKunde.Nachname & \" \" & objKunde.Strasse & \" \" & objKunde.PLZ & \" \" & objKunde.Ort)\r\n Next<\/span> objKunde\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>KundenLoeschen\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n objUserQuery = tblKunden.DataContext\r\n objUserQuery.Execute(\"DELETE FROM tblKunden\")\r\nEnd Sub<\/span><\/pre>\nSub <\/span>Main\r\n KundenLoeschen\r\n AnredenLoeschen\r\n AnredenAnlegen\r\n AnredenAusgeben\r\n KundenAnlegen(10)\r\n KundenAusgeben\r\nEnd Sub<\/span><\/pre>\nBeispieldaten für umfangreicheres Datenmodell<\/h2>\n
![\"Datenmodell](\"..\/fileadmin\/_temp_\/2022_02\/pic_1359_001.png\")
<\/p>\n\n
Hinzufügen von Produkten<\/h2>\n
Public Sub <\/span>ProdukteAnlegen(intMenge As <\/span>Int32)\r\n Dim <\/span>Beispielprodukt As <\/span>New<\/span> tblProdukte\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n Dim <\/span>i As <\/span>Int32\r\n objUserQuery = tblProdukte.DataContext\r\n Dim <\/span>objFaker As <\/span>New<\/span> Bogus.Faker(Of tblProdukte)(\"de\")\r\n objFaker.Rules(Function(f, p)\r\n p.Produktbezeichnung = f.Commerce.ProductName\r\n p.Einzelpreis = f.Commerce.Price(10, 100, 2)\r\n End Function)\r\n For i = 1 To intMenge\r\n Beispielprodukt = objFaker.Generate\r\n Beispielprodukt.ID = i\r\n objUserQuery.Insert(Beispielprodukt)\r\n Next<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
Sub <\/span>Main\r\n ...\r\n ProdukteAnlegen(10)\r\n ...\r\nEnd Sub<\/span><\/pre>\nProblem mit Anlagefeldern<\/h2>\n
![\"Problem](\"..\/fileadmin\/_temp_\/2022_02\/pic_1359_013.png\")
<\/p>\n![\"Abfrage](\"..\/fileadmin\/_temp_\/2022_02\/pic_1359_014.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2022_02\/pic_1359_015.png\")
<\/p>\nPublic Sub <\/span>ProdukteAnlegen(intMenge As <\/span>Int32)\r\n Dim <\/span>Beispielprodukt As <\/span>New<\/span> qryProdukteOhneBilder\r\n ...\r\n objUserQuery = qryProdukteOhneBilder.DataContext\r\n Dim <\/span>objFaker As <\/span>New<\/span> Bogus.Faker( Of qryProdukteOhneBilder)(\"de\")\r\n ...\r\n