Comelio GmbH
|
 |
Comelio-Blog > PHP > SQLite PHP und SQLite
PHP und SQLiteFolgende Funktionen sind für SQLite verfügbar:
Wie stelle ich eine Verbindung her?Die Klasse DB_sqlite liefert in ihrem Konstruktor eine passende Datenbankverbindung zur Datendatei von SQLite zurück, welche für alle weiteren Funktionen als Handle benutzt wird. Der Übergabeparameter für den Konstruktor ist die Datendatei, welche für eine Bearbeitung geöffnet werden soll. Der Destruktor der Klasse schließt die Verbindung, sobald das instanziierte Objekte nicht mehr gebraucht wird.
class DB_sqlite {
// Connection
var $DBFile;
var $Connection;
// Query
var $SQL; // SQL-command
// Constructor
function __construct($DB_File){
if (is_string($DB_File)){
$this->DBFile = $DB_File;
if (!$this->Connection = sqlite_open($this->DBFile, 0666,
$Error)){
return $Error;
}
else {
return $this->Connection;
}
}
else {
return false;
}
}
// Destructor
function __destruct(){
sqlite_close($this->Connection);
}
}
sqlite_output.php
Wie verwende ich DDL?Die Verwendung von SQLite hinsichtlich der DDL ist nicht so angenehm wie bei anderen Datenbanksystemen. Dies liegt natürlich daran, dass alle Speicherstrukturen und Daten in einer einzigen Datendatei verwaltet werden. Folgende Befehle aus SQL92 werden nicht unterstützt:
Die folgende Methode der Klasse DB_SQLite lässt sich für alle anderen SQL-Befehle einsetzen, die zulässig sind. Sie werden einfach mit den passenden Funktionen ausgeführt.
// Execute DDL
function Make_DDL (){
if (isset($this->SQL) && is_string($this->SQL)){
$Command = sqlite_query($this->Connection, $this->SQL);
if (!$Command){
return sqlite_last_error($this->Connection);
}
else{
return sqlite_last_insert_rowid($this->Connection);
}
}
else {
return false;
}
sqlite_output.php
Man verwendet dies wie folgt, um z.B. eine Tabelle anzulegen und mehrere Datensätze einzutragen. Beim ersten Programmdurchlauf werden die Datenbank und die Tabelle eingerichtet sowie die Daten eingetragen. Bei nachfolgenden Durchläufen der Testdatei müssen Sie diesen Bereich auskommentieren, da die Tabelle bereits existiert bzw. auch die Primärschlüssel schon benutzt werden.
// Test DDL-clauses
$DB["SQLite"] = new DB_sqlite("kursenrw.sqllite");
$DB["SQLite"] -> SQL = "CREATE TABLE termin (
T_Nr int(4) NOT NULL default '0',
K_Nr int(7) NOT NULL default '0',
T_Beginn varchar(20) NOT NULL default '',
T_Ende varchar(20) NOT NULL default '',
T_Ort varchar(20) NOT NULL default '',
PRIMARY KEY (T_Nr))";
$DB["SQLite"] -> Make_DDL();
$DB["SQLite"] -> SQL = "INSERT INTO termin
VALUES (1, 1015036, '18.02.2000',
'20.02.2000', 'Essen')";
$DB["SQLite"] -> Make_DDL();
$DB["SQLite"] -> SQL ="INSERT INTO termin
VALUES (2, 1020053, '18.02.2000',
'20.02.2000', 'Berlin')";
$DB["SQLite"] -> Make_DDL();
$DB["SQLite"] -> SQL ="INSERT INTO termin
VALUES (3, 1015036, '18.02.2000',
'20.02.2000', 'Essen')";
$DB["SQLite"] -> Make_DDL();
sqlite_output_test.php
Wie gebe ich eine Tabelle aus?Die Ausgabe einer Tabelle umfasst zwei grundsätzliche Bereiche, in die die umfangreiche Version einer Datenverarbeitung aufgeteilt werden kann:
// Make Table
function Make_Table($THTitle, $Line){
// Get data
$Result = sqlite_query($this->Connection, $this->SQL);
if (is_resource($Result)){
// Output table
$Text = "<table border=0>\n";
// Output heading
if ($THTitle !== "")
{
$i = 0;
$Row = sqlite_num_fields($Result);
$Text .= "<tr>\n";
while ($i < $Row){
$FieldName = sqlite_field_name($Result, $i);
$Text .= "\t<th>$FieldName</th>\n";
$i++;
}
$Text .= "</tr>\n";
}
// Output rows
while ($Row = sqlite_fetch_array($Result, SQLITE_NUM)){
$Text .= "<tr>\n";
// Output fields
foreach ($Row as $Field)
if ($Field !=""){
$Text .= "\t<td>".$Field."</td>\n";
}
else {
$Text .= "\t<td> </td>\n";
}
$Text .= "</tr>\n";
// Output line
if ($Line){
$Row = sqlite_num_fields($Result);
$Text .= "<tr>\n"
."\t<td colspan="
.$Row
. ">"
."<hr noshade></td>\n"
."</tr>\n";
}
}
// End table
$Text .= "</table>\n";
// Free result
//sqlite_free_result($Result);
return $Text;
}
else {
return false;
}
}
sqlite_output.php
Man verwendet dies wie folgt, um eine einfache Abfrage auszugeben. Dabei ist wichtig, dass die Spaltennamen durch geeignete Aliasnamen ersetzt werden, welche sich auch für eine Aufbereitung in HTML eignen.
// Print table
$DB["SQLite"] -> SQL = "SELECT T_Nr AS Nr,
T_Beginn AS Beginn,
T_Ende AS Ende,
T_Ort AS Ort
FROM termin";
echo $DB["SQLite"] -> Make_Table("Kurse", true);
sqlite_output_test.php
Wie gebe ich eine Liste aus?Ähnlich wie bei der Ausgabe einer Tabelle, so stellt auch die Listenausgabe eine häufig wiederkehrende Aufgabe dar. Anstatt nun jede Liste individuell zu programmieren und auszugeben, sollte man eine Funktion oder eine Methode aus einer entsprechenden Klasse mit anderen Ausgabemethoden verwenden. Dabei ist lediglich darauf zu achten, dass nur eine einzige Spalte von der Abfrage zurückgegeben wird und die Abfrage eine perfekte Abfrage ist. Dies sind Abfragen, welche sich gut in solchen allgemeinen Methoden einsetzen lassen, weil sie z.B. HTML-Formatierungen wie Links zu anderen Seiten oder Datumsformatierungen über SQL-Funktionen bereits in der Abfrage besitzen, und daher die gefundene und bereits aufbereitete Datenmenge nur noch in HTML ausgegeben werden muss. Dies erledigt die nun folgende Methodengruppe, wobei einige geschützte Methoden vorhanden sind, welche nur für den Aufruf innerhalb der DB_SQLite-Klasse notwendig sind. Als Parameter lässt sich ein Titel angeben, welcher automatisch oberhalb der Liste in einem <h1>-Tag ausgegeben wird, und eine Linie, welche mit einer übergebenen Breite unterhalb der Liste mit Hilfe eines <hr>-Tags ausgegeben wird.
// Print out a UL-List
private function Print_List_Start($Title){
// Prepare output list
if ($Title !== ""){
$Text = "<h1>"
.$Title
."</h1>\n";
return $Text;
}
else {
return false;
}
}
private function Print_List_End($Line){
// Finish output list
if (!empty($Line)){
$Text = "<hr align=\"left\" noshade width=\""
.$Line
."\"><br>\n";
return $Text;
}
else{
return false;
}
}
private function Print_List_Items(){
// Get data
$Result = sqlite_query($this->Connection, $this->SQL);
if (is_resource($Result)){
// Prepare output data
$Text = "";
// Process database data
while ($Row = sqlite_fetch_array($Result, SQLITE_NUM)){
foreach ($Row as $Field){
if ($Field !=""){
$Text .= "\t<li>".$Field."</li>\n";
}
}
// Return html Text
return $Text;
}
}
else {
return false;
}
}
// Prints out a UL-list
function Make_UL_List($Type, $Title, $Line){
if (is_string($this->SQL)
&& (is_string($Type)
&& ($Type == "disc" || $Type == "circle" ||
$Type == "square"))
&& is_string($Title)
&& is_int($Line)){
// Prepare output data
$Text = "";
// Prepare output list (1)
$Text .= DB_sqlite::Print_List_Start($Title);
// Prepare output list (2)
$Text .= "<ul type=\""
.$Type
."\">\n";
// Output list (3)
$Text .= DB_sqlite::Print_List_Items();
// Finish output list (2)
$Text .= "</ul>\n";
// Finish output list (1)
$Text .= DB_sqlite::Print_List_End($Line);
// Return html data
return $Text;
}
else {
return false;
}
}
// Prints out a OL-list
function Make_OL_List($Type, $Title, $Line){
if (is_string($this->SQL)
&& (is_string($Type)
&& ($Type == "1" || $Type == "a" ||
$Type == "A" || $Type == "i" ||
$Type == "I"))
&& is_string($Title)
&& is_int($Line)){
// Prepare output data
$Text = "";
// Prepare output list (1)
$Text .= DB_sqlite::Print_List_Start($Title);
// Prepare output list (2)
$Text .= "<ol type=\""
.$Type
."\">\n";
// Output list (3)
$Text .= DB_sqlite::Print_List_Items();
// Finish output list (2)
$Text .= "</ol>\n";
// Finish output list (1)
$Text .= DB_sqlite::Print_List_End($Line);
// Return html data
return $Text;
}
else {
return false;
}
}
sqlite_output.php
Die Abfrage ist überaus einfach und liefert nur eine einzige Spalte zurück, wie es für die Methode auch notwendig ist. Einmal erzeugt man mit Hilfe der Make_UL_List()-Methode eine nicht-nummerierte Liste, und ein andermal erzeugt man über Make_OL_List() eine nummerierte Liste mit entsprechenden Vorgaben für das type-Attribut des Listenelements von HTML.
// Use and test list-function
$DB["SQLite"] -> SQL = "SELECT DISTINCT T_Ort
FROM termin";
echo $DB["SQLite"] -> Make_UL_List("square",
"Bereichsübersicht",
350);
echo $DB["SQLite"] -> Make_OL_List("a",
"Bereichsübersicht",
350);
sqlite_output_test.php
Wie verwende ich benutzerdefinierte Spaltenfunktionen?Folgendes Beispiel erzeugt eine bedingte Funktion, die als benutzerdefinierte Spaltenfunktion in SQLite zur Verfügung steht, nachdem sie über die sqlite_create_function($Connection, 'Address', 'Find_Address', 1);-Funktion angemeldet wurde. Dabei benötigt man neben dem Verbindungshandle eine Angabe, wie die Funktion in SQL verwendet werden soll, wie sie tatsächlich heißt und wie viele Parameter erwartet werden. Sie lässt sich hiernach als Spaltenfunktionen nutzen, die für jede Reihe aktiv wird.
// Test connection
if (!$Connection = sqlite_open("kursenrw.sqllite", 0666, $Error)){
die ($Error);
}
else {
// Prepare user-defined-function
function Find_Address($City){
switch ($City) {
case "Berlin":
return "Berlin - Mitte";
break;
case "Essen":
return "Essen - City/Hbf";
break;
default:
return $City;
}
}
// Register function
sqlite_create_function($Connection, 'Address',
'Find_Address', 1);
// Perform query
$Rows = sqlite_array_query($Connection,
"SELECT T_Beginn,
T_Ende,
Address(T_Ort)
FROM termin",
SQLITE_ASSOC);
// Analyze result
echo "<pre>";
print_r($Rows);
echo "</pre>";
sqlite_rowfunction.php
Man erhält ein Array, in dem man ersehen kann, wie die Funktion arbeitet. Sie ersetzt für jeden Datensatz in der Spalte T_Ort den vorhandenen Wert durch den Ersetzungswert.
Array
(
[0] => Array
(
[T_Beginn] => 18.02.2000
[T_Ende] => 20.02.2000
[Address(T_Ort)] => Essen - City/Hbf
)
[1] => Array
(
[T_Beginn] => 18.02.2000
[T_Ende] => 20.02.2000
[Address(T_Ort)] => Berlin - Mitte
)
…
)
Ausgabe
Wie verwende ich benutzerdefinierte Aggregatfunktionen?Neben den benutzerdefinierten Spaltenfunktionen lassen sich auch nicht-reihenbezogene Aggregatfunktionen verwenden. Dazu benötigt man mindestens zwei Funktionen, von denen die eine für die Verarbeitung der Reihenwerte verwendet wird, und von denen die zweite für die Ermittlung des Gesamtergebnisses zum Zuge kommt. Dies wird mit Hilfe der Funktion sqlite_create_aggregate($Connection, 'MaxCity', Max_Count_City_Row', 'Max_Count_City_Agg'); gelöst, die zum einen eine reihenbezogene und zum anderen eine für alle Daten verfügbare Funktion besitzt.
// Inclusion of class
include("sqlite_output.php");
// Test DDL-clauses
$DB["SQLite"] = new DB_sqlite("kursenrw.sqllite");
$DB["SQLite"] -> SQL = "CREATE TABLE termin (
T_Nr int(4) NOT NULL default '0',
K_Nr int(7) NOT NULL default '0',
T_Beginn date NOT NULL default '',
T_Ende date NOT NULL default '',
T_Ort varchar(20) NOT NULL default '',
PRIMARY KEY (T_Nr))";
$DB["SQLite"] -> Make_DDL();
$DB["SQLite"] -> SQL = "INSERT INTO termin
VALUES (1, 1015036, '2000-02-18',
'2000-02-20', 'Essen')";
$DB["SQLite"] -> Make_DDL();
$DB["SQLite"] -> SQL ="INSERT INTO termin
VALUES (2, 1020053, '2001-02-18',
'2001-02-20', 'Berlin')";
$DB["SQLite"] -> Make_DDL();
$DB["SQLite"] -> SQL ="INSERT INTO termin
VALUES (3, 1015036, '2002-02-18',
'2002-02-20', 'Essen')";
$DB["SQLite"] -> Make_DDL();
// Test connection
if (!$Connection = sqlite_open("kursenrw.sqllite",
0666, $Error)){
die ($Error);
}
else {
// Prepare user-defined-function
function Max_Count_City_Row(&$Context, $City){
if (!$Connection = sqlite_open("kursenrw.sqllite",
0666, $Error)){
$Context = 0;
}
else {
$Rows = sqlite_array_query($Connection,
"SELECT COUNT(*) AS Zahl
FROM termin
WHERE T_Ort='"
.$City
."'",
SQLITE_ASSOC);
if($Rows[0]["Zahl"] > $Context){
$Context = $Rows[0]["Zahl"];
}
}
}
function Max_Count_City_Agg(&$Context){
return $Context;
}
// Register functions
sqlite_create_aggregate($Connection,
'MaxCity',
'Max_Count_City_Row',
'Max_Count_City_Agg');
// Perform query
$Rows = sqlite_array_query($Connection,
"SELECT MaxCity(T_Ort) AS Zahl
FROM termin",
SQLITE_ASSOC);
// Analyze result
echo "<pre>";
print_r($Rows);
echo "</pre>";
}
sqlite_aggregatefunction.php
Man erhält als Ergebnis die Information, wie hoch die häufigste Stadtnennung ist.
Array
(
[0] => Array
(
[Zahl] => 2
)
)
Ausgabe
|
||||||||||||
PHP5 bietet die Möglichkeit, ein einfaches dateibasiertes Datenbanksystem zu verwenden. Die Verwendung von SQLite hinsichtlich der DDL ist nicht so angenehm wie bei anderen Datenbanksystemen. Dies liegt natürlich daran, dass alle Speicherstrukturen und Daten in einer einzigen Datendatei verwaltet werden. Folgende Befehle aus SQL92 werden u.a. nicht unterstützt: