16 diub.SQLite

Eine einfache Wrapper-Klasse zur direkten Nutzung von SQLite (sqlite3.dll).

Die Implementierung stellt keine Universal-Schnittstelle dar! Es werden lediglich die Grundfunktionalitäten breitgestellt, diese aber in bequemer Weise.

Quellcode

Der Quellcode steht zur Verfügung unter https://github.com/diub/diub.SQlite3.

Beispiel Klasse

Alle Felder, welche in der Tabelle abgelegt werden sollen, müssen public sein!

public class StorageHash : LUIDRecord {
	public Int64 FileSize;
	public byte [] SHA512;
	public byte [] MD5;
	/// <summary>
	/// Laufende Nummer für UNDO.
	/// </summary>
	public Id SessionId;
}

16.1 Erzeugen, Öffnen & Schließen

// SEOS; Serialized Object Storage; bezieht sich auf diub.SeOSQLite
internal SQLite3 SEOS;

SEOS = new SQLite3 ("C:\\Example.sqlite");
bool b = SEOS.Connect ();	// oder SEOS.Open ();
...
bool b = SEOS.Disconnect ();	// oder SEOS.Close ();

16.2 Tabelle anlegen

• Tabellen werden immer aus einer Klasse erzeugt.
• Verschachtelte Klassen werden unterstützt.
• Alle Felder, welche in der Tabelle abgelegt werden sollen, müssen public sein!
• Properties sind (a) keine Daten sondern C#-Funktionen und (b) kein Selbstzeck! Daher haben sie (meiner Meinung nach) in einer Datenbank nichts verloren.

Der Aufruf kann beliebig oft erfolgen: Existiert die Tabelle bereits, wird sie nicht neu angelegt oder verändert.

bool b = SEOS.CreateTable ("StorageTable", typeof (StorageHash));

16.3 Tabelle löschen

bool b = SEOS.DropTable ("StorageTable");

16.4 Index erzeugen

// Index über eine Spalte
bool b = SEOS.CreateIndex ("StorageTable", "StorageTable_ID", true,
	nameof (StorageHash.LUID) );
// Index über mehrere Spalten
bool b = SEOS.CreateIndex ("StorageTable", "StorageTable_INDEX", true,
	nameof (StorageHash.FileSize), nameof (StorageHash.MD5),
	nameof (StorageHash.SHA512) );

16.5 Abfragen

Vergleichstypen

• Equal
  Standard, wenn kein Vergleichstyp angegeben wird.
• LessThen, LessThanOrEqual, GreaterThan, GreaterThanOrEqual, Unequal
• Like, Unlike, StartsWith, EndsWith
  Für diese Vergleichstypen muss das Vergleichs-Argument um Sonderzeichen ergänzt werden.
  Bei Verwendung von QueryItem erfolgt dies automatisch (durch SQLite3.QuerySetAsWhereStatements).

Prepare...Query

Vordefinierte Abfrage beschleunigen die Verarbeitung enorm.

Wichtig! Die Datenbank muss bei der Erzeugung geöffnet sein!

In vielen Beispielen zu SQLite wird die Datenbank geöffnet, bearbeitet und anschließend gleich wieder geschlossen. Dieses Vorgehen dient nur dem Beispiel!

Im echten Betrieb wird die Datenbank (global) geöffnet und erst, wenn keine Zugriffe mehr erfolgen sollen, geschlossen.

QueryItem

QueryItem dienen der Definition von Teilabfragen durch Angabe von Feldname und Vergleichstyp (QueryCompareType)!

16.5.1 Einfügen (Insert)

Abfrage

public SQLite3.SQLiteInsertQuery<StorageHash> insert_query =
 SEOS.PrepareInsertQuery<StorageHash> ("StorageTable");

Ausführung

StorageHash sh = new StorageHash (Identifier, IFD);
bool b = SEOS.Insert<StorageHash> (
       insert_query,
       sh);
bool b = insert_query.Insert (
       SEOS,
       sh);
// Funktioniert so nur, so lange die Datenbank ständig geöffnet bleibt!
// sonst vorher: insert_query.Database = ... ; 
bool b = insert_query.Insert (
	sh);

16.5.2 Auslesen (Select)

Abfrage

// Default: QueryCompareType.EQUAL
queries = new List<QueryItem> ();
queries.Add (new QueryItem (nameof (StorageHash.FileSize)));
queries.Add (new QueryItem (nameof (StorageHash.SHA512)));
queries.Add (new QueryItem (nameof (StorageHash.MD5)));
public SQLite3.SQLiteSelectQuery<StorageHash> select_query;
select_query = SEOS.PrepareSelectQuery<StorageHash> (
	"StorageTable", queries.ToArray());

Ausführung

List<StorageHash> hashes;
byte [] SHA512 = {..}, MD5 = {..};
hashes = SEOS.SelectList<StorageHash> (
	select_query,
	32184, SHA512, MD5);
hashes = select_query.SelectList (
       SEOS,
	32184, SHA512, MD5);
