Römische Zahlen

Das römische Zahlensystem wurde in der Antike von den Römern erfunden. Noch heute findet man immer wieder diese Zeichen. Wenn man zum Beispiel an Uhren denkt. Doch konnte sich dieses System auf langer Sicht nicht durchsetzen und wurde im Mittelalter von der arabischen Schreibweise der Zahlen verdrängt, weil mit diesen Zahlen besser gerechnet werden konnte. Dennoch kommt das Thema der römischen Zahlen noch immer im Unterricht vor und deshalb hier die Informationen dazu.
Zunächst sollten wir uns die römischen Ziffern und dessen Wertigkeiten anschauen.

Zeichen I II III IV V VI VII VIII IX X
Wert 1 2 3 4 5 6 7 8 9 10

Da die römischen Zahlen auf einer additiven Schreibweise beruhen, wird bei der Erhöhung des Wertes entweder eine Zahl drauf addiert oder subtrahiert.
Zum Beispiel:

1 = I
2 = I+I = II
5 = V
6 = 5 + 1 = V + I = VI
9 = 10 – 1 = X – I = IX
Subtraktion X Addition

In den Anfängen und auch noch später arbeitete man mit ursprünglich mit vier aufeinanderfolgenden gleichen Zeichen.

4 = IIII
400 = CCCC

Zeichen XI XII XIII XIV XV XVI XVII XVIII XIX XX
Wert 11 12 13 14 15 16 17 18 19 20
Zeichen XXX XL L XC C CL D M
Wert 30 40 50 90 100 150 500 1000

Zuletzt schauen wir uns mal die kniffligen Fälle an. Nehmen wir einfach mal die 49.
Wahrscheinlich würde der ein oder andere die Zahl so umwandeln:

FALSCH 49 = XIXL
RICHTIG 49 = XLIX

Erklärung, zuerst ziehen wir 10 ab, und haben dann 40, auf diese 40 müssen wir 9 addieren und das machen wir wo? Auf der rechten Seite. Eine Zahl machen wir noch.

FALSCH 99 = IC
RICHTIG 99 = XCIX

MySQLi Prepared Statements – SELECT Abfragen

Nachdem wir uns mit den Grundlagen von MySQLi beschäftigt haben, möchte ich hier ein wenig auf die Vorteile von MySQLi eingehen. Das Zauberwort heißt Prepared Statements.

Was ist ein Prepared Statement?

Darunter versteht man eine Anweisung für ein Datenbanksystem, die vorkompiliert wird. Das heißt, dem Datenbanksystem wird eine Anweisung übergeben, die nicht mit konkreten Daten gefüllt ist, sondern Platzhalter verwendet werden. Der Vorteil überwiegt in einer erhöhten Geschwindigkeit, wenn die eine Anfrage geparst wird und nur noch mit verschiedenen Parametern ausgeführt werden muss.
Bei komplexen Abfragen sollte eher darauf verzichtet werden, weil es das System sogar langsamer machen kann.
Ein weiterer Vorteil ist, das alle Eingaben nicht maskiert werden müssen, Stichwort SQL-Injections, denn das wird von dem System übernommen. Wie das alles funktioniert, werden wir uns nun ansehen.


Ich persönlich bevorzuge die objektorientierte Variante, doch der Vollständigkeit halber, werde ich auch die prozedurale Variante zeigen. Fangen wir gleich damit an. Die Verbindung zu einer Datenbank werde ich jetzt nicht noch einmal beschreiben, das kann man sich hier ansehen.

Prozedurale Prepared Statements

$vorname = "Sarah";
$stmt = mysqli_stmt_init($mysqli);
if(mysqli_stmt_prepare($stmt, 'SELECT vorname, nachname FROM benutzer WHERE vorname = ?'))
 {
  mysqli_stmt_bind_param($stmt, "s", $vorname);
  mysqli_stmt_execute($stmt);
  mysqli_stmt_bind_result($stmt, $vorname, $nachname);


  while(mysqli_stmt_fetch($stmt))
  {
   echo $vorname.' '.$nachname;
  }
 }
