{"id":55000088,"date":"2017-06-01T00:00:00","date_gmt":"2020-03-27T19:26:44","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=88"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"SQLiteDatenmodellierung_per_C","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/SQLiteDatenmodellierung_per_C\/","title":{"rendered":"SQLite-Datenmodellierung per C#"},"content":{"rendered":"

Wenn Sie eine SQLite-Datenbank von einer WPF\/C#-Anwendung aus nutzen, möchten Sie gegebenenfalls einmal Tabellen in dieser Datenbank anlegen, ändern oder löschen oder gar neue Datenbanken mit C# erstellen. Dies kann beispielsweise interessant werden, wenn Sie eine neue Version einer Anwendung ausliefern, aber der Benutzer die Daten in der Datenbank der vorherigen Version weiter nutzen möchte. Dieser Artikel stellt die grundlegenden Vorgehensweisen für diese Arbeitsschritte vor.<\/b><\/p>\n

NuGet-Paket für SQLite hinzufügen<\/h2>\n

Wenn Sie von einer C#-Anwendung aus Änderungen an einer SQLite-Datenbank vornehmen oder diese sogar erstellen wollen, benötigen Sie das NuGet-Paket mit den entsprechenden Erweiterungen. Dazu klicken Sie mit der rechten Maustaste auf das Projekt im Projektmappen-Explorer und wählen den Kontextmenü-Eintrag NuGet-Pakete verwalten… <\/b>aus. Im nun erscheinenden Bereich wechseln Sie auf Durchsuchen und suchen nach SQLite<\/b>. Den nun auftauchenden Eintrag System.Data.SQLite <\/b>können Sie dann auswählen und installieren.<\/p>\n

SQLite-Befehle verfügbar machen<\/h2>\n

In der Klasse, in der Sie die Befehle zum Erstellen und Anpassen von SQLite-Datenbanken unterbringen wollen, benötigen Sie zunächst einen Verweis auf den Namespace System.Data.SQLite<\/b>, der erst nach dem Hinzufügen des oben genannten NuGet-Pakets vorfinden:<\/p>\n

using System.Data.SQLite;<\/pre>\n
Leere Datenbank erstellen<\/h2>\n
Um eine leere Datenbank zu erstellen, fügen wir dem Fenster MainWindow.xaml <\/b>ein Textfeld zur Eingabe des Datenbanknamens sowie eine Schaltfläche zum Erstellen der leeren Datenbankdatei hinzu. Diese Schaltfläche soll die folgende Methode auslösen:<\/p>\n
private void btnCreateDatabase_Click(object sender, RoutedEventArgs e) {\r\n     string databaseFile = AppDomain.CurrentDomain.BaseDirectory + txtDatenbankname.Text;\r\n     File.Delete(databaseFile);\r\n     SQLiteConnection.CreateFile(databaseFile);\r\n     if (File.Exists(databaseFile)) {\r\n         MessageBox.Show(\"Leere Datenbank \\n\\n''\" + databaseFile + \"''\\n\\n wurde erstellt.\");\r\n     }\r\n}<\/pre>\n
Die Methode trägt den Pfad der .exe<\/b>-Datei plus den vom Benutzer gewählten Datenbanknamen in die Variable databaseFile <\/b>ein. Diese Datei wird, sofern vorhanden, gelöscht und dann mit der Methode CreateFile <\/b>des Objekts SQLiteConnection <\/b>neu erstellt. Dabei übergeben Sie die Variable mit dem Datenbankpfad als Parameter. Die folgende if<\/b>-Bedingung prüft, ob nach diesem Vorgang eine Datei mit dem angegebenen Namen vorhanden ist und zeigt in diesem Fall eine entsprechende Meldung an.<\/p>\n
Neue Tabelle erstellen<\/h2>\n
Nun wollen wir der frisch angelegten Datenbank eine erste Tabelle hinzufügen. Das ist dann auch tatsächlich der erste Inhalt der Datenbankdatei – diese weist nach dem Anlegen nämlich die Dateigröße 0 <\/b>auf (siehe Bild 1). Danach rufen wir mit der Tasten btnCreateTable <\/b>die folgende Methode auf, die wieder den Pfad der .exe<\/b>-Datei und den Dateinamen aus dem Textfeld in der Variablen databaseFile <\/b>zusammensetzt. Dann erstellt sie ein neues Objekt des Typs SQLiteConnection<\/b>, der sie als Konstruktor-Parameter eine Zeichenkette übergibt, die aus Data Source=<\/b>, dem Datenbankpfad und der zu verwenden Version besteht.<\/p>\n
\"Frisch<\/p>\n
Bild 1: Frisch angelegte Datenbankdatei<\/span><\/b><\/p>\n
Die Open<\/b>-Methode öffnet die Verbindung zu dieser Datenbank. Dann schreibt die Methode eine CREATE TABLE<\/b>-Anweisung, die eine neue Tabelle namens Beispieltabelle <\/b>mit den beiden Feldern id <\/b>und Beispielstring <\/b>enthält. Nun erstellt die Methode ein neues SQLiteCommand<\/b>-Objekt und übergibt die SQL-Anweisung aus der String-Variablen sql <\/b>sowie das Verbindungsobjekt aus connection <\/b>als Parameter. Die ExecuteNonQuery<\/b>-Methode führt die CREATE TABLE<\/b>-Anweisung schließlich aus. Mit der Close<\/b>-Methode schließen wir die Verbindung:<\/p>\n
private void btnCreateTable_Click(object sender, RoutedEventArgs e) {\r\n     string databaseFile = AppDomain.CurrentDomain.BaseDirectory + txtDatenbankname.Text;\r\n     SQLiteConnection connection = new SQLiteConnection(\"Data Source=\" + databaseFile + \";Version=3;\");\r\n     connection.Open();\r\n     string sql = \"CREATE TABLE Beispieltabelle (id INT, Beispielstring VARCHAR(255))\";\r\n     SQLiteCommand command = new SQLiteCommand(sql, connection);\r\n     command.ExecuteNonQuery();\r\n     connection.Close();\r\n}<\/pre>\n
Ein Blick in den Windows Explorer zeigt, dass dies nicht spurlos an der Datenbankdatei vorübergegangen ist: Diese hat nun immerhin eine Größe von acht Kilobytes. Aber befindet sich auch die neue Tabelle darin Dies prüfen wir mit dem Tool SQLiteStudio<\/b>, das Sie kostenlos über das Internet herunterladen können. Mit dem Menüeintrag Datenbank|Datenbank hinzufügen <\/b>öffnen Sie den Dialog aus Bild 2. Hier wählen Sie die soeben angelegte Datei aus und klicken nach dem Betätigen von Verbindung testen <\/b>auf die Schaltlfäche OK<\/b>.<\/p>\n
\"Hinzufügen<\/p>\n
Bild 2: Hinzufügen der Datenbank zum SQLiteStudio<\/span><\/b><\/p>\n
Danach finden Sie im Hauptfenster von SQLiteStudio <\/b>bereits die Datenbank mit der ersten Tabelle im Datenbank-Explorer vor (siehe Bild 3). Allerdings verfügt das Feld id<\/b> noch nicht über eine Primärschlüssel, aber das können wir ja gleich nachholen – indem wir die neue Tabelle verändern.<\/p>\n
\"Die<\/p>\n
Bild 3: Die neue Tabelle im SQLiteStudio<\/span><\/b><\/p>\n
Tabelle mit Primärschlüsselfeld erstellen<\/h2>\n
Im nächsten Beispiel wollen wir eine Tabelle erstellen und das ID<\/b>-Feld direkt als Primärschlüsselfeld kennzeichnen. Dazu fügen wir der CREATE TABLE<\/b>-Methode gleich das Schlüsselwort PRIMARY KEY <\/b>für das Feld ID <\/b>hinzu. Dazu nutzen wir prinzipiell die gleiche Methode wie für das vorherige Beispiel:<\/p>\n
private void btnTabelleMitPKAnlegen_Click(object sender, RoutedEventArgs e) {\r\n     string databaseFile = AppDomain.CurrentDomain.BaseDirectory + txtDatenbankname.Text;\r\n     string connectionString = \"Data Source=\" + databaseFile + \";Version=3;\";\r\n     MessageBox.Show(connectionString);\r\n     SQLiteConnection connection = new SQLiteConnection(connectionString);\r\n     connection.Open();\r\n     string sql = \"CREATE TABLE BeispieltabelleMitPK (id INT PRIMARY KEY, Beispielstring VARCHAR(255))\";\r\n     SQLiteCommand command = new SQLiteCommand(sql, connection);\r\n     command = new SQLiteCommand(sql, connection);\r\n     command.ExecuteNonQuery();\r\n     connection.Close();\r\n}<\/pre>\n
Auch das liefert das gewünschte Ergebnis, wie ein Blick in SQLiteStudio<\/b> beweist (siehe Bild 4).<\/p>\n
\"Tabelle<\/p>\n
Bild 4: Tabelle mit Primärschlüssel im SQLiteStudio<\/span><\/b><\/p>\n
Nun habe ich allerdings beim Erstellen der neuen Tabelle bei Experimentieren vergessen, das Textfeld txtDatenbankname <\/b>zu füllen. Es gibt allerdings beim Durchlaufen der obigen Methode keinerlei Fehlermeldung – wie kann das sein Theoretisch dürfte der Zugriff auf die Datenbank mit der Open<\/b>-Methode doch gar nicht funktionieren, da die Datenbankdatei gar nicht vorhanden ist Doch das ist ein Fehlschluss: Dadurch, dass wir txtDatenbankname <\/b>nicht gefüllt haben, übergeben wir nämlich einen String wie den folgenden mit connectionString <\/b>an die Open<\/b>-Methode:<\/p>\n
Data Source=C:\\Users\\User\\...\\bin\\Debug\\;Version=3;<\/pre>\n
Wenn wir nun in das Verzeichnis …\\bin\\Debug <\/b>schauen, finden wir dort auch keine neue Datenbank etwa mit einem beim Öffnen temporär vergebenen Namen. Wenn wir allerdings eine Ebene nach oben gehen, also in das Verzeichnis …\\bin<\/b>, finden wir die Situation aus Bild 5 vor. SQLite legt, wenn die in der Verbindungszeichenfolge für die Open<\/b>-Methode angegebene Datenbankdatei noch nicht vorhanden ist, eine neue Datenbank an. In diesem Fall hat SQLite Debug\\;Version=3;<\/b> als Dateinamen interpretiert und eine Datei namens Debug;Version=3 <\/b>angelegt (das Backslash-Zeichen \\ <\/b>wurde dabei als Escape-Zeichen für das Semikolon interpretiert). Die Größe von 20 KB <\/b>zeigt an, dass hier auch gleich die gewünschte Tabelle angelegt wurde.<\/p>\n
\"Eine<\/p>\n
Bild 5: Eine Datenbankdatei namens Debug;Version=3<\/span><\/b><\/p>\n
Autowert definieren<\/h2>\n
Beim Einfügen von Datensätzen müssen wir uns Gedanken darum machen, auf welche Weise der Wert des Primärschlüsselfeldes definiert wird. Unter Access wurde das immer einfach durch Festlegen der Eigenschaft Autowert <\/b>für das betroffene Feld erledigt. Unter SQLite ist das auch nicht viel anders: Hier fügen Sie hinter dem PRIMARY KEY<\/b>-Schlüsselwort einfach noch AUTOINCREMENT <\/b>ein (siehe Methode btnTabelleMitAutowertAnlegen_Click<\/b>):<\/p>\n
CREATE TABLE BeispieltabelleMitAutowert(ID INTEGER PRIMARY KEY AUTOINCREMENT, ...)<\/pre>\n
SQLite hat hier allerdings eine etwas andere Philosophie als andere Datenbanksysteme: Sie müssen gar nicht unbedingt eine Autoincrement-Funktion definieren, sondern können das Primärschlüsselfeld auch einfach nur als INTEGER PRIMARY KEY <\/b>definieren. Wenn Sie dann beim Neuanlegen eines Datensatzes keinen Wert für das Primärschlüsselfeld angeben, fügt SQLite automatisch einen entsprechend ermittelten Wert ein. Gegenüber anderen Datenbanksystemen haben Sie so die Wahl, ob Sie das System einen Primärschlüsselwert auswählen lassen wollen oder ob Sie diesen selbst vergeben wollen. Mehr dazu erfahren Sie weiter unten unter Datensätze einfügen<\/b>.<\/p>\n
Prüfen, ob Datenbank vorhanden ist<\/h2>\n
Wir wollen an dieser Stelle den Benutzer darauf hinweisen, dass die Datenbank noch nicht vorhanden ist und die Methode abbrechen. Das erledigen wir mit einer entsprechenden if<\/b>-Bedingung:<\/p>\n
private void btnTabelleMitPKAnlegen_Click(object sender, RoutedEventArgs e) {\r\n     string databaseFile = AppDomain.CurrentDomain.BaseDirectory + txtDatenbankname.Text;\r\n     if (!File.Exists(databaseFile)) {\r\n         MessageBox.Show(\"Die Datenbank \\n\\n''\" + databaseFile + \"''\\n\\nist nicht vorhanden.\");\r\n     }\r\n     else {\r\n        \/\/Tabelle anlegen\r\n     }\r\n}<\/pre>\n
Herstellen einer Verbindung in eigener Methode<\/h2>\n
In den bisherigen Beispielen haben wir jeweils einige Anweisungen eingebaut, welche die Verbindung herstellen und mit der Variablen connection <\/b>referenzieren. Damit wir diese Zeilen nicht in jeder neuen Methode erneut schreiben müssen, gliedern wir diese in eine eigene Methode aus und erweitern deren Funktionsumfang gleich ein wenig.<\/p>\n
Die neue Methode heißt VerbindungOeffnen und erwartet den Pfad zur Datenbankdatei als Parameter (datenbankpfad<\/b>) sowie einen Boolean-Wert namens datenbankErstellen<\/b>, der angibt, ob die Datenbank erstellt werden soll, wenn Sie noch nicht vorhanden ist. Die Methode stellt die Boolean-Variable datenbankExistiert <\/b>zunächst auf true <\/b>ein. Dann prüft sie, ob die mit datenbankpfad <\/b>angegebene Datei existiert. Falls nicht, wird datenbankExistiert <\/b>auf false <\/b>eingestellt und eine Meldung ausgegeben, dass die Datenbank nicht vorhanden ist. Falls die Datenbank existiert, baut die Methode in der zweiten if<\/b>-Bedingung eine Verbindungszeichenfolge zusammen, erstellt ein SQLiteConnectionString<\/b>-Objekt auf Basis dieser Verbindung und öffnet diese mit der Open<\/b>-Methode. Die Verbindung wird dann als Rückgabewert zurückgeliefert. Sollte datenbankExistiert <\/b>den Wert false <\/b>enthalten, liefert die Methode den Wert null <\/b>zurück:<\/p>\n
private SQLiteConnection VerbindungOeffnen(string datenbankpfad, bool datenbankErstellen = false) {\r\n     bool datenbankExistiert = true;\r\n     if (!File.Exists(datenbankpfad)) {\r\n         if (!datenbankErstellen) {\r\n             datenbankExistiert = false;\r\n             MessageBox.Show(\"Die Datenbank \\n\\n''\" + datenbankpfad+ \"''\\n\\nist nicht vorhanden.\");\r\n         }\r\n     }\r\n     if (datenbankExistiert) {\r\n         string connectionString = \"Data Source=\" + datenbankpfad + \";Version=3;\";\r\n         SQLiteConnection connection = new SQLiteConnection(connectionString);\r\n         connection.Open();\r\n         return connection;\r\n     }\r\n     else {\r\n         return null;\r\n     }\r\n}<\/pre>\n
Prüfen, ob Tabelle vorhanden ist<\/h2>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 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