// Funktioniert so nur, solage die Datenbank ständig geöffnet bleibt!
// sonst vorher: select_query.Database = ... ; 
hashes = select_query.SelectList (
	32184, SHA512, MD5);

16.5.3 Löschen (Delete)

Abfrage

public SQLite3.SQLiteDeleteQuery storage_sessionid_delete_query;
query = new QueryItem (nameof (StorageHash.SessionId));
delete_query = SEOS.PrepareDeleteQuery<StorageHash> (
	"StorageTable", query);

Ausführung

bool b = SEOS.Delete (delete_query, SessionId);
bool b = delete_query.Delete (
       SEOS,
       SessionId);
// Funktioniert so nur, solage die Datenbank ständig geöffnet bleibt!
// sonst vorher: delete_query.Database = ... ; 
bool b = delete_query.Delete (SessionId);

16.5.4 Aktualisieren (Update)

Die Aktualisierung ist dual implementiert.

• UpdateIfExist
  Implementiert das Standardverhalten von SQLite.
  Standardmäßig aktualisiert SQLite nur, wenn mindestens ein passender Eintrag gefunden wird.
• UpdateOrInsert
  Diese Variante ähnelt der von MongoDB.
  Wird kein Eintrag zur Aktualisierung gefunden, führt diese Implementierung automatisch ein Einfügen (Insert) für einen neuen Eintrag aus. Aus Geschwindigkeitsgründen sollten aber echte INSERT vorgezogen werden!

Abfrage

public SQLite3.SQLiteUpdateQuery storage_sessionid_update_query;
query = new QueryItem (nameof (StorageHash.SessionId));
update_query = PrepareUpdateQuery<StorageHash> ("StorageTable", query);

Ausführung

StorageHash sh = new StorageHash (Identifier, IFD);
bool b = SEOS.UpdateOrInsert<StorageHash> (
	update_query,
	sh, storage_hash.SessionId);
bool b = update_query.UpdateOrInsert (
       SEOS,
	sh, storage_hash.SessionId);
// Funktioniert so nur, solage die Datenbank ständig geöffnet bleibt!
// sonst vorher: update_query.Database = ... ; 
bool b = update_query.UpdateOrInsert (
	sh, storage_hash.SessionId);
//////
bool b = SEOS.UpdateIfExist<StorageHash> (
	update_query,
	sh, storage_hash.SessionId);
bool b = update_query.UpdateIfExist (
       SEOS,
	sh, storage_hash.SessionId);
// Funktioniert so nur, solage die Datenbank ständig geöffnet bleibt!
// sonst vorher: update_query.Database = ... ; 
bool b = update_query.UpdateIfExist (
	sh, storage_hash.SessionId);

16.6 Direkte Abfragen

Die Abfragen werden nicht zwischengespeichert! Daher ist diese Variante deutlich langsamer.

Auslesen

List<StorageHash> hashes;
query = new QueryItem (
	nameof (StorageHash.FileSize),
	32876,
	QueryCompareType.Equal
);
hashes = SEOS.QueryList<StorageHash> ("StorageHash", query);

Einen (den ersten gefundenen) oder Keinen (bzw. default (T))

StorageHash hash;
query = new QueryItem (
	nameof (StorageHash.FileSize),
	32876,
	QueryCompareType.Equal
);
hash = SEOS.QueryOne<StorageHash> ("StorageHash", query);

16.7 Transaktionen

Für Details zu Transaktionen siehe die originale SQLite-Dokumentation!

bool b;
b = SEOS.BeginTransaction ();
b = SEOS.Commit ();
b = SEOS.Rollback ()

TransactionModes

Manuelle Transaktionen beschleunigen Insert-, Delete- und Update-Operationen. Einzeloperationen werden automatisch immer in eine Begin-Commit-Abfolge eingebettet und sind daher sehr langsam!

Daher weden 2 sehr unterschiedliche Transaktions-Modi (TransactionMode) unterstützt:

• Exclusiv
  Der Standard bei SQLite. Konkurierende Threads blockieren, bis sie exklusiv die Transaktion durchführen können.
• CombineCache
  Hier sind verschachtelte Transaktionen gestattet. Konkurierende Threads nutzen alle gemeinsam die erste eröffnete Transaktion. Dies dient der schnelleren Verarbeitung aller Abfragen.
  Wichtig: Ein Rollback ist nicht möglich!

16.8 Tabellen ändern: Alter

Die hier vorgestellten Funktionen ändern die Strukturen einer Tabelle. Vordefinierte Abfragen verlieren dadurch ihre Gültigkeit!

• Schließen Sie nach solchen Änderungen die Datenbank und öffnen Sie diese neu!
• Achten Sie darauf, die Abfragen neu aufzubauen.

bool b;
b = AddColumn ("StorageHash", "SpalteX", typeof (string));
b = DropColumn ("StorageHash", "SpalteX");
b = RenameColumn ("StorageHash", "SpalteX", "SpalteY");
b = RenameTable ("StorageHash", "StorageHashBackup")