mysqli_close($mysqli);
//Ausgabe: Sarah Schmidt

Auf den ersten Blick kann man erkennen, dass die Funktionsbezeichnungen ziemlich lang sind. Das ist ein weiterer Grund, warum man objektorientiert arbeiten sollte. Mit mysqli_stmt_init initialisieren wir ein Statement, das ein Objekt zurück gibt, damit wir es in mysqli_stmt_prepare benutzen können.
In unserer SQL-Anweisung erkennt man direkt etwas ungewöhnliches. Denn anstatt einen Parameter anzugeben, wird ein Platzhalter verwendet, den das Fragezeichen darstellt. An diesen Platzhalter wird mit mysqli_stmt_bind_param ein Wert gebunden, den wir als String deklarieren. Dafür steht das s. Von diesen Typenbezeichnern gibt es noch mehr, dazu aber weiter unten.
In der nächsten Zeile wird unser Statement mit mysqli_stmt_execute() ausgeführt. Damit wir mit der Ausgabe weiter arbeiten können, müssen wir die Ausgabewerte an eine Variable binden, das mit mysqli_stmt_bind_result funktioniert.
Das lassen wir uns dann durch eine while-Schleife ausgeben.
Dann schließen wir die Datenbankverbindung wieder.

Objektorientierte Prepared Statements

$vorname = "Sarah";
$stmt = $mysqli->prepare('SELECT vorname, nachname FROM benutzer WHERE vorname = ?');
$stmt->bind_param("s", $vorname);
$stmt->execute();
$stmt->bind_result($vorname, $nachname);


while($stmt->fetch())
 {
  echo $vorname.' '.$nachname;
 }
$mysqli->close();
//Ausgabe: Sarah Schmidt

Es ist viel weniger Schreibaufwand von Nöten und wesentlich übersichtlicher. Jetzt zeige ich noch die verschiedenen Typen, die man bei einem Prepared Statement verwenden kann.

// String ist eine Zeichenkette
s = String
// Integer sind ganze Zahlen
i = Integer
// Double sind Fließkommazahlen
d = double
//(Binary Large Object) Binäre Datei
b = Blob

Jetzt erkennt man die Mächtigkeit von Prepared Statements. Ein Angreifer kann Slashes und Quots setzten wie er möchte und trotzdem wird alles als gewöhnlicher String oder als entsprechender Typ behandelt.

Einfache MySQLi Datenbankabfrage

MySQLi soll eine verbesserte Version von MySQL darstellen, dafür auch das i am Ende, das für improved steht und verbessert bedeutet.
Laut dem Hersteller hat sich die Geschwindigkeit erhöht und mit der Hilfe von Prepared Statements ist die Sicherheit im Bezug auf SQL Injections gestiegen. Weiter ist ein wichtiger Aspekt, dass man MySQLi nicht nur prozedural verwenden kann, sondern darauf ausgelegt ist sie objektorientiert zu verweden. MySQLi bietet auch die Möglichkeit von Multiquerys.

In diesem Artikel schauen wir uns eine Datenbankverbindung mit einer einfachen Abfrage an. Dabei nehmen wir die Besonderheiten genau unter die Lupe.

Was hat sich geändert?

Wer bereits mit den Funktionen von MySQL vertraut ist, wird sich schnell in die prozedurale Schreibweise hineinfinden.

MySQL MySQLi MySQLi OOP
mysql_connect() mysqli_connect() new mysqli()
mysql_query() mysqli_query() $stmt = $mysqli->query()
mysql_affected_rows() mysqli_affected_rows() $stmt->affected_rows
mysql_select_db() mysqli_select_db() Kann als Parameter bei der
Datenbankverbindung angegeben
werden.

