TSQLiteDatabase: A SQLite3 Database Wrapper

[HalloDu]

TSQLiteDatabase: A SQLite3 Database Wrapper
Kompatible SQLite3 Version: 3.6.16
TSQLiteDatabase ist ein nahezu vollständiger OOP-Wrapper um die SQLite3.dll. Er wurde erstellt da ich für eine Anwendung in Delphi 2009 ein kleine, freie Datenbank brauchte nd ich mich für SQLite entschieden hatte. Da ich aber für den Zugriff eine kleine, schlanke Klasse brauchte und mir die im Internet gefundenen Lösungen nicht gefallen haben, habe ich kurzerhand selbst einen Wrapper geschrieben. Zur Nutzung wird die SQLite3.dll benötigt

Features
Verbinden mit einer SQLite3 kompatiblen Datenbank
Ausführen von SQL-Statments
Bindings in den Statments
Erzeugen von Collations, Aggregaten und Funktionen
Fortschrittsereignis bei längeren Prozessen
Autorisieren von bestimmten SQL-Aktionen
Blob-Zugriff als Stream
Weiterarbeiten mit SQLite-internen Werten
Limits setzen
In Delphi 2009: Unicode
NoVCL kompatibel

Beispiele zur Benutzung
Zur Datenbank verbinden und ein "INSERT" ausführen

Delphi-Quellcode:

var DB: TSQLiteDatabase;
begin
  DB :=  TSQLiteDatabase.Create('test.db');
  DB.Execute('INSERT INTO TEST (TEST) VALUES ("TEST");');
  DB.Free;
end;

Ein "INSERT" mit Binding

Delphi-Quellcode:

var DB: TSQLiteDatabase;
    Command: TSQLiteCommand;
begin
  DB :=  TSQLiteDatabase.Create('test.db');
  Command := DB.Command('INSERT INTO TEST (TEST) VALUES (?);');
  Command.Binding[1].AsString := 'Test';
  Command.Execute;
  Command.Free;
  DB.Free;
end.

Auflisten der Daten einer Tabelle

Delphi-Quellcode:

var DB: TSQLiteDatabase;
    Query: TSQLiteQuery;
begin
  DB :=  TSQLiteDatabase.Create('test.db');
  Query := DB.Query('SELECT * FROM TEST');
  while Query.Next do
    begin
      WriteLn(Query[0].AsString);
    end;
  Query.Free;
  DB.Free;
end.

Beispiel mit vielen "INSERT"s

Delphi-Quellcode:

var DB: TSQLiteDatabase;
    Command: TSQLiteCommand;
begin
  DB :=  TSQLiteDatabase.Create('test.db');
  DB.Execute('BEGIN TRANSACTION'); // Damit nicht so viele Festplattenzugriffe gemacht werden müssen
  Command := DB.Command('INSERT INTO TEST (TEST) VALUES (?);');
  For I := 1 to 200 do
    begin
      Command.Reset; 
      Command.Binding[1].AsString := 'Test'+IntToStr(I);
      Command.Execute;
    end;
  Command.Free;
  DB.Execute('END TRANSACTION');
  DB.Free;
end.

Getestet mit...
Delphi 2009 größtenteils, da ich es im Moment in einem Projekt einsetze
Delphi 7 rudimentär

SVN: svn://delphidev.net/public/SQLiteDatabase

Wäre klasse, wenn sich das wer von euch mal ansehen oder sogar ein bisschen testen könnte

[HalloDu]

Entschuldigung das ich mich erst heute wieder melde, hatte recht viel zu tun und das dann über die Arbeit etwas verpennt. Also was dein Problem angeht, so solltest du einfach ein simples Reset vor jedem neuverwenden des Statments aufrufen, dann sollte es gehn. Was die Performance angeht, so ist das Problem, dass wenn du 100 Einträge hinzufügst jedesmal ein Festplattenzugriff gemacht werden muss.

Delphi-Quellcode:

DB.Execute('BEGIN TRANSACTION');
//INSERTS, INSERTS, INSERTS
DB.Execute('END TRANSACTION');

beschleunigt das ganze enorm. (oben Beispiel hinzugefügt)

PS: Was die Interfaces angeht, so bin ich da noch nicht ganz durchgestiegen, es ist aber jeder angehalten, der möchte, sich in diesem Bereich an dem Projekt zu beteiliegen.

[Mithrandir]

Also in meinem Fall so:

