Comelio GmbH
Rellinghauser Straße 10
D-45128 Essen
Deutschland
Fon: 0201-437517-0
Fax: 0201-437517-10
info@comelio.com
Comelio GmbH
Goethestraße 34
D-13086 Berlin
Deutschland
info@comelio.com
Comelio GmbH (Ecos)
Glockengießerwall 17
D-20095 Hamburg
Deutschland
info@comelio.com
Comelio GmbH (Ecos)
Mainzer Landstraße 27-31
D-60329 Frankfurt
Deutschland
info@comelio.com
Comelio GmbH (Ecos)
Stiglmaierplatz/Dachauer Str. 37
D-80335 München
Deutschland
info@comelio.com
Comelio GmbH (Ecos)
Liebknechtstr. 33
D-70565 Stuttgart
Deutschland
info@comelio.com
Comelio GmbH
Nevinghoff 16
D-48147 Münster
Deutschland
Comelio GmbH
Friedrich - List - Platz 1
D-04103 Leipzig
Deutschland
Comelio GmbH
St. Johanner Strasse 41-43
D-66111 Saarbrücken
Deutschland
Comelio GmbH
Kaiser-Wilhem-Ring 27–29
D-50672 Köln
Deutschland
Comelio GmbH
Münsterstraße 248
D-40470 Düsseldorf
Deutschland
Comelio GmbH
Fürther Strasse
D-90429 Nürnberg
Deutschland
Comelio GmbH
Bremen
Deutschland
Comelio-Blog > PHP > SQLite
PHP und SQLite
|
Dieser Artikel zeigt die Verwendung von SQLite als kleine Alternative bei geringem und einfach strukturiertem Datenbestand. |
 | Kontakt |
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:PHP und SQLite
Folgende Funktionen sind für SQLite verfügbar:
- sqlite_array_query Liefert das gesamte Abfrageergebnis in Array-Form zurück und sollte bei wenigen Datensätzen angewandt werden. Allgemeine Syntax: array sqlite_array_query ( resource db, string query [, int result_type [, bool decode_binary]])
- sqlite_busy_timeout Ermöglicht die Angabe der Wartezeit zur Freigabe (Voreinstellung 60 Sekunden). Allgemeine Syntax: void sqlite_busy_timeout ( resource Datenbank, int Millisekunden)
- sqlite_changes Liefert die Anzahl der modifizierten Zeilen. Allgemeine Syntax: int sqlite_changes ( resource db)
- sqlite_close Beendet die Datenbankverbindung. Allgemeine Syntax: void sqlite_close ( resource Datenbank)
- sqlite_column Liefert eine Spalte aus dem Abfrageergebnis. Allgemeine Syntax: mixed sqlite_column ( resource Ergebnis, mixed Index_oder_Name [, bool decode_binary])
- sqlite_create_aggregate Bindet eine Aggregat-Benutzerfunktion in PHP-Syntax an eine SQL-Abfrage. Allgemeine Syntax: bool sqlite_create_aggregate ( resource dbhandle, string function_name, mixed step_func, mixed finalize_func [, int num_args])
- sqlite_create_function Bindet eine reihenbezogene (keine aggregierende) Benutzerfunktion in PHP-Syntax an eine SQL-Abfrage. Allgemeine Syntax: bool sqlite_create_function ( resource db, string SQL-Funktionsname, mixed callback [, int num_args])
- sqlite_current Liefert die aktuelle Zeile als Array aus der Ergebnismenge. Allgemeine Syntax: array sqlite_current ( resource Ergebnis [, int Ergebnis_Typ [, bool decode_binary]])
- sqlite_error_string Ermittelt den Fehlertext. Allgemeine Syntax: string sqlite_error_string ( int error_code)
- sqlite_escape_string Übermittelt ein Fluchtzeichen an den Parser. Allgemeine Syntax: string sqlite_escape_string ( string item)
- sqlite_fetch_array Liefert eine Zeile aus einem DB-Ergebnis als Array. Der Standard-Wert und damit die Standardformatierung ist SQLITE_BOTH. Für die Indizierung werden sowohl Nummern als auch die Spaltennamen verwendet. SQLITE_ASSOC beschränkt dies auf die Spaltennamen, SQLITE_NUM auf die Spaltennummern. Allgemeine Syntax: array sqlite_fetch_array ( resource Ergebnis [, int Ergebnis_Typ [, bool decode_binary]])
- sqlite_fetch_single Liefert die erste Reihe als Array. Allgemeine Syntax: string sqlite_fetch_single ( resource result [, int result_type [, bool decode_binary]])
- sqlite_fetch_string Ermittelt eine Zeile der Ergebnismenge als Array. Allgemeine Syntax: string sqlite_fetch_string ( resource Ergebnis [, int Ergebnis_Typ [, bool decode_binary]])
- sqlite_field_name Liefert den Feldnamen. Allgemeine Syntax: string sqlite_field_name ( resource Ergebnis, int Feld_Index)
- sqlite_has_more Liefert TRUE, wenn noch mehr Zeilen in der Ergebnismenge sind. Allgemeine Syntax: bool sqlite_has_more ( resource Ergebnis)
- sqlite_last_error Liefert die letzte Fehlernummer. Allgemeine Syntax: int sqlite_last_error ( resource db)
- sqlite_last_insert_rowid Liefert die Nummer der zuletzt eingefügten Zeile. Allgemeine Syntax: int sqlite_last_insert_rowid ( resource db)
- sqlite_libencoding Liefert die Kodierung der genutzten SQLite-Bibliothek. Allgemeine Syntax: string sqlite_libencoding ( void )
- sqlite_libversion Liefert die Version der genutzten SQLite-Bibliothek. Allgemeine Syntax: string sqlite_libversion ( void )
- sqlite_next Bewegt den Datensatzzeiger zur nächsten Zeile. Allgemeine Syntax: bool sqlite_next ( resource Ergebnis)
- sqlite_num_fields Zählt die Feldanzahl. Allgemeine Syntax: int sqlite_num_fields ( resource Ergebnis)
- sqlite_num_rows Zählt die Zeilen eines Abfrageergebnisses. Allgemeine Syntax: int sqlite_num_rows ( resource Ergebnis)
- sqlite_open -- Öffnet eine SQLite Datenbank. Wenn die Datenbank nicht existiert, wird sie erzeugt. Allgemeine Syntax: resource sqlite_open ( string Datei [, int mode [, string &Fehler]])
- sqlite_popen Öffnet eine persistente DB-Verbindung und/oder legt eine entsprechende DB an. Standardwert für Modus: 06666. Allgemeine Syntax: resource sqlite_popen ( string Datei [, int mode [, string &Fehler]])
- sqlite_query Schickt SQL-Anweisungen zur Datenbank. Allgemeine Syntax: resource sqlite_query ( resource db, string Abfrage)
- sqlite_rewind Setzt den Datensatzzeiger auf die erste Zeile. Allgemeine Syntax: bool sqlite_rewind ( resource Ergebnis)
- sqlite_seek Setzt den Datensatzzeiger auf einen bestimmten Datensatz. Allgemeine Syntax: bool sqlite_seek( resource Ergebnis, int Zeilennummer)
- sqlite_udf_decode_binary Dekodiert Binärdaten einer benutzerdefinierten Funktion. Allgemeine Syntax: string sqlite_udf_decode_binary ( string data)
- sqlite_udf_encode_binary Kodiert Binärdaten einer benutzerdefinierten Funktion. Allgemeine Syntax: string sqlite_udf_encode_binary ( string data)
- sqlite_unbuffered_query Führt eine Abfrage durch und behält die Ergebnisse im Zwischenspeicher. Allgemeine Syntax: resource sqlite_unbuffered_query ( resource db, string Abfrage)
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:
- CHECK Einschränkungen: Allgemeine CHECK-Einschränkungen werden ohne Fehler geparst, aber nicht kontrolliert. NOT NULL und UNIQUE werden dagegen auch berücksichtigt.
- Variablen in Unterabfragen können nur statisch sein und sich nicht auf Reihenergebnisse beziehen.
- FOREIGN KEY Einschränkungen: Fremdschlüsselbeziehungen werden geparst, aber nicht berücksichtigt.
- Volle Trigger-Unterstützung: Es besteht die Möglichkeit, Trigger zu verwenden, doch ist der Gebrauch eingeschränkt. Die Syntaxstrukturen FOR EACH STATEMENT, INSTEAD OF für Tabellen und rekursive Trigger zählen dazu.
- ALTER TABLE: Eine Tabellenänderung kann nur über ein Löschen und Neuanlegen der Tabelle erfolgen. Die Daten der alten Tabelle müssen zwischengespeichert werden.
- Verschachtelte Transaktionen: Zurzeit werden nur einfache Transaktionen unterstützt.
- COUNT(DISTINCT X) –Funktion: Diese Funktion lässt sich nur durch eine abgeleitete Tabelle in Form von SELECT count(x) FROM (SELECT DISTINCT x FROM tbl) umsetzen.
- RIGHT und FULL OUTER JOIN: Während LEFT OUTER JOIN implementiert ist, fehlen RIGHT OUTER JOIN oder FULL OUTER JOIN.
- Schreiben in VIEWs: Von Sichten in SQLite kann nur gelesen werden. DML-Befehle wie DELETE, INSERT, oder UPDATE sind unzulässig. Es lässt sich allerdings ein INSTEAD OF-Trigger für Sichten erstellen.
- GRANT und REVOKE: Die Benutzerrechte der Datenbank sind auf die Benutzerrechte der Textdatei beschränkt.
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:
- In einem ersten – allerdings optionalen Schritt – lässt sich das zurückgelieferte Ergebnis untersuchen. Dies umfasst solche Punkte wie die Anzahl der gefundenen Reihen sowie die Anzahl der gefundenen Spalten. Dies ist zwar typischerweise bekannt, da dies die Anzahl der Spalten in der SQL-Abfrage darstellt, darf aber in diesem Fall nicht als bekannt vorausgesetzt werden, weil die folgende Methode für jede beliebige SQL-Abfrage eine HTML-Tabelle liefern soll und nicht nur für eine, von der man die Anzahl der Spalten bereits kennt.
- In einem zweiten Schritt, der mindestens für ein Programm erfüllt sein muss, gibt man die Datenreihen aus. Auch hier wird in diesem Rezept darauf geachtet, dass gar nicht bekannt ist, wie viel Spalten oder wie viele Reihen überhaupt zurückgeliefert werden können, sodass eine möglichst allgemeine Datenverarbeitung benutzt wird. Neben der nicht abschaltbaren Eigenschaft, eine HTML-Tabelle auszugeben, besitzt die Methode noch zwei weitere Eigenschaften, nämlich die Ausgabe einer in <th>-Elementen formatierten Kopfzeile und die Ausgabe einer einfachen Linie. Sollen weitere Eigenschaften der Tabelle vorhanden sein, muss man sich diese Methode an seine eigenen Bedürfnisse anpassen. Es handelt sich meistens um die üblichen und sehr zahlreichen Attributwerte, die in HTML für die Tabellenformatierung vorhanden sind wie Zellraum, Zellauffüllung, Breite und Farben.
// 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
- Comelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg Göttingen Bonn Wolfsburg Lübeck Bochum Kiel Koblenz Andernach Bremen Frankfurt Ludwigshafen Ingolstadt Leipzig Berlin München Koblenz Kassel Mannheim Aachen Ol Magdeburg Hamburg Köln Hannover FreiburgComelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg Göttingen Bonn Wolfsburg Lübeck Bochum Kiel Koblenz Andernach Bremen Frankfurt Ludwigshafen Ingolstadt Leipzig Berlin München Koblenz Kassel Mannheim Aachen Ol Magdeburg Hamburg Köln Hannover FreiburgComelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg Göttingen Bonn Wolfsburg Lübeck Bochum Kiel Koblenz Andernach Bremen Frankfurt Ludwigshafen Ingolstadt Leipzig Berlin München Koblenz Kassel Mannheim Aachen Ol Magdeburg Hamburg Köln Hannover FreiburgComelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg Göttingen Bonn Wolfsburg Lübeck Bochum Kiel Koblenz Andernach Bremen Frankfurt Ludwigshafen Ingolstadt Leipzig Berlin München Koblenz Kassel Mannheim Aachen Ol Magdeburg Hamburg Köln Hannover FreiburgComelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg Göttingen Bonn Wolfsburg Lübeck Bochum Kiel Koblenz Andernach Bremen Frankfurt Ludwigshafen Ingolstadt Leipzig Berlin München Koblenz Kassel Mannheim Aachen Ol Magdeburg Hamburg Köln Hannover FreiburgComelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg Göttingen Bonn Wolfsburg Lübeck Bochum Kiel Koblenz Andernach Bremen Frankfurt Ludwigshafen Ingolstadt Leipzig Berlin München Koblenz Kassel Mannheim Aachen Ol Magdeburg Hamburg Köln Hannover FreiburgComelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg Göttingen Bonn Wolfsburg Lübeck Bochum Kiel Koblenz Andernach Bremen Frankfurt Ludwigshafen Ingolstadt Leipzig Berlin München Koblenz Kassel Mannheim Aachen Ol Magdeburg Hamburg Köln Hannover FreiburgComelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg Göttingen Bonn Wolfsburg Lübeck Bochum Kiel Koblenz Andernach Bremen Frankfurt Ludwigshafen Ingolstadt Leipzig Berlin München Koblenz Kassel Mannheim Aachen Ol Magdeburg Hamburg Köln Hannover FreiburgComelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg Göttingen Bonn Wolfsburg Lübeck Bochum Kiel Koblenz Andernach Bremen Frankfurt Ludwigshafen Ingolstadt Leipzig Berlin München Koblenz Kassel Mannheim Aachen Ol Magdeburg Hamburg Köln Hannover Freiburg
- Comelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg
- Comelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg
- Comelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg
- Comelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg
- Comelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg
- Comelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg
- Comelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg
- Comelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg
- Comelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg
- Comelio GmbH PHP: Datenbank mit SQLite SQLJ Tutorial XML Handbuch MySQL LDAP Anleitung PHP SQL Heidelberg Zwickau Rügen Stuttgart Erlangen Würzuburg