Wie man sieht, hat sich in der prozeduralen Schreibweise bis auf das i nicht geändert. Bis auf den Funktionsumfang vielleicht. Bei der objektorientierten Schreibweise, wird es schon etwas anspruchsvoller für Umsteiger. Sollte man aber bereits Erfahrungen in der OOP haben, wird es keine große Hürde sein. Aber auch für Neulinge erschließt sich recht schnell, wie man damit umzugehen hat.
Zunächst schauen wir uns die das Ganze prozedural an und dann objektorientiert.

Prozedural Datenbankverbindung

$mysqli = mysqli_connect("localhost", "Datenbankbenutzer", "Datenbankpasswort", "Datenbankname");


if(mysqli_connect_errno())
{
  printf("Datenbankfehler:", mysqli_connect_error());
  exit;
}

Zunächst erstellen wir eine Verbindung zu unserer Datenbank und prüfen dann, ob eine Fehlermeldung zurück gegeben wird. Dies tuen wir mit der Funktion mysqli_connect_errno(). Sollte ein Fehler erzeugt werden, gibt die Funktion einen Fehlercode zurück.

Objektorientiert Datenbankverbindung

$mysqli = new mysqli("localhost", "Datenbankbenutzer", "Datenbankpasswort", "Datenbankname");


if($mysqli->connect_errno)
{
  printf("Datenbankfehler:", mysqli_connect_error());
  exit;
}

Mit new erzeugen wir ein neues Objekt oder anders gesagt, wir erstellen eine Instanz der Klasse mysqli.


Nachdem wir nun eine erfolgreiche Verbindung zu unserer Datenbank herstellen konnten, möchten wir nun eine Abfrage machen. Für eine einfache Abfrage, habe ich eine kleine Tabelle erstellt, die wie folgt aussieht.

CREATE TABLE benutzer(
id INT(4) NOT NULL AUTO_INCREMENT,
PRIMARY KEY(id),
vorname VARCHAR(15),
nachname VARCHAR(30),
age INT(2))

Im zweiten Schritt fügen wir direkt ein paar Datensätze hinzu.

INSERT INTO benutzer (vorname, nachname, age) VALUES
("Peter", "Müller", 29),
("Donald", "Duck", 32),
("Sarah", "Schmidt", 22)

So, dann hätten wir das auch fertig, jetzt können wir zu dem Teil kommen, worum es hier eigentlich geht. Die Abfrage der Datenbank mit Hilfe von MySQLi.
Wie oben werde ich beide Wege zeigen.

Prozedurale MySQLi SELECT Abfrage

$ergebnis = mysqli_query($mysqli, 'SELECT * FROM benutzer WHERE vorname = "Peter"');


while($row = mysqli_fetch_assoc($ergebnis))
{
 echo $row[‘vorname’].' '.$row[‘nachname’];
}
//Ausgabe: Peter Müller

Anders als bei einer normalen MySQL Abfrage, wird bei dem mysqli_query die Verbindung mit angegeben. Danach komt der SQL String für die SELECT Anweisung. Mit der while-Schleife lassen wir uns das Ergebnis ausgeben. Hier nutzen wir die Funktion mysqli_fetch_assoc, die ein assoziatives Array zurück liefert, auf das wir über die Variable $row zugreifen können.

Objektorientierte MySQLi SELECT Abfrage

$ergebnis = $mysqli->query('SELECT * FROM benutzer WHERE vorname = "Peter"');


while($row = $ergebnis->fetch_assoc())
{
 echo $row[‘vorname’].' '.$row[‘nachname’];
}
//Ausgabe: Peter Müller

In den beiden Schreibweisen finden sich kleine Unterschiede, die aber noch nicht so gravierend sind. Die große Veränderung zwischen MySQL und MySQLi ist ersichtlich, wenn man Prepared Statements verwendet. Die beschreibe ich in einem anderen Artikel, den ihr unter MySQLi Prepared Statements finden könnt.

Impressum | 2014 © Wissen Lernen - Webpixelpromoter.com