Delphi-Quellcode:

procedure TDatabase.AddFile(FileSpecs: TFileSpecs);
  var
    FileCmd: TSQLiteCommand;
  begin
    DB.Execute('BEGIN TRANSACTION');
    FileCmd := fDB.Command('INSERT INTO FILES (FILE_PATH, FILE_EXT, FILE_TITLE, FILE_ARTIST, FILE_ALBUM, FILE_YEAR, FILE_GENRE, FILE_LENGTH) ' +
                        'VALUES ( ? , ? , ? , ? , ? , ? , ? , ? );');
    FileCmd.Binding[1].AsString := FileSpecs.fFilePath;
    FileCmd.Binding[2].AsString := FileSpecs.fFileExtType;
    FileCmd.Binding[3].AsString := FileSpecs.fTitle;
    FileCmd.Binding[4].AsString := FileSpecs.fArtist;
    FileCmd.Binding[5].AsString := FileSpecs.fAlbum;
    FileCmd.Binding[6].AsString := FileSpecs.fYear;
    FileCmd.Binding[7].AsString := FileSpecs.fGenre;
    FileCmd.Binding[8].AsInteger := FileSpecs.fLength;
    FileCmd.Execute;
    FileCmd.Free;
    DB.Execute('END TRANSACTION');
  end;

oder?

[HalloDu]

Das hätte keine Auswirkung auf die Performance. Du musst, wenn du weißt, dass das mehrere Inserts werden werden, diesen Prozess, z.B. eine For-Schleife, mit der Transaktion umgeben, siehe Beispiel oben. Das ist sowieso bei vielen Änderungen in der Datenbank zu empfehlen, und auch bei den meisten Datenbanken machbar. Wenn z.B. ein Problem auftritt, kannst du dann den ganzen Prozess mit einem Rollback wieder rückgängig machen, siehe dazu SQLite Doku

[Mithrandir]

Ah, ok. Und wie genau war das mit dem Reset gemeint?

[xZise]

Ich nehme mal er meinte das so:

Code:

BEGIN TRANSACTION
  INSERT ...
  Schleife:
    Binds ...
    Exec ...
    Reset ...
COMMIT

Achso und warum muss man ".Execute('BEGIN TRANSACTION')" aufrufen? Also ich fand es total unpraktisch und habe es so implementiert, wie bei "BeginUpdate"/"EndUpdate". Weil wenn ich das richtig noch in Erinnerung habe, dann kann man nur einmal "Begin Transaction" aufrufen.

MfG
xZise

[Wormid]

Hallöchen,

gibt es eigentlich eine aktuellere Version des Wrappers? Hat sich daran noch etwas getan?

Gruß

Wormid

[dGeek]

Ich habe mal ein wenig gebuddelt und das Thema hier gefunden.
Ich stelle mir gerade die Frage, ob ich von INI zu SQLite3 umstellen sollte oder eher nicht.

In einer INI-Datei meines Projektes können zwischen 1 und 100 Sektionen sein (in der Regel maximal 10) mit etwa (je nach Sektion) 20 bis 30 Schlüsseln.
Es wird relativ häufig auf die einzelnen Schlüssel zugegriffen. Eigentlich sogar immer - egal, was man bei meinem Projekt macht, wird irgendetwas ausgelesen.

Da stellt sich mir nun die Frage: weiterhin INI oder SQLite3?

[Sir Rufo]

Bau dir eine abstrakte Klasse, wo du die Werte abfragen kannst.

Dann dazu die konkrete für eine Ini-Datei (beim reinen Lesen bietet sich auf jeden Fall TMemIniFile an) und bei Bedarf weitere (die dann z.B. mit einer SQlite DB spricht).

Dann kannst du die auch direkt vergleichen, was dir genehmer ist oder was im konkreten Fall besser passt.

Eine Ableitung von TCustomIniFile die dann mit einer SQlite Datenbank spricht ist natürlich auch denkbar.

[dGeek]

So wie ich das verstanden habe, kann ich also einfach TIniFile durch TMemIniFile austauschen.
Und dort wo gespeichert wird, müsste ich dann UpdateFile aufgerufen werden.

Richtig oder liege ich total falsch?

[Sir Rufo]

Richtig.

Trotz allem würde ich eine Basis-Klasse für die Einstellungen erschaffen und dann konkrete die aus einem bestimmten Topf die Daten beschaffen.