php dbhandler
1.0.0
PHP-DbHandler ist eine PHP-Bibliothek, die die Interaktion mit MySQL-Datenbanken vereinfachen soll. Es bietet einen umfassenden Satz an Tools zum Erstellen und Ausführen von Abfragen, zum Verwalten von Transaktionen und zum Verwalten von Datenbankschemata über PDO-Verbindungen.
Where und Having -Klauselnor und and OperatorenInstallieren Sie das Paket über Composer:
composer require tribal2/db-handler Beginnen Sie mit der Erstellung einer Db Instanz:
use Tribal2 DbHandler Core PDOWrapper ;
use Tribal2 DbHandler Db ;
use Tribal2 DbHandler DbConfig ;
$ config = DbConfig:: create ( ' my_database ' )
-> withUser ( ' username ' )
-> withPassword ( ' password ' )
-> withHost ( ' localhost ' ) // Optional. Default: 'localhost'
-> withPort ( 3306 ) // Optional. Default: 3306
-> withCharset ( ' utf8mb4 ' ); // Optional. Default: 'utf8mb4'
$ pdoWrapper = new PDOWrapper (
$ config ,
// Optional PsrLogLoggerInterface instance.
// $logger, // Default: PsrLogNullLogger
);
$ db = new Db (
$ pdoWrapper ,
// Optional PsrSimpleCacheCacheInterface instance.
// $cache, // Default: NULL
);Where und Having -KlauselnDie Where-Klasse bietet eine flexible und intuitive Möglichkeit zum Erstellen von Abfragebedingungen. Es unterstützt eine Vielzahl von Vergleichs- und logischen Operatoren, sodass Sie die Kriterien für die Auswahl oder Filterung von Daten aus Ihrer Datenbank genau definieren können.
Die Methoden geben ein Where-Objekt zurück, das die Bedingung zusammen mit einem parametrisierten Wert für sichere und effiziente Abfragen kapselt.
Die Where-Klauseln vereinfachen nicht nur die Erstellung der Abfragesyntax, sondern erhöhen auch die Sicherheit, indem sie die mit der SQL-Injection verbundenen Risiken intern verwalten. Diese Bibliothek ersetzt Werte automatisch durch PDO-benannte Parameter und führt die Bindung mithilfe der entsprechenden PDO-Datentypen durch. Durch die Behandlung dieser entscheidenden Aspekte wird sichergestellt, dass Ihre Abfragen nicht nur sauber und wartbar, sondern auch sicher sind.
Sie müssen sich nicht mehr darum kümmern, Ihre Eingaben für Datenbankabfragen manuell zu bereinigen. Die Bibliothek sorgt dafür, dass die Anweisungen so vorbereitet werden, dass sie vor SQL-Injection geschützt sind, einer der häufigsten Sicherheitslücken in datenbankgesteuerten Anwendungen. Mit diesem Ansatz können Sie sich auf die Geschäftslogik Ihrer Anwendung konzentrieren und darauf vertrauen, dass die Datenbankinteraktionen sicher und effizient gehandhabt werden.
$ where = Where:: equals ( ' status ' , ' active ' );
// Output: `status` = :status___1
$ where = Where:: notEquals ( ' category ' , ' archived ' );
// Output: `category` <> :category___1
$ where = Where:: greaterThan ( ' price ' , 100 );
// Output: `price` > :price___1
$ where = Where:: greaterThanOrEquals ( ' price ' , 100 );
// Output: `price` >= :price___1
$ where = Where:: lessThan ( ' price ' , 50 );
// Output: `price` < :price___1
$ where = Where:: lessThanOrEquals ( ' price ' , 50 );
// Output: `price` <= :price___1
$ where = Where:: isNull ( ' description ' );
// Output: `description` IS NULL
$ whereNotNull = Where:: isNotNull ( ' description ' );
// Output: Output: `description` IS NOT NULL $ where = Where:: like ( ' name ' , ' %Apple% ' );
// Output: `name` LIKE :name___1
$ where = Where:: notLike ( ' name ' , ' %Apple% ' );
// Output: `name` NOT LIKE :name___1
$ where = Where:: between ( ' date ' , ' 2021-01-01 ' , ' 2021-12-31 ' );
// Output: `date` BETWEEN :date___1 AND :date___2
$ where = Where:: notBetween ( ' date ' , ' 2021-01-01 ' , ' 2021-12-31 ' );
// Output: `date` NOT BETWEEN :date___1 AND :date___2
$ where = Where:: in ( ' status ' , [ ' active ' , ' pending ' , ' on-hold ' ]);
// Output: `status` IN (:status___1, :status___2, :status___3)
$ where = Where:: notIn ( ' status ' , [ ' active ' , ' pending ' , ' on-hold ' ]);
// Output: `status` NOT IN (:status___1, :status___2, :status___3)or und and Operatoren $ where1 = Where:: equals ( ' status ' , ' active ' );
$ where2 = Where:: greaterThan ( ' price ' , 100 );
$ orWhere = Where:: or ( $ where1 , $ where2 );
// Output: (`status` = :status___1 OR `price` > :price___1)
$ andWhere = Where:: and ( $ where1 , $ where2 );
// Output: (`status` = :status___1 AND `price` > :price___1)Sie können die Operatoren
orundandauch verschachteln:
$ where3 = Where:: equals ( ' category ' , ' archived ' );
$ combinedWhere = Where:: and ( $ where3 , $ orWhere );
// Output: (`category` = :category___1 AND (`status` = :status___1 OR `price` > :price___1)) In den folgenden Unterabschnitten erfahren Sie, wie Sie mithilfe dieser Bibliothek Abfragen erstellen und ausführen. Der Einfachheit halber gehen wir davon aus, dass die Variable $db eine Instanz der Db -Klasse ist.
In allen folgenden Beispielen haben wir die Abfragekonstruktion von der Ausführung getrennt. Mit diesem Ansatz können Sie das Abfrageobjekt wiederverwenden und mehrmals mit unterschiedlichen Parametern ausführen. Sie können die Methoden zum Erstellen und Ausführen der Abfrage jedoch auch wie folgt in einer einzigen Anweisung verketten:
$ results = $ db
-> select ()
-> columns ([ ' column1 ' , ' column2 ' ])
-> from ( ' table_name ' )
-> where (Where:: equals ( ' column2 ' , 1 ))
-> fethAll (); $ select = $ db -> select ()
-> columns ([ ' column1 ' , ' column2 ' ])
-> column ( ' column3 ' )
-> from ( ' table_name ' )
-> where (Where:: equals ( ' column2 ' , 1 )) // See "Where Clauses" section above
-> groupBy ( ' column1 ' )
-> having (Where:: equals ( ' sum(column2) ' , 5 ))
-> orderBy ( ' column3 ' , ' ASC ' )
-> limit ( 10 )
-> offset ( 5 );
$ sql = $ select -> getSql ();
// $sql:
// SELECT
// `column1`,
// `column2`,
// `column3`
// FROM
// `table_name`
// WHERE
// `column2` = :column2___1
// GROUP BY
// `column1`
// HAVING
// `sum(column2)` = :sum_column2____1
// ORDER BY
// `column3` ASC
// LIMIT
// 10
// OFFSET
// 5;Ergebnisse abrufen:
Standardmäßig gibt die fetchAll() Methode ein Array von Objekten zurück (standardmäßig unter Verwendung von PDO::FETCH_OBJ ), wobei jedes Objekt eine Datenzeile darstellt. Sie können die Ergebnisse auch als Array assoziativer Arrays abrufen, indem Sie die Konstante PDO::FETCH_ASSOC als Argument an die Builder-Methode fetchMethod() übergeben, bevor Sie die Abfrage ausführen.
$ allResults = $ select -> fetchAll ();
$ firstResult = $ select -> fetchFirst ();
$ column1Values = $ select -> fetchColumn ( ' column1 ' );
$ column3DistinctValues = $ select -> fetchDistincts ( ' column3 ' );
// Output: object(FetchResult) {
// data => array(n) {
// [0]...
// [1]...
// [n-1]...
// },
// count => int(n)
// }Sie können die Anzahl der Ergebnisse auch abrufen mit:
$ countResults = $ select -> fetchCount ();
// Output: 5Pagination:
Der effiziente Umgang mit großen Datensätzen und die Bereitstellung einer benutzerfreundlichen Oberfläche für die Datennavigation sind für jede robuste Anwendung unerlässlich. Die Paginierungsfunktion in PHP-DbHandler geht auf diese Anforderungen elegant ein. Es vereinfacht die Aufteilung Ihrer Daten in überschaubare Blöcke oder „Seiten“ und erleichtert so die Arbeit mit großen Datensätzen, ohne das System oder den Benutzer zu überfordern.
Paginierung einrichten
Es gibt zwei Möglichkeiten, die Paginierung für Ihre Abfragen einzurichten:
Verwenden der Paginierungsmethode: Mit dieser Methode können Sie die Anzahl der Elemente pro Seite präzise definieren. Dies ist eine effiziente Möglichkeit, Ihre Abfrage für die Paginierung vorzubereiten.
$ select = $ db -> select ()
-> from ( ' table_name ' )
// ...
-> paginate (itemsPerPage: 10 );Manuelles Festlegen von Grenzwert und Offset: Für mehr Kontrolle können Sie den Grenzwert (Anzahl der Elemente pro Seite) und den Offset (Startpunkt im Datensatz) für Ihre Abfrage manuell festlegen.
$ select = $ db -> select ()
-> from ( ' table_name ' )
// ...
-> limit ( 10 )
-> offset ( 0 );Ergebnisse mit Paginierung abrufen
Sobald die Paginierung eingerichtet ist, können Sie Ergebnisse auf verschiedene Arten abrufen und so ganz einfach durch Ihren Datensatz navigieren:
fetchPage(?int $page) : Ruft eine aktuelle oder bestimmte Seite ab.fetchNextPage() : Ergebnisse für die nächste Seite abrufen.fetchPreviousPage() : Ergebnisse für die vorherige Seite abrufen.fetchFirstPage() : Ergebnisse für die erste Seite abrufen.fetchLastPage() : Ergebnisse für die letzte Seite abrufen. Jede dieser Methoden gibt ein FetchPaginatedResult -Objekt zurück, das die folgenden Eigenschaften enthält:
data : Ein Array der Datensätze auf der aktuellen Seite.count : Die Gesamtzahl der Datensätze im Datensatz.page : Die aktuelle Seitenzahl.perPage : Die Anzahl der Datensätze pro Seite.totalPages : Die Gesamtzahl der Seiten. // Example output structure of FetchPaginatedResult
object (FetchPaginatedResult) {
data => array (n) {
[ 0 ]. . .
[ 1 ]. . .
[n- 1 ]. . .
},
count => int(n),
page => int( 10 ),
perPage => int( 10 ),
totalPages => int( 23 )
}Dieses Paginierungssystem in PHP-DbHandler stellt sicher, dass Sie große Datensätze effektiv verwalten und navigieren können, wodurch die Gesamtleistung und das Benutzererlebnis Ihrer Anwendung verbessert werden.
Caching:
In den heutigen datengesteuerten Anwendungen sind Effizienz und Leistung von entscheidender Bedeutung. Um diese Aspekte bei Datenbankinteraktionen zu verbessern, enthält die Bibliothek eine Caching-Funktion in ihren Select -Abfragen. Diese Funktion steigert die Leistung, indem Abfrageergebnisse zwischengespeichert werden, wodurch die Datenbanklast reduziert und die Antwortzeiten für häufig ausgeführte Abfragen verbessert werden. Wichtig ist, dass es vollständig mit dem PSR-16-Standard (Simple Cache) kompatibel ist und so eine umfassende Kompatibilität und Flexibilität gewährleistet.
PSR-16-kompatibles Caching
Die Caching-Funktionalität innerhalb von Select-Abfragen akzeptiert jede Cache-Instanz, die PsrSimpleCacheCacheInterface implementiert. Diese Konformität mit den PSR-16-Standards bedeutet, dass Sie eine Vielzahl von Caching-Bibliotheken, die dieser Schnittstelle entsprechen, nahtlos integrieren können, was Ihnen die Flexibilität bietet, die Caching-Lösung auszuwählen, die den Anforderungen Ihrer Anwendung am besten entspricht.
Db -Klasse eine Instanz von PsrSimpleCacheCacheInterface bereitgestellt wird, können Sie diesen Schritt überspringen. Wenn Sie dies nicht getan haben, können Sie die setCache -Methode verwenden: $ select = $ db -> select ()-> setCache ( $ simpleCacheInstance );Hinweise:
- Wenn Sie beim Initialisieren der
Db-Klasse keine Cache-Instanz angegeben haben, müssen Sie diese für jedeSelectAbfrage festlegen, die Sie zwischenspeichern möchten.- Sie können diese Methode auch verwenden, wenn Sie eine bestimmte Cache-Instanz für eine
Select-Abfrage festlegen möchten. Dadurch können Sie je nach den Anforderungen Ihrer Anwendung unterschiedliche Caching-Lösungen für unterschiedliche Abfragen verwenden.
withCache -Methode. Sie können einen Standardrückgabewert für fehlende Cache-Einträge und eine TTL (Time To Live) für die zwischengespeicherten Daten angeben. $ select -> withCache (defaultValue, ttl);Hinweise:
- Das Argument
defaultValueist optional. Wenn nicht angegeben, gibt die BibliothekNULLfür fehlende Cache-Einträge zurück.- Das
ttl-Argument ist optional. Wenn nicht angegeben, verwendet die Bibliothek den von der PsrSimpleCache-Instanz festgelegten TTL-Wert.
$ allResults = $ select -> fetchAll ();
$ firstResult = $ select -> fetchFirst ();
$ column1Values = $ select -> fetchColumn ( ' column1 ' );
$ column3DistinctValues = $ select -> fetchDistincts ( ' column3 ' );Hauptvorteile
Die Insert Klasse in der PHP-DbHandler-Bibliothek optimiert den Prozess der Erstellung und Ausführung von Einfügeabfragen in einer Datenbank. Diese mit mehreren Merkmalen und Schnittstellen ausgestattete Klasse bietet einen ausgefeilten Ansatz für die Handhabung von Einfügevorgängen mit verschiedenen erweiterten Funktionen.
Abfragegenerierung
Insert -Klasse können Sie Spalten dynamisch Werte zum Einfügen zuweisen. Sie können einen einzelnen Wert oder mehrere Werte gleichzeitig hinzufügen: $ insert = $ db -> insert ()
-> into ( ' table_name ' )
-> value ( ' column1 ' , ' value1 ' )
-> values ([ ' column2 ' => ' value2 ' , ' column3 ' => ' value3 ' ]);Die Klasse prüft, ob die Spalte in der Tabelle vorhanden ist, bevor sie den Wert hinzufügt, und kümmert sich auch um die erforderliche PDO-Bindung.
$ rows = [
[ ' column1 ' => ' value1 ' , ' column2 ' => ' value2 ' ],
[ ' column1 ' => ' value3 ' , ' column2 ' => ' value4 ' ],
// ...
];
$ insert -> rows ( $ rows );Ausführung
$ success = $ insert -> execute ();Schecks
Bevor eine Einfügeoperation ausgeführt wird, prüft die Klasse automatisch Folgendes:
- Wenn sich die Datenbank im schreibgeschützten Modus befindet, werden unbeabsichtigte Schreibvorgänge verhindert.
- Bei Kollisionen bei nicht automatisch inkrementierenden Primärschlüsseln wird die Datenintegrität sichergestellt.
Die Insert Klasse ist eine umfassende Lösung für die Handhabung von Einfügevorgängen in einer Datenbank und bietet sowohl Benutzerfreundlichkeit als auch erweiterte Funktionen zur effizienten Verwaltung komplexer Einfügeaufgaben.
Die Update Klasse in der PHP-DbHandler-Bibliothek bietet eine ausgefeilte und flexible Möglichkeit, Aktualisierungsabfragen in einer Datenbank zu erstellen und auszuführen. Es ist so konzipiert, dass es sich nahtlos in die bestehende Datenbankstruktur integrieren lässt und gleichzeitig robuste Funktionen zur effektiven Verwaltung von Aktualisierungsvorgängen bietet.
Abfragegenerierung
$ update = $ db -> update ()
-> table ( ' table_name ' )
-> set ( ' column1 ' , ' newValue1 ' )
-> set ( ' column2 ' , ' newValue2 ' );
```
2. **Conditional Updates**: Incorporate conditions into your update queries using the `where` method. This allows for precise targeting of records to be updated.
``` php
$ update -> where (Where:: equals ( ' column3 ' , ' conditionValue ' ));Ausführung
$ success = $ update -> execute ();Prüfung des schreibgeschützten Modus : Vor der Ausführung prüft die Klasse, ob sich die Datenbank im schreibgeschützten Modus befindet, und verhindert so unbeabsichtigte Schreibvorgänge.
Die Update -Klasse stellt eine umfassende Lösung zum Erstellen und Ausführen von Aktualisierungsvorgängen in einer Datenbank dar. Seine Kombination aus Flexibilität, Robustheit und Benutzerfreundlichkeit macht es zur idealen Wahl für die Verwaltung von Datenbankaktualisierungen in PHP-Anwendungen.
Die Klasse Delete in der PHP-DbHandler-Bibliothek bietet einen ausgefeilten Ansatz zum Erstellen und Ausführen von Löschabfragen in Datenbanken. Diese Klasse stellt sicher, dass Löschvorgänge präzise und sicher ausgeführt werden, und integriert wichtige Prüfungen und Funktionen für eine optimale Abfragebearbeitung.
Abfragegenerierung
Die Klasse ermöglicht ein präzises Targeting der zu löschenden Datensätze mithilfe von bedingten Ausdrücken. Dies wird durch die where -Methode erreicht, die es ermöglicht, bestimmte Zeilen basierend auf den angegebenen Kriterien zum Löschen auszuwählen.
$ delete = $ db -> delete ()
-> from ( ' table_name ' )
-> where (Where:: equals ( ' column ' , ' value ' ));Obligatorische Where-Klausel : Um ein versehentliches Löschen aller Datensätze in einer Tabelle zu vermeiden, erfordert die Klasse die Angabe einer
WHEREKlausel. Dies dient als Schutz vor unbeabsichtigten Massenlöschungen.
Ausführung
$ success = $ delete -> execute ();Die Klasse führt vor der Ausführung des Löschvorgangs wichtige Prüfungen durch, einschließlich der Überprüfung der Existenz der Tabelle und der Sicherstellung, dass sich die Datenbank nicht im schreibgeschützten Modus befindet.
Die Klasse Delete ist darauf ausgelegt, Löschvorgänge mit einem hohen Maß an Kontrolle und Sicherheit abzuwickeln. Dadurch wird sichergestellt, dass Löschvorgänge unter Berücksichtigung der Struktur und Einschränkungen der Datenbank korrekt durchgeführt werden. Unabhängig davon, ob Sie einfache oder komplexe Löschaufgaben durchführen, bietet dieser Kurs die notwendigen Tools, um diese zuverlässig und sicher auszuführen.
Die StoredProcedure Klasse in der PHP-DbHandler-Bibliothek bietet einen optimierten und effizienten Ansatz zum Ausführen gespeicherter Prozeduren in Datenbanken. Diese Klasse bietet eine robuste Möglichkeit, mit gespeicherten Prozeduren zu interagieren und die Parameterverwaltung, Ausführung und das Abrufen von Ergebnissen problemlos zu handhaben.
Abfragegenerierung
Einrichten gespeicherter Prozeduraufrufe : Einfaches Einrichten von Aufrufen gespeicherter Prozeduren mit dynamischer Parameterverwaltung. Geben Sie den Prozedurnamen und die erforderlichen Parameter an.
$ procedure = $ db -> storedProcedure ()
-> call ( ' procedure_name ' )
-> with ( ' paramName ' , $ value )
// ...
-> with ( ' paramName2 ' , $ value );Ausführung
$ results = $ procedure -> execute ();Prüfungen des schreibgeschützten Modus : Vor der Ausführung überprüft die Klasse, ob sich die Datenbank im schreibgeschützten Modus befindet, um sicherzustellen, dass Schreibvorgänge nicht unbeabsichtigt ausgeführt werden.
Die StoredProcedure Klasse ist ein unverzichtbares Werkzeug für die Verarbeitung gespeicherter Prozeduraufrufe in PHP-Anwendungen. Es vereinfacht die Interaktion mit gespeicherten Prozeduren und macht den Prozess intuitiver und weniger fehleranfällig, insbesondere in Anwendungen, die stark auf komplexen Datenbankoperationen basieren.
Die Verwaltung von Datenbanktransaktionen ist ein entscheidender Aspekt zur Gewährleistung der Datenintegrität, insbesondere bei Anwendungen, die sich mit komplexer Datenmanipulation befassen. PHP-DbHandler vereinfacht diesen Prozess und bietet eine intuitive und unkomplizierte Möglichkeit, Transaktionen abzuwickeln.
Mit den bereitgestellten Transaktionsverwaltungsfunktionen können Sie Transaktionen einfach starten, festschreiben oder rückgängig machen und haben so die vollständige Kontrolle über Ihre Datenbankvorgänge. Dadurch wird sichergestellt, dass eine Reihe von Datenbankoperationen als eine einzige atomare Einheit behandelt werden können, die entweder vollständig oder gar nicht abgeschlossen wird, wodurch die Konsistenz und Zuverlässigkeit Ihrer Daten gewahrt bleibt.
$ db -> transaction -> begin ();
$ db -> transaction -> commit ();
$ db -> transaction -> rollback ();Diese Funktion ist besonders nützlich in Szenarien, in denen mehrere zusammengehörige Datenbankvorgänge zusammen ausgeführt werden müssen. Wenn ein Vorgang innerhalb der Transaktion fehlschlägt, kann die Rollback-Methode verwendet werden, um alle seit Beginn der Transaktion vorgenommenen Änderungen rückgängig zu machen und so Teilaktualisierungen zu verhindern, die zu Dateninkonsistenzen führen könnten. Wenn umgekehrt alle Vorgänge erfolgreich sind, speichert die Commit-Methode alle Änderungen in der Datenbank.
Mithilfe dieser Transaktionskontrollen stellt PHP-DbHandler sicher, dass die Datenverwaltung Ihrer Anwendung robust, konsistent und fehlerresistent ist. Unabhängig davon, ob Sie mit komplexen Dateneingaben, Aktualisierungen oder Batch-Prozessen zu tun haben, bieten diese Transaktionsfunktionen die notwendigen Tools, um Ihre Datenbankvorgänge effektiv zu verwalten.
Die Transaction Klasse führt außerdem eine leistungsstarke Funktion zur Verwaltung komplexer Transaktionsszenarien ein. Mit dieser Funktion können Sie Transaktions-Commits global steuern. Dies ist besonders nützlich, wenn Sie mehrere Methoden umfassen möchten, die Transaktionen in einem einzigen, übergreifenden Transaktionskontext verwenden.
Abwicklung von Transaktionen weltweit
Sie können mehrere Transaktionsvorgänge als Teil einer größeren Transaktion verwalten, indem Sie automatische Commits deaktivieren. Dies ist besonders nützlich in Szenarien, in denen mehrere Vorgänge, von denen jeder Transaktionen unabhängig voneinander verarbeiten kann, als Teil einer einzelnen atomaren Transaktion ausgeführt werden müssen.
// Begin a transaction
$ db -> transaction -> begin ();
// Disable automatic commits
$ db -> transaction -> setCommitsModeOff ();
// Execute other methods that use transactions
// $db->transaction->begin();
// ...
// $db->transaction->commit();
// Re-enable automatic commits
$ db -> transaction -> setCommitsModeOn ();
// Commit the transaction
$ db -> transaction -> commit ();Diese Funktion verbessert die Kontrolle über Transaktionsvorgänge und ermöglicht komplexere und zuverlässigere Datenmanipulationsszenarien. Dadurch wird sichergestellt, dass alle im Rahmen der globalen Transaktion vorgenommenen Änderungen entweder gemeinsam festgeschrieben oder rückgängig gemacht werden, wodurch die Datenintegrität und -konsistenz gewahrt bleibt.
Wir schätzen und freuen uns über Beiträge zum Projekt! Wenn Sie daran interessiert sind, einen Beitrag zu leisten, lesen Sie bitte unsere Datei CONTRIBUTING.md. Dort finden Sie detaillierte Informationen zu den ersten Schritten, Richtlinien zum Einreichen von Beiträgen und Tipps, wie Sie den Prozess so einfach und effektiv wie möglich gestalten können.
Unabhängig davon, ob Sie einen Fehler beheben, eine Funktion hinzufügen oder die Dokumentation verbessern, werden Ihre Beiträge sehr geschätzt und haben einen erheblichen Einfluss auf das Projekt.
Wenn Sie Fragen haben oder Ideen vor dem Codieren besprechen möchten, können Sie gerne ein Problem auf unserer GitHub-Problemseite zur Diskussion eröffnen.
Wir freuen uns über Ihre Bereitschaft zur Mitarbeit und freuen uns auf Ihre Einsendungen!
Diese Bibliothek ist unter der MIT-Lizenz lizenziert. Weitere Einzelheiten finden Sie in der LICENSE-Datei.
Für Unterstützung besuchen Sie bitte die Problemseite im GitHub-Repository: GitHub-Probleme
