MariaDB - Kurzanleitung

Eine Datenbankanwendung existiert getrennt von der Hauptanwendung und speichert Datensammlungen. Jede Datenbank verwendet eine oder mehrere APIs für die Erstellung, den Zugriff, die Verwaltung, die Suche und die Replikation der darin enthaltenen Daten.

Datenbanken verwenden auch nicht relationale Datenquellen wie Objekte oder Dateien. Datenbanken sind jedoch die beste Option für große Datenmengen, die unter langsamem Abrufen und Schreiben mit anderen Datenquellen leiden würden.

Relationale Datenbankverwaltungssysteme (RDBMS) speichern Daten in verschiedenen Tabellen. Beziehungen zwischen diesen Tabellen werden mithilfe von Primärschlüsseln und Fremdschlüsseln hergestellt.

RDBMS bietet die folgenden Funktionen:

• Mit ihnen können Sie eine Datenquelle mit Tabellen, Spalten und Indizes implementieren.

• Sie stellen die Integrität von Referenzen über Zeilen mehrerer Tabellen hinweg sicher.

• Sie aktualisieren automatisch die Indizes.

• Sie interpretieren SQL-Abfragen und -Operationen beim Bearbeiten oder Beschaffen von Daten aus Tabellen.

RDBMS-Terminologie

Bevor wir mit unserer Diskussion über MariaDB beginnen, lassen Sie uns einige Begriffe in Bezug auf Datenbanken überprüfen.

• Database - Eine Datenbank ist eine Datenquelle, die aus Tabellen besteht, die verwandte Daten enthalten.

• Table - Eine Tabelle, dh eine Tabelle, ist eine Matrix, die Daten enthält.

• Column- Eine Spalte, dh Datenelement, ist eine Struktur, die Daten eines Typs enthält. Zum Beispiel Versanddaten.

• Row- Eine Zeile ist eine Struktur, die verwandte Daten gruppiert. Zum Beispiel Daten für einen Kunden. Es wird auch als Tupel, Eintrag oder Datensatz bezeichnet.

• Redundancy - Dieser Begriff bezieht sich auf das zweimalige Speichern von Daten, um das System zu beschleunigen.

• Primary Key- Dies bezieht sich auf einen eindeutigen, identifizierenden Wert. Dieser Wert kann in einer Tabelle nicht zweimal vorkommen, und es ist nur eine Zeile zugeordnet.

• Foreign Key - Ein Fremdschlüssel dient als Verknüpfung zwischen zwei Tabellen.

• Compound Key- Ein zusammengesetzter Schlüssel oder zusammengesetzter Schlüssel ist ein Schlüssel, der sich auf mehrere Spalten bezieht. Es bezieht sich auf mehrere Spalten aufgrund einer Spalte ohne eindeutige Qualität.

• Index - Ein Index ist praktisch identisch mit dem Index eines Buches.

• Referential Integrity - Dieser Begriff bezieht sich darauf, sicherzustellen, dass alle Fremdschlüsselwerte auf vorhandene Zeilen verweisen.

MariaDB-Datenbank

MariaDB ist eine beliebte Abzweigung von MySQL, die von den ursprünglichen Entwicklern von MySQL erstellt wurde. Es entstand aus Bedenken im Zusammenhang mit der Übernahme von MySQL durch Oracle. Es bietet Unterstützung sowohl für kleine Datenverarbeitungsaufgaben als auch für Unternehmensanforderungen. Es soll ein Ersatz für MySQL sein, der nur eine einfache Deinstallation von MySQL und eine Installation von MariaDB erfordert. MariaDB bietet die gleichen Funktionen von MySQL und vieles mehr.

Hauptmerkmale von MariaDB

Die wichtigen Merkmale von MariaDB sind -

• MariaDB steht unter GPL, LGPL oder BSD.

• MariaDB enthält eine große Auswahl an Speicher-Engines, einschließlich Hochleistungs-Speicher-Engines, für die Arbeit mit anderen RDBMS-Datenquellen.

• MariaDB verwendet eine standardmäßige und beliebte Abfragesprache.

• MariaDB läuft auf einer Reihe von Betriebssystemen und unterstützt eine Vielzahl von Programmiersprachen.

• MariaDB bietet Unterstützung für PHP, eine der beliebtesten Webentwicklungssprachen.

• MariaDB bietet Galera-Cluster-Technologie an.

• MariaDB bietet auch viele Operationen und Befehle, die in MySQL nicht verfügbar sind, und eliminiert / ersetzt Funktionen, die sich negativ auf die Leistung auswirken.

Anfangen

Bevor Sie mit diesem Tutorial beginnen, stellen Sie sicher, dass Sie über Grundkenntnisse in PHP und HTML verfügen, insbesondere über Material, das in unseren PHP- und HTML-Tutorials behandelt wird.

Dieses Handbuch konzentriert sich auf die Verwendung von MariaDB in einer PHP-Umgebung, daher sind unsere Beispiele für PHP-Entwickler am nützlichsten.

Wir empfehlen dringend, unser PHP-Tutorial zu lesen, wenn Sie nicht vertraut sind oder es überprüfen müssen.

Alle Downloads für MariaDB befinden sich im Download- Bereich der offiziellen Website der MariaDB-Stiftung. Klicken Sie auf den Link zu der gewünschten Version. Eine Liste der Downloads für mehrere Betriebssysteme, Architekturen und Installationsdateitypen wird angezeigt.

Installation unter LINUX / UNIX

Wenn Sie mit Linux / Unix-Systemen vertraut sind, laden Sie einfach die Quelle herunter, um Ihre Installation zu erstellen. Unsere empfohlene Installationsmethode ist die Verwendung von Distributionspaketen. MariaDB bietet Pakete für die folgenden Linux / Unix-Distributionen an -

• RedHat/CentOS/Fedora
• Debian/Ubuntu

Die folgenden Distributionen enthalten ein MariaDB-Paket in ihren Repositorys -

• openSUSE
• Arch Linux
• Mageia
• Mint
• Slackware

Befolgen Sie diese Schritte, um in einer Ubuntu-Umgebung zu installieren -

Step 1 - Melden Sie sich als Root an.

Step 2 - Navigieren Sie zu dem Verzeichnis, das das MariaDB-Paket enthält.

Step 3 - Importieren Sie den GnuPG-Signaturschlüssel mit dem folgenden Code: -

sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 0xcbcb082a1bb943db

Step 4 - Fügen Sie MariaDB zum hinzu sources.listDatei. Öffnen Sie die Datei und fügen Sie den folgenden Code hinzu:

sudo add-apt-repository 'deb http://ftp.osuosl.org/pub/mariadb/repo/5.5/ubuntuprecise main'

Step 5 - Aktualisieren Sie das System mit den folgenden -

sudo apt-get update

Step 6 - Installieren Sie MariaDB mit den folgenden -

sudo apt-get install mariadb-server

Installation unter Windows

Doppelklicken Sie nach dem Suchen und Herunterladen einer automatischen Installationsdatei (MSI) einfach auf die Datei, um die Installation zu starten. Der Installationsassistent führt Sie durch jeden Installationsschritt und alle erforderlichen Einstellungen.

Testen Sie die Installation, indem Sie sie an der Eingabeaufforderung starten. Navigieren Sie zum Speicherort der Installation, normalerweise im Verzeichnis, und geben Sie an der Eingabeaufforderung Folgendes ein:

mysqld.exe --console

Wenn die Installation erfolgreich ist, werden Meldungen zum Start angezeigt. Wenn dies nicht angezeigt wird, haben Sie möglicherweise Berechtigungsprobleme. Stellen Sie sicher, dass Ihr Benutzerkonto auf die Anwendung zugreifen kann. Für die MariaDB-Verwaltung stehen grafische Clients in der Windows-Umgebung zur Verfügung. Wenn Sie die Befehlszeile als unangenehm oder umständlich empfinden, sollten Sie mit ihnen experimentieren.

Installation testen

Führen Sie einige einfache Aufgaben aus, um die Funktion und Installation von MariaDB zu bestätigen.

Use the Admin Utility to Get Server Status

Zeigen Sie die Serverversion mit der mysqladmin-Binärdatei an.

[root@host]# mysqladmin --version

Es sollte die Version, Verteilung, das Betriebssystem und die Architektur anzeigen. Wenn die Ausgabe dieses Typs nicht angezeigt wird, überprüfen Sie Ihre Installation auf Probleme.

Execute Simple Commands with a Client

Rufen Sie die Eingabeaufforderung für MariaDB auf. Dies sollte Sie mit MariaDB verbinden und die Ausführung von Befehlen ermöglichen. Geben Sie einen einfachen Befehl wie folgt ein:

mysql> SHOW DATABASES;

Nach der Installation

Legen Sie nach erfolgreicher Installation von MariaDB ein Root-Passwort fest. Eine Neuinstallation hat ein leeres Passwort. Geben Sie Folgendes ein, um das neue Passwort festzulegen:

mysqladmin -u root password "[enter your password here]";

Geben Sie Folgendes ein, um mit Ihren neuen Anmeldeinformationen eine Verbindung zum Server herzustellen:

mysql -u root -p
Enter password:*******

Upgrade unter Windows

Wenn Sie MySQL bereits auf Ihrem Windows-System installiert haben und auf MariaDB aktualisieren möchten; Deinstallieren Sie MySQL nicht und installieren Sie MariaDB. Dies führt zu einem Konflikt mit der vorhandenen Datenbank. Sie müssen stattdessen MariaDB installieren und dann den Upgrade-Assistenten in der Windows-Installationsdatei verwenden.

Die Optionen Ihrer MySQL my.cnf-Datei sollten mit MariaDB funktionieren. MariaDB verfügt jedoch über viele Funktionen, die in MySQL nicht enthalten sind.

Berücksichtigen Sie die folgenden Konflikte in Ihrer my.cnf-Datei:

• MariaDB verwendet standardmäßig die Aria-Speicher-Engine für temporäre Dateien. Wenn Sie viele temporäre Dateien haben, ändern Sie die Größe des Schlüsselpuffers, wenn Sie keine MyISAM-Tabellen verwenden.

• Wenn Ihre Anwendungen häufig eine Verbindung herstellen oder trennen, ändern Sie die Thread-Cache-Größe.

• Wenn Sie über 100 Verbindungen verwenden, verwenden Sie den Thread-Pool.

Kompatibilität

MySQL und MariaDB sind im Wesentlichen identisch. Es gibt jedoch genügend Unterschiede, um Probleme bei der Aktualisierung zu verursachen. Weitere dieser Unterschiede finden Sie in der MariaDB Knowledge Base.

Bevor Sie versuchen, MariaDB auszuführen, müssen Sie zunächst den aktuellen Status ermitteln, der ausgeführt oder heruntergefahren wird. Es gibt drei Möglichkeiten, MariaDB zu starten und zu stoppen:

• Führen Sie mysqld (die MariaDB-Binärdatei) aus.
• Führen Sie das Startskript mysqld_safe aus.
• Führen Sie das Startskript mysql.server aus.

Wenn Sie MariaDB an einem nicht standardmäßigen Speicherort installiert haben, müssen Sie möglicherweise die Standortinformationen in den Skriptdateien bearbeiten. Stoppen Sie MariaDB, indem Sie dem Skript einfach einen "Stop" -Parameter hinzufügen.

Wenn Sie es automatisch unter Linux starten möchten, fügen Sie Startskripte zu Ihrem hinzu initSystem. Jede Distribution hat ein anderes Verfahren. Informationen hierzu finden Sie in Ihrer Systemdokumentation.

Erstellen eines Benutzerkontos

Erstellen Sie ein neues Benutzerkonto mit dem folgenden Code:

CREATE USER 'newusername'@'localhost' IDENTIFIED BY 'userpassword';

Dieser Code fügt der Benutzertabelle eine Zeile ohne Berechtigungen hinzu. Sie haben auch die Möglichkeit, einen Hashwert für das Passwort zu verwenden. Gewähren Sie den Benutzerrechten den folgenden Code:

GRANT SELECT, INSERT, UPDATE, DELETE ON database1 TO 'newusername'@'localhost';

Andere Berechtigungen umfassen nahezu jeden Befehl oder jede Operation, die in MariaDB möglich ist. Führen Sie nach dem Erstellen eines Benutzers den Befehl "FLUSH PRIVILEGES" aus, um die Grant-Tabellen zu aktualisieren. Dadurch kann das Benutzerkonto verwendet werden.

Die Konfigurationsdatei

Nach einem Build unter Unix / Linux sollte die Konfigurationsdatei "/etc/mysql/my.cnf" wie folgt bearbeitet werden:

# Example mysql config file.
# You can copy this to one of:
# /etc/my.cnf to set global options,
# /mysql-data-dir/my.cnf to get server specific options or
# ~/my.cnf for user specific options.

#

# One can use all long options that the program supports.
# Run the program with --help to get a list of available options

# This will be passed to all mysql clients
[client]
#password = my_password
#port = 3306
#socket = /tmp/mysql.sock

# Here is entries for some specific programs
# The following values assume you have at least 32M ram

# The MySQL server
[mysqld]
#port = 3306
#socket = /tmp/mysql.sock
temp-pool

# The following three entries caused mysqld 10.0.1-MariaDB (and possibly other
   versions) to abort...
# skip-locking
# set-variable = key_buffer = 16M
# set-variable = thread_cache = 4

loose-innodb_data_file_path = ibdata1:1000M
loose-mutex-deadlock-detector
gdb

######### Fix the two following paths

# Where you want to have your database
data = /path/to/data/dir

# Where you have your mysql/MariaDB source + sql/share/english
language = /path/to/src/dir/sql/share/english

[mysqldump]
quick
MariaDB
8
set-variable = max_allowed_packet=16M
[mysql]
no-auto-rehash

[myisamchk]
set-variable = key_buffer = 128M

Bearbeiten Sie die Zeilen "data =" und "language =" entsprechend Ihrer Umgebung.

Navigieren Sie nach der Dateiänderung zum Quellverzeichnis und führen Sie Folgendes aus:

./scripts/mysql_install_db --srcdir = $PWD --datadir = /path/to/data/dir -- user = $LOGNAME

Lassen Sie das “$PWD” variable if you added datadir to the configuration file. Ensure “$LOGNAME ”wird verwendet, wenn Version 10.0.1 von MariaDB ausgeführt wird.

Administrationsbefehle

Überprüfen Sie die folgende Liste wichtiger Befehle, die Sie regelmäßig bei der Arbeit mit MariaDB verwenden werden:

• USE [database name] - Legt die aktuelle Standarddatenbank fest.

• SHOW DATABASES - Listet die aktuell auf dem Server befindlichen Datenbanken auf.

• SHOW TABLES - Listet alle nicht temporären Tabellen auf.

• SHOW COLUMNS FROM [table name] - Stellt Spalteninformationen zur angegebenen Tabelle bereit.

• SHOW INDEX FROM TABLENAME [table name] - Stellt Tabellenindexinformationen zur angegebenen Tabelle bereit.

• SHOW TABLE STATUS LIKE [table name]\G – - Stellt Tabellen Informationen zu nicht temporären Tabellen zur Verfügung, und das Muster, das nach der LIKE-Klausel angezeigt wird, wird zum Abrufen von Tabellennamen verwendet.

MariaDB arbeitet gut mit einer Vielzahl von Programmiersprachen und Frameworks wie PHP, C #, JavaScript, Ruby on Rails, Django und anderen zusammen. PHP bleibt aufgrund seiner Einfachheit und seines historischen Fußabdrucks die beliebteste aller verfügbaren Sprachen. Dieser Leitfaden konzentriert sich auf PHP in Zusammenarbeit mit MariaDB.

PHP bietet eine Auswahl von Funktionen für die Arbeit mit der MySQL-Datenbank. Diese Funktionen führen Aufgaben wie den Zugriff darauf oder das Ausführen von Vorgängen aus und sind vollständig mit MariaDB kompatibel. Rufen Sie diese Funktionen einfach wie jede andere PHP-Funktion auf.

Die PHP-Funktionen, die Sie für MariaDB verwenden, entsprechen dem folgenden Format:

mysql_function(value,value,...);

Der zweite Teil der Funktion gibt ihre Aktion an. Zwei der in diesem Handbuch verwendeten Funktionen sind:

mysqli_connect($connect); mysqli_query($connect,"SQL statement");

Das folgende Beispiel zeigt die allgemeine Syntax eines PHP-Aufrufs einer MariaDB-Funktion -

<html>
   <head>
      <title>PHP and MariaDB</title>
   </head>

   <body>
      <?php
         $retval = mysql_function(value, [value,...]); if( !$retval ) {
            die ( "Error: Error message here" );
         }
         // MariaDB or PHP Statements
      ?>
   </body>
</html>

Im nächsten Abschnitt werden wir wichtige MariaDB-Aufgaben mithilfe von PHP-Funktionen untersuchen.

Eine Möglichkeit, eine Verbindung mit MariaDB herzustellen, besteht darin, die MySQL-Binärdatei an der Eingabeaufforderung zu verwenden.

MYSQL Binary

Sehen Sie sich ein Beispiel unten an.

[root@host]# mysql -u root -p

Enter password:******

Der oben angegebene Code stellt eine Verbindung zu MariaDB her und bietet eine Eingabeaufforderung zum Ausführen von SQL-Befehlen. Nach Eingabe des Codes sollte eine Begrüßungsnachricht mit einer erfolgreichen Versionsnummer angezeigt werden.

Welcome to the MariaDB monitor. Commands end with ; or \g. 
Your MariaDB connection id is 122323232 
Server version: 5.5.40-MariaDB-log
  
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.  
mysql>

In diesem Beispiel wird der Root-Zugriff verwendet, aber jeder Benutzer mit Berechtigungen kann natürlich auf die MariaDB-Eingabeaufforderung zugreifen und Vorgänge ausführen.

Trennen Sie die Verbindung zu MariaDB über die exit Befehl wie folgt -

mysql> exit

PHP-Verbindungsskript

Eine andere Möglichkeit, eine Verbindung zu MariaDB herzustellen und die Verbindung zu MariaDB zu trennen, besteht darin, ein PHP-Skript zu verwenden. PHP bietet diemysql_connect()Funktion zum Öffnen einer Datenbankverbindung. Es verwendet fünf optionale Parameter und gibt nach einer erfolgreichen Verbindung eine MariaDB-Verbindungskennung oder bei einer nicht erfolgreichen Verbindung eine falsche zurück. Es bietet auch diemysql_close() Funktion zum Schließen von Datenbankverbindungen, die einen einzelnen Parameter verwendet.

Syntax

Überprüfen Sie die folgende Syntax des PHP-Verbindungsskripts:

connection mysql_connect(server,user,passwd,new_link,client_flag);

Die Beschreibung der Parameter ist unten angegeben -

Sr.Nr.	Parameter & Beschreibung
1	server Dieser optionale Parameter gibt den Hostnamen an, auf dem der Datenbankserver ausgeführt wird. Der Standardwert ist "localhost: .3036".
2	user Dieser optionale Parameter gibt den Benutzernamen an, der auf die Datenbank zugreift. Der Standardwert ist der Eigentümer des Servers.
3	passwd Dieser optionale Parameter gibt das Kennwort des Benutzers an. Der Standardwert ist leer.
4	new_link Dieser optionale Parameter gibt dies bei einem zweiten Aufruf von an mysql_connect() Mit identischen Argumenten anstelle einer neuen Verbindung wird die Kennung der aktuellen Verbindung zurückgegeben.
5	client flags Dieser optionale Parameter verwendet eine Kombination der folgenden konstanten Werte: MYSQL_CLIENT_SSL - Verwendet SSL-Verschlüsselung. MYSQL_CLIENT_COMPRESS - Verwendet das Komprimierungsprotokoll. MYSQL_CLIENT_IGNORE_SPACE - Ermöglicht Leerzeichen nach Funktionsnamen. MYSQL_CLIENT_INTERACTIVE - Ermöglicht ein interaktives Timeout von Sekunden Inaktivität vor dem Schließen der Verbindung.

Überprüfen Sie die unten angegebene Syntax des PHP-Trennungsskripts.

bool mysql_close ( resource $link_identifier );

Wenn Sie die Ressource weglassen, wird die zuletzt geöffnete Ressource geschlossen. Bei einem erfolgreichen Abschluss wird der Wert true oder false zurückgegeben.

Versuchen Sie den folgenden Beispielcode, um eine Verbindung mit einem MariaDB-Server herzustellen:

<html>
   <head>
      <title>Connect to MariaDB Server</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'guest1'; $dbpass = 'guest1a';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
      
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully'; mysql_close($conn);
      ?>
   </body>
</html>

Bei erfolgreicher Verbindung wird die folgende Ausgabe angezeigt:

mysql> Connected successfully

Das Erstellen oder Löschen von Datenbanken in MariaDB erfordert Berechtigungen, die normalerweise nur Root-Benutzern oder Administratoren gewährt werden. Unter diesen Konten haben Sie zwei Möglichkeiten zum Erstellen einer Datenbank - die mysqladmin-Binärdatei und ein PHP-Skript.

mysqladmin binär

Das folgende Beispiel zeigt die Verwendung der mysqladmin-Binärdatei beim Erstellen einer Datenbank mit dem Namen Products - -

[root@host]# mysqladmin -u root -p create PRODUCTS
Enter password:******

PHP-Datenbank-Skript erstellen

PHP verwendet die mysql_queryFunktion beim Erstellen einer MariaDB-Datenbank. Die Funktion verwendet zwei Parameter, einen optionalen, und gibt bei Erfolg entweder den Wert "true" oder bei Nichterfolg den Wert "false" zurück.

Syntax

Überprüfen Sie Folgendes create database script Syntax -

bool mysql_query( sql, connection );

Die Beschreibung der Parameter ist unten angegeben -

S.No.	Parameter & Beschreibung
1	sql Dieser erforderliche Parameter besteht aus der SQL-Abfrage, die zum Ausführen der Operation erforderlich ist.
2	connection Wenn nicht angegeben, verwendet dieser optionale Parameter die zuletzt verwendete Verbindung.

Versuchen Sie den folgenden Beispielcode zum Erstellen einer Datenbank:

<html>
   <head>
      <title>Create a MariaDB Database</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'root';
         $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }

         echo 'Connected successfully<br />';
         $sql = 'CREATE DATABASE PRODUCTS'; $retval = mysql_query( $sql, $conn );
      
         if(! $retval ) { die('Could not create database: ' . mysql_error()); } echo "Database PRODUCTS created successfully\n"; mysql_close($conn);
      ?>
   </body>
</html>

Nach erfolgreichem Löschen wird die folgende Ausgabe angezeigt:

mysql> Database PRODUCTS created successfully 
mysql> SHOW DATABASES; 
+-----------------------+ 
| Database              | 
+-----------------------+ 
| PRODUCTS              | 
+-----------------------+

Das Erstellen oder Löschen von Datenbanken in MariaDB erfordert Berechtigungen, die normalerweise nur Root-Benutzern oder Administratoren gewährt werden. Unter diesen Konten haben Sie zwei Möglichkeiten, eine Datenbank zu löschen: die mysqladmin-Binärdatei und ein PHP-Skript.

Beachten Sie, dass gelöschte Datenbanken nicht wiederherstellbar sind. Führen Sie diesen Vorgang daher mit Vorsicht aus. Darüber hinaus tun PHP-Skripte, die zum Löschen verwendet werdennot Sie werden vor dem Löschen mit einer Bestätigung aufgefordert.

mysqladmin binär

Das folgende Beispiel zeigt, wie Sie mit der mysqladmin-Binärdatei eine vorhandene Datenbank löschen.

[root@host]# mysqladmin -u root -p drop PRODUCTS
Enter password:******
mysql> DROP PRODUCTS
ERROR 1008 (HY000): Can't drop database 'PRODUCTS'; database doesn't exist

PHP Drop Database Script

PHP verwendet die mysql_queryFunktion beim Löschen von MariaDB-Datenbanken. Die Funktion verwendet zwei Parameter, einen optionalen, und gibt bei Erfolg entweder den Wert "true" oder bei Nichterfolg den Wert "false" zurück.

Syntax

Überprüfen Sie die folgende Syntax des Drop-Datenbank-Skripts:

bool mysql_query( sql, connection );

Die Beschreibung der Parameter ist unten angegeben -

Sr.Nr.	Parameter & Beschreibung
1	sql Dieser erforderliche Parameter besteht aus der SQL-Abfrage, die zum Ausführen der Operation erforderlich ist.
2	connection Wenn nicht angegeben, verwendet dieser optionale Parameter die zuletzt verwendete Verbindung.

Versuchen Sie den folgenden Beispielcode zum Löschen einer Datenbank:

<html>
   <head>
      <title>Delete a MariaDB Database</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'root';
         $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully<br />';
         
         $sql = 'DROP DATABASE PRODUCTS'; $retval = mysql_query( $sql, $conn );
         
         if(! $retval ){ die('Could not delete database: ' . mysql_error()); } echo "Database PRODUCTS deleted successfully\n"; mysql_close($conn);
      ?>
   </body>
</html>

Nach erfolgreichem Löschen wird die folgende Ausgabe angezeigt:

mysql> Database PRODUCTS deleted successfully

Nach dem Herstellen einer Verbindung zu MariaDB müssen Sie eine Datenbank auswählen, mit der gearbeitet werden soll, da möglicherweise viele Datenbanken vorhanden sind. Es gibt zwei Möglichkeiten, diese Aufgabe auszuführen: über die Eingabeaufforderung oder über ein PHP-Skript.

Die Eingabeaufforderung

Verwenden Sie bei der Auswahl einer Datenbank an der Eingabeaufforderung einfach den SQL-Befehl ‘use’ - -

[root@host]# mysql -u root -p

Enter password:******

mysql> use PRODUCTS;

Database changed

mysql> SELECT database();  
+-------------------------+ 
| Database                | 
+-------------------------+ 
| PRODUCTS                | 
+-------------------------+

Sobald Sie eine Datenbank ausgewählt haben, werden alle nachfolgenden Befehle für die ausgewählte Datenbank ausgeführt.

Note- Bei allen Namen (z. B. Datenbank, Tabelle, Felder) wird zwischen Groß- und Kleinschreibung unterschieden. Stellen Sie sicher, dass die Befehle dem richtigen Fall entsprechen.

PHP Wählen Sie Datenbankskript

PHP bietet die mysql_select_dbFunktion zur Datenbankauswahl. Die Funktion verwendet zwei Parameter, einen optionalen, und gibt bei erfolgreicher Auswahl den Wert "true" oder bei einem Fehler den Wert "false" zurück.

Syntax

Überprüfen Sie die folgende Syntax für ausgewählte Datenbankskripte.

bool mysql_select_db( db_name, connection );

Die Beschreibung der Parameter ist unten angegeben -

S.No.	Parameter & Beschreibung
1	db_name Dieser erforderliche Parameter gibt den Namen der zu verwendenden Datenbank an.
2	connection Wenn nicht angegeben, verwendet dieser optionale Parameter die zuletzt verwendete Verbindung.

Versuchen Sie den folgenden Beispielcode zur Auswahl einer Datenbank:

<html>
   <head>
      <title>Select a MariaDB Database</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'guest1';
         $dbpass = 'guest1a'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully';
         
         mysql_select_db( 'PRODUCTS' );
         mysql_close($conn);
      ?>
   </body>
</html>

Nach erfolgreicher Auswahl sehen Sie folgende Ausgabe:

mysql> Connected successfully

Gute Felddefinitionen sind für die Optimierung Ihrer Datenbank unerlässlich. Der ideale Ansatz erfordert, dass Sie ausschließlich ein Feld des Typs und der Größe verwenden, die benötigt werden. Wenn Sie beispielsweise nur ein Feld mit einer Breite von fünf Zeichen verwenden, definieren Sie kein Feld mit einer Breite von 20 Zeichen. Feld- (oder Spalten-) Typen werden aufgrund der im Feld gespeicherten Datentypen auch als Datentypen bezeichnet.

MariaDB-Datentypen können in numerische Werte, Datum und Uhrzeit sowie Zeichenfolgenwerte unterteilt werden.

Numerische Datentypen

Die von MariaDB unterstützten numerischen Datentypen lauten wie folgt:

• TINYINT - Dieser Datentyp repräsentiert kleine Ganzzahlen, die in den vorzeichenbehafteten Bereich von -128 bis 127 und den vorzeichenlosen Bereich von 0 bis 255 fallen.

• BOOLEAN - Dieser Datentyp verknüpft einen Wert 0 mit "false" und einen Wert 1 mit "true".

• SMALLINT - Dieser Datentyp repräsentiert Ganzzahlen im vorzeichenbehafteten Bereich von -32768 bis 32768 und im vorzeichenlosen Bereich von 0 bis 65535.

• MEDIUMINT - Dieser Datentyp repräsentiert Ganzzahlen im vorzeichenbehafteten Bereich von -8388608 bis 8388607 und im vorzeichenlosen Bereich von 0 bis 16777215.

• INT(also INTEGER)- Dieser Datentyp repräsentiert eine Ganzzahl normaler Größe. Wenn der Bereich als vorzeichenlos markiert ist, erstreckt er sich von 0 bis 4294967295. Wenn er signiert ist (Standardeinstellung), erstreckt sich der Bereich von -2147483648 bis 2147483647. Wenn eine Spalte auf ZEROFILL (ein vorzeichenloser Status) gesetzt ist, werden allen Werten Nullen vorangestellt M Ziffern im INT-Wert.

• BIGINT - Dieser Datentyp repräsentiert Ganzzahlen im vorzeichenbehafteten Bereich von 9223372036854775808 bis 9223372036854775807 und im vorzeichenlosen Bereich von 0 bis 18446744073709551615.

• DECIMAL(auch DEC, NUMERIC, FIXED) - Dieser Datentyp repräsentiert präzise Festkommazahlen, wobei M seine Ziffern und D die Ziffern nach der Dezimalstelle angibt. Der M-Wert fügt weder "-" noch den Dezimalpunkt hinzu. Wenn D auf 0 gesetzt ist, wird kein Dezimal- oder Bruchteil angezeigt und der Wert wird beim EINFÜGEN auf das nächste Dezimal gerundet. Die maximal zulässige Stelle ist 65 und das Maximum für Dezimalstellen ist 30. Der Standardwert für M bei Auslassung ist 10 und 0 für D bei Auslassung.

• FLOAT - Dieser Datentyp repräsentiert eine kleine Gleitkommazahl mit dem Wert 0 oder eine Zahl innerhalb der folgenden Bereiche. -

  • -3,402823466E + 38 bis -1,175494351E-38

  • 1.175494351E-38 bis 3.402823466E + 38

• DOUBLE (ebenfalls REAL und DOUBLE PRECISION) - Dieser Datentyp repräsentiert Gleitkommazahlen normaler Größe mit dem Wert 0 oder innerhalb der folgenden Bereiche. -

  • -1.7976931348623157E + 308 bis -2.2250738585072014E-308

  • 2.2250738585072014E-308 bis 1.7976931348623157E + 308

• BIT- Dieser Datentyp stellt Bitfelder dar, wobei M die Anzahl der Bits pro Wert angibt. Wenn M weggelassen wird, ist der Standardwert 1. Bitwerte können mit „b '[Wert]'“ angewendet werden, wobei der Wert den Bitwert in 0s und 1s darstellt. Das Auffüllen mit Nullen erfolgt automatisch von links über die gesamte Länge. Zum Beispiel wird "10" zu "0010".

Datums- und Uhrzeitdatentypen

Die von MariaDB unterstützten Datums- und Uhrzeitdatentypen lauten wie folgt:

• DATE - Dieser Datentyp repräsentiert einen Datumsbereich von „1000-01-01“ bis „9999-12-31“ und verwendet das Datumsformat „JJJJ-MM-TT“.

• TIME - Dieser Datentyp repräsentiert einen Zeitbereich von "-838: 59: 59.999999" bis "838: 59: 59.999999".

• DATETIME- Dieser Datentyp repräsentiert den Bereich "1000-01-01 00: 00: 00.000000" bis "9999-12-31 23: 59: 59.999999". Es wird das Format „JJJJ-MM-TT HH: MM: SS“ verwendet.

• TIMESTAMP- Dieser Datentyp repräsentiert einen Zeitstempel im Format „JJJJ-MM-TT HH: MM: TT“. Es findet hauptsächlich Verwendung bei der Detaillierung des Zeitpunkts von Datenbankänderungen, z. B. Einfügen oder Aktualisieren.

• YEAR- Dieser Datentyp repräsentiert ein Jahr im 4-stelligen Format. Das vierstellige Format ermöglicht Werte im Bereich von 1901 bis 2155 und 0000.

String DataTypes

Die von MariaDB unterstützten Zeichenfolgentypwerte lauten wie folgt:

• String literals - Dieser Datentyp repräsentiert Zeichenfolgen in Anführungszeichen.

• CHAR- Dieser Datentyp stellt eine rechts aufgefüllte Zeichenfolge mit fester Länge dar, die Leerzeichen mit der angegebenen Länge enthält. M steht für die Spaltenlänge von Zeichen in einem Bereich von 0 bis 255, der Standardwert ist 1.

• VARCHAR - Dieser Datentyp stellt eine Zeichenfolge variabler Länge mit einem M-Bereich (maximale Spaltenlänge) von 0 bis 65535 dar.

• BINARY - Dieser Datentyp repräsentiert binäre Bytezeichenfolgen, wobei M die Spaltenlänge in Bytes ist.

• VARBINARY - Dieser Datentyp repräsentiert binäre Byte-Zeichenfolgen mit variabler Länge, wobei M die Spaltenlänge ist.

• TINYBLOB- Dieser Datentyp repräsentiert eine Blob-Spalte mit einer maximalen Länge von 255 (28 - 1) Bytes. Im Speicher verwendet jeder ein Präfix mit einer Bytelänge, das die Bytemenge im Wert angibt.

• BLOB- Dieser Datentyp repräsentiert eine Blob-Spalte mit einer maximalen Länge von 65.535 (216 - 1) Bytes. Beim Speichern wird jeweils ein Präfix mit einer Länge von zwei Bytes verwendet, das die Bytemenge im Wert angibt.

• MEDIUMBLOB- Dieser Datentyp repräsentiert eine Blob-Spalte mit einer maximalen Länge von 16.777.215 (2 ²⁴ - 1) Bytes. Bei der Speicherung wird jeweils ein Präfix mit einer Länge von drei Bytes verwendet, das die Bytemenge im Wert angibt.

• LONGBLOB- Dieser Datentyp repräsentiert eine Blob-Spalte mit einer maximalen Länge von 4.294.967.295 (2 ³² - 1) Bytes. Im Speicher verwendet jeder ein Präfix mit einer Länge von vier Bytes, das die Bytemenge im Wert angibt.

• TINYTEXT- Dieser Datentyp repräsentiert eine Textspalte mit einer maximalen Länge von 255 (2 ⁸ - 1) Zeichen. Im Speicher verwendet jeder ein Präfix mit einer Bytelänge, das die Bytemenge im Wert angibt.

• TEXT- Dieser Datentyp repräsentiert eine Textspalte mit einer maximalen Länge von 65.535 (2 ¹⁶ - 1) Zeichen. Beim Speichern wird jeweils ein Präfix mit einer Länge von zwei Bytes verwendet, das die Bytemenge im Wert angibt.

• MEDIUMTEXT- Dieser Datentyp repräsentiert eine Textspalte mit einer maximalen Länge von 16.777.215 (2 ²⁴ - 1) Zeichen. Bei der Speicherung wird jeweils ein Präfix mit einer Länge von drei Bytes verwendet, das die Bytemenge im Wert angibt.

• LONGTEXT- Dieser Datentyp repräsentiert eine Textspalte mit einer maximalen Länge von 4.294.967.295 oder 4 GB (2 ³² - 1) Zeichen. Im Speicher verwendet jeder ein Präfix mit einer Länge von vier Bytes, das die Bytemenge im Wert angibt.

• ENUM - Dieser Datentyp repräsentiert ein Zeichenfolgenobjekt mit nur einem einzigen Wert aus einer Liste.

• SET- Dieser Datentyp repräsentiert ein Zeichenfolgenobjekt mit null oder mehr Werten aus einer Liste mit maximal 64 Mitgliedern. SET-Werte werden intern als ganzzahlige Werte angezeigt.

In diesem Kapitel erfahren Sie, wie Sie Tabellen erstellen. Bestimmen Sie vor dem Erstellen einer Tabelle zunächst deren Namen, Feldnamen und Felddefinitionen.

Es folgt die allgemeine Syntax für die Tabellenerstellung:

CREATE TABLE table_name (column_name column_type);

Überprüfen Sie den Befehl zum Erstellen einer Tabelle in der PRODUCTS-Datenbank.

databaseproducts_ tbl(
   product_id INT NOT NULL AUTO_INCREMENT,
   product_name VARCHAR(100) NOT NULL,
   product_manufacturer VARCHAR(40) NOT NULL,
   submission_date DATE,
   PRIMARY KEY ( product_id )
);

Im obigen Beispiel wird "NOT NULL" als Feldattribut verwendet, um Fehler zu vermeiden, die durch einen Nullwert verursacht werden. Das Attribut "AUTO_INCREMENT" weist MariaDB an, den nächsten verfügbaren Wert zum ID-Feld hinzuzufügen. Das Schlüsselwort Primärschlüssel definiert eine Spalte alsprimary key. Mehrere durch Kommas getrennte Spalten können einen Primärschlüssel definieren.

Die beiden Hauptmethoden zum Erstellen von Tabellen sind die Verwendung der Eingabeaufforderung und eines PHP-Skripts.

Die Eingabeaufforderung

Verwenden Sie den Befehl CREATE TABLE, um die Aufgabe wie unten gezeigt auszuführen.

root@host# mysql -u root -p
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> CREATE TABLE products_tbl(
   -> product_id INT NOT NULL AUTO_INCREMENT,
   -> product_name VARCHAR(100) NOT NULL,
   -> product_manufacturer VARCHAR(40) NOT NULL,
   -> submission_date DATE,
   -> PRIMARY KEY ( product_id )
   -> );
mysql> SHOW TABLES;
+------------------------+
| PRODUCTS               |
+------------------------+
| products_tbl           |
+------------------------+

Stellen Sie sicher, dass alle Befehle mit einem Semikolon abgeschlossen sind.

PHP Tabellenskript erstellen

PHP bietet mysql_query()zur Tabellenerstellung. Das zweite Argument enthält den erforderlichen SQL-Befehl -

<html>
   <head>
      <title>Create a MariaDB Table</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'root'; $dbpass = 'rootpassword';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
      
         if(! $conn ){ die('Could not connect: ' . mysql_error()); } echo 'Connected successfully<br />'; $sql = "CREATE TABLE products_tbl( ".
            "product_id INT NOT NULL AUTO_INCREMENT, ".
            "product_name VARCHAR(100) NOT NULL, ".
            "product_manufacturer VARCHAR(40) NOT NULL, ".
            "submission_date DATE, ".
            "PRIMARY KEY ( product_id )); ";
      
         mysql_select_db( 'PRODUCTS' );
         $retval = mysql_query( $sql, $conn ); if(! $retval ) {
            die('Could not create table: ' . mysql_error());
         }
         echo "Table created successfully\n";
         
         mysql_close($conn);
      ?>
   </body>
</html>

Bei erfolgreicher Tabellenerstellung wird die folgende Ausgabe angezeigt:

mysql> Table created successfully

In diesem Kapitel lernen wir, Tabellen zu löschen.

Das Löschen von Tabellen ist sehr einfach, aber denken Sie daran, dass alle gelöschten Tabellen nicht wiederherstellbar sind. Die allgemeine Syntax zum Löschen von Tabellen lautet wie folgt:

DROP TABLE table_name ;

Es gibt zwei Möglichkeiten, um eine Tabelle zu löschen: Verwenden Sie die Eingabeaufforderung oder ein PHP-Skript.

Die Eingabeaufforderung

Verwenden Sie an der Eingabeaufforderung einfach die DROP TABLE SQL-Befehl -

root@host# mysql -u root -p
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> DROP TABLE products_tbl

mysql> SELECT * from products_tbl
ERROR 1146 (42S02): Table 'products_tbl' doesn't exist

PHP Drop Table Script

PHP bietet mysql_query()zum Ablegen von Tischen. Übergeben Sie einfach dem zweiten Argument den entsprechenden SQL-Befehl -

<html>
   <head>
      <title>Create a MariaDB Table</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'root'; $dbpass = 'rootpassword';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
         
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully<br />'; $sql = "DROP TABLE products_tbl";
         mysql_select_db( 'PRODUCTS' );
         $retval = mysql_query( $sql, $conn ); if(! $retval ) {
            die('Could not delete table: ' . mysql_error());
         }
         echo "Table deleted successfully\n";
         
         mysql_close($conn);
      ?>
   </body>
</html>

Nach erfolgreichem Löschen der Tabelle wird die folgende Ausgabe angezeigt:

mysql> Table deleted successfully

In diesem Kapitel erfahren Sie, wie Sie Daten in eine Tabelle einfügen.

Das Einfügen von Daten in eine Tabelle erfordert den Befehl INSERT. Die allgemeine Syntax des Befehls lautet INSERT, gefolgt von Tabellenname, Feldern und Werten.

Überprüfen Sie die unten angegebene allgemeine Syntax -

INSERT INTO tablename (field,field2,...) VALUES (value, value2,...);

Die Anweisung erfordert die Verwendung von einfachen oder doppelten Anführungszeichen für Zeichenfolgenwerte. Weitere Optionen für die Anweisung sind die Anweisungen "INSERT ... SET", die Anweisungen "INSERT ... SELECT" und verschiedene andere Optionen.

Note - Die in der Anweisung angezeigte Funktion VALUES () gilt nur für INSERT-Anweisungen und gibt NULL zurück, wenn sie an anderer Stelle verwendet wird.

Für die Ausführung des Vorgangs stehen zwei Optionen zur Verfügung: Verwenden Sie die Befehlszeile oder ein PHP-Skript.

Die Eingabeaufforderung

An der Eingabeaufforderung gibt es viele Möglichkeiten, einen Auswahlvorgang auszuführen. Eine Standardaussage ist unten angegeben -

belowmysql>
INSERT INTO products_tbl (ID_number, Nomenclature) VALUES (12345,“Orbitron 4000”);
mysql> SHOW COLUMNS FROM products_tbl;
+-------------+-------------+------+-----+---------+-------+
| Field       | Type        | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| ID_number   | int(5)      |      |     |         |       |
| Nomenclature| char(13)    |      |     |         |       |
+-------------+-------------+------+-----+---------+-------+

Sie können mehrere Zeilen einfügen -

INSERT INTO products VALUES (1, “first row”), (2, “second row”);

Sie können auch die SET-Klausel verwenden -

INSERT INTO products SELECT * FROM inventory WHERE status = 'available';

PHP-Einfügungsskript

Verwenden Sie dieselbe Anweisung "INSERT INTO ..." in einer PHP-Funktion, um die Operation auszuführen. Sie werden die verwendenmysql_query() wieder funktionieren.

Überprüfen Sie das folgende Beispiel -

<?php
   if(isset($_POST['add'])) {
      $dbhost = 'localhost:3036'; $dbuser = 'root';
      $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
         die('Could not connect: ' . mysql_error());
      }

      if(! get_magic_quotes_gpc() ) {
         $product_name = addslashes ($_POST['product_name']);
         $product_manufacturer = addslashes ($_POST['product_name']);
      } else {
         $product_name = $_POST['product_name'];
         $product_manufacturer = $_POST['product_manufacturer'];
      }
      $ship_date = $_POST['ship_date'];
      $sql = "INSERT INTO products_tbl ". "(product_name,product_manufacturer, ship_date) ". "VALUES"."('$product_name','$product_manufacturer','$ship_date')";

      mysql_select_db('PRODUCTS');
      $retval = mysql_query( $sql, $conn ); if(! $retval ) {
         die('Could not enter data: ' . mysql_error());
      }

      echo "Entered data successfully\n";
      mysql_close($conn);
   }
?>

Nach erfolgreicher Dateneinfügung wird die folgende Ausgabe angezeigt:

mysql> Entered data successfully

Sie werden auch Validierungsanweisungen mit Einfügeanweisungen zusammenarbeiten, z. B. um sicherzustellen, dass die Daten korrekt eingegeben werden. MariaDB enthält zu diesem Zweck eine Reihe von Optionen, von denen einige automatisch sind.

In diesem Kapitel erfahren Sie, wie Sie Daten aus einer Tabelle auswählen.

SELECT-Anweisungen rufen ausgewählte Zeilen ab. Sie können UNION-Anweisungen, eine Bestellklausel, eine LIMIT-Klausel, eine WHERE-Klausel, eine GROUP BY ... HAVING-Klausel und Unterabfragen enthalten.

Überprüfen Sie die folgende allgemeine Syntax:

SELECT field, field2,... FROM table_name, table_name2,... WHERE...

Eine SELECT-Anweisung bietet mehrere Optionen zum Angeben der verwendeten Tabelle.

• database_name.table_name

• table_name.column_name

• database_name.table_name.column_name

Alle select-Anweisungen müssen eine oder mehrere enthalten select expressions. Ausgewählte Ausdrücke bestehen aus einer der folgenden Optionen:

• Ein Spaltenname.

• Ein Ausdruck, der Operatoren und Funktionen verwendet.

• Die Angabe "Tabellenname. *", Um alle Spalten in der angegebenen Tabelle auszuwählen.

• Das Zeichen "*" zum Auswählen aller Spalten aus allen in der FROM-Klausel angegebenen Tabellen.

Die Eingabeaufforderung oder ein PHP-Skript können zum Ausführen einer select-Anweisung verwendet werden.

Die Eingabeaufforderung

Führen Sie an der Eingabeaufforderung die folgenden Anweisungen aus:

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> SELECT * from products_tbl
+-------------+---------------+
| ID_number   | Nomenclature  |
+-------------+---------------+
| 12345       | Orbitron 4000 |
+-------------+---------------+

PHP Select Script

Verwenden Sie dieselben SELECT-Anweisungen in einer PHP-Funktion, um die Operation auszuführen. Sie werden die verwendenmysql_query()wieder funktionieren. Überprüfen Sie ein Beispiel unten -

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT product_id, product_name,product_manufacturer, ship_date FROM products_tbl';
   mysql_select_db('PRODUCTS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Product ID :{$row['product_id']} <br> ". "Name: {$row['product_name']} <br> ".
         "Manufacturer: {$row['product_manufacturer']} <br> ". "Ship Date : {$row['ship_date']} <br>".
         "--------------------------------<br>";
   }

   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Nach erfolgreichem Datenabruf wird die folgende Ausgabe angezeigt:

Product ID: 12345
Nomenclature: Orbitron 4000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Nomenclature: Orbitron 3000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
mysql> Fetched data successfully

Best Practices empfehlen, den Cursorspeicher nach jeder SELECT-Anweisung freizugeben. PHP bietet diemysql_free_result()Funktion für diesen Zweck. Überprüfen Sie die Verwendung wie unten gezeigt -

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl';
   mysql_select_db('PRODUCTS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_NUM)) {
      echo "Product ID :{$row[0]} <br> ". "Name: {$row[1]} <br> ".
         "Manufacturer: {$row[2]} <br> ". "Ship Date : {$row[3]} <br> ".
         "--------------------------------<br>";
   }

   mysql_free_result($retval); echo "Fetched data successfully\n"; mysql_close($conn);
?>

WHEREKlauseln filtern verschiedene Anweisungen wie SELECT, UPDATE, DELETE und INSERT. Sie präsentieren Kriterien zur Angabe der Aktion. Sie werden normalerweise nach einem Tabellennamen in einer Anweisung angezeigt, und ihre Bedingung folgt. Die WHERE-Klausel funktioniert im Wesentlichen wie eine if-Anweisung.

Überprüfen Sie die allgemeine Syntax der unten angegebenen WHERE-Klausel -

[COMMAND] field,field2,... FROM table_name,table_name2,... WHERE [CONDITION]

Beachten Sie die folgenden Eigenschaften der WHERE-Klausel:

• Es ist optional.

• Hiermit kann jede Bedingung angegeben werden.

• Es ermöglicht die Angabe mehrerer Bedingungen mithilfe eines UND- oder ODER-Operators.

• Die Groß- und Kleinschreibung gilt nur für Aussagen, die LIKE-Vergleiche verwenden.

Die WHERE-Klausel erlaubt die Verwendung der folgenden Operatoren:

Operator
=! =
> <
> = <=

WHERE-Klauseln können an der Eingabeaufforderung oder in einem PHP-Skript verwendet werden.

Die Eingabeaufforderung

Verwenden Sie an der Eingabeaufforderung einfach einen Standardbefehl -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> SELECT * from products_tbl WHERE product_manufacturer = 'XYZ Corp';
+-------------+----------------+----------------------+
| ID_number   | Nomenclature   | product_manufacturer |
+-------------+----------------+----------------------+
| 12345       | Orbitron 4000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12346       | Orbitron 3000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12347       | Orbitron 1000  | XYZ Corp             |
+-------------+----------------+----------------------+

Überprüfen Sie ein Beispiel mit dem AND Zustand -

SELECT *
FROM products_tbl
WHERE product_name = 'Bun Janshu 3000';
AND product_id <= 344;

In diesem Beispiel werden sowohl UND- als auch ODER-Bedingungen kombiniert

SELECT *
FROM products_tbl
WHERE (product_name = 'Bun Janshu 3000' AND product_id < 344)
OR (product_name = 'Bun Janshu 3000');

PHP-Skripte mit Where-Klausel

Beschäftige die mysql_query() Funktion in Operationen mit einer WHERE-Klausel -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl WHERE product_manufacturer = "XYZ Corp"'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Product ID :{$row['product_id']} <br> ".
         "Name: {$row['product_name']} <br> ". "Manufacturer: {$row['product_manufacturer']} <br> ".
         "Ship Date: {$row['ship_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

Nach erfolgreichem Datenabruf wird die folgende Ausgabe angezeigt:

Product ID: 12345
Nomenclature: Orbitron 4000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Nomenclature: Orbitron 3000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
Product ID: 12347
Nomenclature: Orbitron 1000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
mysql> Fetched data successfully

Das UPDATEBefehl ändert vorhandene Felder durch Ändern von Werten. Es verwendet die SET-Klausel, um Spalten zum Ändern anzugeben und die neu zugewiesenen Werte anzugeben. Diese Werte können entweder ein Ausdruck oder der Standardwert des Felds sein. Das Festlegen eines Standardwerts erfordert die Verwendung des Schlüsselworts DEFAULT. Der Befehl kann auch eine WHERE-Klausel verwenden, um Bedingungen für eine Aktualisierung anzugeben, und / oder eine ORDER BY-Klausel, um in einer bestimmten Reihenfolge zu aktualisieren.

Überprüfen Sie die folgende allgemeine Syntax:

UPDATE table_name SET field=new_value, field2=new_value2,...
[WHERE ...]

Führen Sie einen UPDATE-Befehl entweder an der Eingabeaufforderung oder mithilfe eines PHP-Skripts aus.

Die Eingabeaufforderung

Verwenden Sie an der Eingabeaufforderung einfach eine Standard-Befehlswurzel -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> UPDATE products_tbl
   SET nomenclature = 'Fiber Blaster 300Z' WHERE ID_number = 112;
mysql> SELECT * from products_tbl WHERE ID_number='112';
+-------------+---------------------+----------------------+
| ID_number   | Nomenclature        | product_manufacturer |
+-------------+---------------------+----------------------+
| 112         | Fiber Blaster 300Z  | XYZ Corp             |
+-------------+---------------------+----------------------+

PHP Update Query Script

Beschäftige die mysql_query() Funktion in UPDATE-Befehlsanweisungen -

<?php
   $dbhost = ‘localhost:3036’; $dbuser = ‘root’;
   $dbpass = ‘rootpassword’; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die(‘Could not connect: ‘ . mysql_error());
   }

   $sql = ‘UPDATE products_tbl SET product_name = ”Fiber Blaster 300z” WHERE product_id = 112’; mysql_select_db(‘PRODUCTS’); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die(‘Could not update data: ‘ . mysql_error()); } echo “Updated data successfully\n”; mysql_close($conn);
?>

Nach erfolgreicher Datenaktualisierung wird die folgende Ausgabe angezeigt:

mysql> Updated data successfully

Der Befehl DELETE löscht Tabellenzeilen aus der angegebenen Tabelle und gibt die gelöschte Menge zurück. Greifen Sie mit der Funktion ROW_COUNT () auf die gelöschte Menge zu. Eine WHERE-Klausel gibt Zeilen an, und in Abwesenheit werden alle Zeilen gelöscht. Eine LIMIT-Klausel steuert die Anzahl der gelöschten Zeilen.

In einer DELETE-Anweisung für mehrere Zeilen werden nur die Zeilen gelöscht, die eine Bedingung erfüllen. und LIMIT- und WHERE-Klauseln sind nicht zulässig. DELETE-Anweisungen ermöglichen das Löschen von Zeilen aus Tabellen in verschiedenen Datenbanken, jedoch nicht das Löschen aus einer Tabelle und das anschließende Auswählen aus derselben Tabelle innerhalb einer Unterabfrage.

Überprüfen Sie die folgende DELETE-Syntax:

DELETE FROM table_name [WHERE …]

Führen Sie einen DELETE-Befehl entweder an der Eingabeaufforderung oder mithilfe eines PHP-Skripts aus.

Die Eingabeaufforderung

Verwenden Sie an der Eingabeaufforderung einfach einen Standardbefehl -

root@host# mysql –u root –p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> DELETE FROM products_tbl WHERE product_id=133;
mysql> SELECT * from products_tbl WHERE ID_number='133';
ERROR 1032 (HY000): Can't find record in 'products_tbl'

PHP Delete Query Script

Verwenden Sie die mysql_query() Funktion in DELETE-Befehlsanweisungen -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'DELETE FROM products_tbl WHERE product_id = 261'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die('Could not delete data: ' . mysql_error()); } echo "Deleted data successfully\n"; mysql_close($conn);
?>

Nach erfolgreichem Löschen der Daten wird die folgende Ausgabe angezeigt:

mysql> Deleted data successfully
mysql> SELECT * from products_tbl WHERE ID_number='261';
ERROR 1032 (HY000): Can't find record in 'products_tbl'

Die WHERE-Klausel bietet eine Möglichkeit, Daten abzurufen, wenn eine Operation eine genaue Übereinstimmung verwendet. In Situationen, in denen mehrere Ergebnisse mit gemeinsamen Merkmalen erforderlich sind, kann dieLIKE Klausel ermöglicht einen breiten Mustervergleich.

Eine LIKE-Klausel prüft auf eine Musterübereinstimmung und gibt ein wahres oder falsches zurück. Die zum Vergleich verwendeten Muster akzeptieren die folgenden Platzhalterzeichen: "%", das der Anzahl der Zeichen (0 oder mehr) entspricht; und "_", das einem einzelnen Zeichen entspricht. Das Platzhalterzeichen "_" stimmt nur mit Zeichen innerhalb seines Satzes überein. Dies bedeutet, dass lateinische Zeichen ignoriert werden, wenn ein anderer Satz verwendet wird. Bei den Übereinstimmungen wird standardmäßig zwischen Groß- und Kleinschreibung unterschieden, wobei zusätzliche Einstellungen für die Groß- und Kleinschreibung erforderlich sind.

Eine NOT LIKE-Klausel ermöglicht das Testen der entgegengesetzten Bedingung, ähnlich wie die not Operator.

Wenn der Anweisungsausdruck oder das Anweisungsmuster NULL ergibt, ist das Ergebnis NULL.

Überprüfen Sie die unten angegebene allgemeine LIKE-Klauselsyntax.

SELECT field, field2,... FROM table_name, table_name2,...
WHERE field LIKE condition

Verwenden Sie eine LIKE-Klausel entweder an der Eingabeaufforderung oder in einem PHP-Skript.

Die Eingabeaufforderung

Verwenden Sie an der Eingabeaufforderung einfach einen Standardbefehl -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from products_tbl
   WHERE product_manufacturer LIKE 'XYZ%';
+-------------+----------------+----------------------+
| ID_number   | Nomenclature   | product_manufacturer |
+-------------+----------------+----------------------+
| 12345       | Orbitron 4000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12346       | Orbitron 3000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12347       | Orbitron 1000  | XYZ Corp             |
+-------------+----------------+----------------------+

PHP-Skript mit Like-Klausel

Verwenden Sie die mysql_query() Funktion in Anweisungen, die die LIKE-Klausel verwenden

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl WHERE product_manufacturer LIKE "xyz%"'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Product ID:{$row['product_id']} <br> ".
         "Name: {$row['product_name']} <br> ". "Manufacturer: {$row['product_manufacturer']} <br> ".
         "Ship Date: {$row['ship_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

Nach erfolgreichem Datenabruf wird die folgende Ausgabe angezeigt:

Product ID: 12345
Nomenclature: Orbitron 4000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Nomenclature: Orbitron 3000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
Product ID: 12347
Nomenclature: Orbitron 1000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
mysql> Fetched data successfully

Das ORDER BYKlausel, wie in früheren Diskussionen erwähnt, sortiert die Ergebnisse einer Erklärung. Es gibt die Reihenfolge der Daten an, mit denen gearbeitet wird, und enthält die Option zum Sortieren in aufsteigender (ASC) oder absteigender (DESC) Reihenfolge. Wenn die Auftragsspezifikation weggelassen wird, steigt die Standardbestellung auf.

ORDER BY-Klauseln erscheinen in einer Vielzahl von Anweisungen wie DELETE und UPDATE. Sie erscheinen immer am Ende einer Anweisung, nicht in einer Unterabfrage oder vor einer festgelegten Funktion, da sie mit der endgültigen resultierenden Tabelle arbeiten. Sie können auch keine Ganzzahl verwenden, um eine Spalte zu identifizieren.

Überprüfen Sie die allgemeine Syntax der unten angegebenen ORDER BY-Klausel -

SELECT field, field2,... [or column] FROM table_name, table_name2,...
ORDER BY field, field2,... ASC[or DESC]

Verwenden Sie eine ORDER BY-Klausel entweder an der Eingabeaufforderung oder in einem PHP-Skript.

Die Eingabeaufforderung

Verwenden Sie an der Eingabeaufforderung einfach einen Standardbefehl -

root@ host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed

mysql> SELECT * from products_tbl ORDER BY product_manufacturer ASC
+-------------+----------------+----------------------+
| ID_number   | Nomenclature   | product_manufacturer |
+-------------+----------------+----------------------+
| 56789       | SuperBlast 400 | LMN Corp             |
+-------------+----------------+----------------------+
| 67891       | Zoomzoom 5000  | QFT Corp             |
+-------------+----------------+----------------------+
| 12347       | Orbitron 1000  | XYZ Corp             |
+-------------+----------------+----------------------+

PHP-Skript mit Order By-Klausel

Nutzen Sie die mysql_query() Funktion wieder in Anweisungen, die die ORDER BY-Klausel verwenden -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl ORDER BY product_manufacturer DESC'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Product ID :{$row['product_id']} <br> ".
         "Name: {$row['product_name']} <br> ". "Manufacturer: {$row['product_manufacturer']} <br> ".
         "Ship Date : {$row['ship_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

Nach erfolgreichem Datenabruf wird die folgende Ausgabe angezeigt:

Product ID: 12347
Nomenclature: Orbitron 1000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 67891
Nomenclature: Zoomzoom 5000
Manufacturer: QFT Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 56789
Nomenclature: SuperBlast 400
Manufacturer: LMN Corp
Ship Date: 01/04/17
----------------------------------------------
mysql> Fetched data successfully

In früheren Diskussionen und Beispielen haben wir das Abrufen aus einer einzelnen Tabelle oder das Abrufen mehrerer Werte aus mehreren Quellen untersucht. Die meisten realen Datenvorgänge sind viel komplexer und erfordern das Aggregieren, Vergleichen und Abrufen aus mehreren Tabellen.

JOINsErmöglichen das Zusammenführen von zwei oder mehr Tabellen zu einem einzelnen Objekt. Sie werden über die Anweisungen SELECT, UPDATE und DELETE verwendet.

Überprüfen Sie die allgemeine Syntax einer Anweisung mit einem JOIN wie unten gezeigt -

SELECT column
FROM table_name1
INNER JOIN table_name2
ON table_name1.column = table_name2.column;

Beachten Sie die alte Syntax für JOINS, die implizite Verknüpfungen und keine Schlüsselwörter verwendet. Es ist möglich, eine WHERE-Klausel zu verwenden, um einen Join zu erzielen. Schlüsselwörter eignen sich jedoch am besten für Lesbarkeit, Wartung und Best Practices.

JOINs gibt es in vielen Formen, z. B. als Left Join, Right Join oder Inner Join. Verschiedene Join-Typen bieten unterschiedliche Aggregationstypen basierend auf gemeinsamen Werten oder Merkmalen.

Setzen Sie einen JOIN entweder an der Eingabeaufforderung oder mit einem PHP-Skript ein.

Die Eingabeaufforderung

Verwenden Sie an der Eingabeaufforderung einfach eine Standardanweisung -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed

mysql> SELECT products.ID_number, products.Nomenclature, inventory.inventory_ct
   FROM products
   INNER JOIN inventory
   ON products.ID_numbeer = inventory.ID_number;
+-------------+----------------+-----------------+
| ID_number   | Nomenclature   | Inventory Count |
+-------------+----------------+-----------------+
| 12345       | Orbitron 4000  | 150             |
+-------------+----------------+-----------------+
| 12346       | Orbitron 3000  | 200             |
+-------------+----------------+-----------------+
| 12347       | Orbitron 1000  | 0               |
+-------------+----------------+-----------------+

PHP-Skript mit JOIN

Verwenden Sie die mysql_query() Funktion zum Ausführen einer Verknüpfungsoperation -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT a.product_id, a.product_manufacturer, b.product_count FROM products_tbl a, pcount_tbl b WHERE a.product_manufacturer = b.product_manufacturer'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Manufacturer:{$row['product_manufacturer']} <br> ".
         "Count: {$row['product_count']} <br> ". "Product ID: {$row['product_id']} <br> ".
         "--------------------------------<br>";
   }

   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Nach erfolgreichem Datenabruf wird die folgende Ausgabe angezeigt:

ID Number: 12345
Nomenclature: Orbitron 4000
Inventory Count: 150
--------------------------------------
ID Number: 12346
Nomenclature: Orbitron 3000
Inventory Count: 200
--------------------------------------
ID Number: 12347
Nomenclature: Orbitron 1000
Inventory Count: 0
--------------------------------------
mysql> Fetched data successfully

Denken Sie beim Arbeiten mit NULL-Werten daran, dass es sich um unbekannte Werte handelt. Sie sind keine leeren Zeichenfolgen oder Nullen, die gültige Werte sind. Bei der Tabellenerstellung können Spaltenspezifikationen festlegen, dass sie Nullwerte akzeptieren oder ablehnen. Verwenden Sie einfach eine NULL- oder NOT NULL-Klausel. Dies hat Anwendungen in Fällen von fehlenden Datensatzinformationen wie einer ID-Nummer.

Benutzerdefinierte Variablen haben bis zur expliziten Zuweisung den Wert NULL. Gespeicherte Routineparameter und lokale Variablen ermöglichen das Festlegen des Werts NULL. Wenn eine lokale Variable keinen Standardwert hat, hat sie den Wert NULL.

NULL unterscheidet nicht zwischen Groß- und Kleinschreibung und hat die folgenden Aliase:

• UNBEKANNT (ein boolescher Wert)
• \N

NULL-Operatoren

Standardvergleichsoperatoren können nicht mit NULL verwendet werden (z. B. =,>,> =, <=, <oder! =), Da alle Vergleiche mit einem NULL-Wert NULL zurückgeben, nicht wahr oder falsch. Vergleiche mit NULL oder möglicherweise mit NULL müssen den Operator "<=>" (NULL-SAFE) verwenden.

Andere verfügbare Betreiber sind -

• IS NULL - Testet auf einen NULL-Wert.

• IS NOT NULL - Bestätigt das Fehlen eines NULL-Werts.

• ISNULL - Gibt bei der Ermittlung eines NULL-Werts den Wert 1 und in Abwesenheit den Wert 0 zurück.

• COALESCE - Gibt den ersten Nicht-NULL-Wert einer Liste zurück oder gibt einen NULL-Wert zurück, wenn keiner vorhanden ist.

NULL-Werte sortieren

Bei Sortiervorgängen haben NULL-Werte den niedrigsten Wert, sodass die DESC-Reihenfolge unten zu NULL-Werten führt. Mit MariaDB können Sie einen höheren Wert für NULL-Werte festlegen.

Es gibt zwei Möglichkeiten, dies zu tun, wie unten gezeigt -

SELECT column1 FROM product_tbl ORDER BY ISNULL(column1), column1;

Der andere Weg -

SELECT column1 FROM product_tbl ORDER BY IF(column1 IS NULL, 0, 1), column1 DESC;

NULL-Funktionen

Funktionen geben im Allgemeinen NULL aus, wenn Parameter NULL sind. Es gibt jedoch Funktionen, die speziell für die Verwaltung von NULL-Werten entwickelt wurden. Sie sind -

• IFNULL()- Wenn der erste Ausdruck nicht NULL ist, wird er zurückgegeben. Wenn es als NULL ausgewertet wird, gibt es den zweiten Ausdruck zurück.

• NULLIF() - Es gibt NULL zurück, wenn die verglichenen Ausdrücke gleich sind. Wenn nicht, gibt es den ersten Ausdruck zurück.

Funktionen wie SUM und AVG ignorieren NULL-Werte.

NULL-Werte einfügen

Beim Einfügen eines NULL-Werts in eine als NOT NULL deklarierte Spalte tritt ein Fehler auf. Im Standard-SQL-Modus fügt eine NOT NULL-Spalte stattdessen einen Standardwert basierend auf dem Datentyp ein.

Wenn ein Feld ein TIMESTAMP, AUTO_INCREMENT oder eine virtuelle Spalte ist, verwaltet MariaDB NULL-Werte unterschiedlich. Das Einfügen in eine AUTO_INCREMENT-Spalte bewirkt, dass die nächste Nummer in der Sequenz an ihrer Stelle eingefügt wird. In einem TIMESTAMP-Feld weist MariaDB stattdessen den aktuellen Zeitstempel zu. In virtuellen Spalten, einem Thema, das später in diesem Lernprogramm behandelt wird, wird der Standardwert zugewiesen.

EINZIGARTIGE Indizes können viele NULL-Werte enthalten, Primärschlüssel können jedoch nicht NULL sein.

NULL-Werte und der Befehl Ändern

Wenn Sie den Befehl ALTER verwenden, um eine Spalte zu ändern, weist MariaDB ohne NULL-Angaben automatisch Werte zu.

Neben dem in LIKE-Klauseln verfügbaren Mustervergleich bietet MariaDB über den REGEXP-Operator einen auf regulären Ausdrücken basierenden Abgleich. Der Operator führt einen Mustervergleich für einen Zeichenfolgenausdruck basierend auf einem bestimmten Muster durch.

In MariaDB 10.0.5 wurden reguläre PCRE-Ausdrücke eingeführt, die den Umfang der Zuordnung zu Bereichen wie rekursiven Mustern, Vorausschau-Aussagen und vielem mehr erheblich erweitern.

Überprüfen Sie die Verwendung der unten angegebenen Standard-REGEXP-Operatorsyntax.

SELECT column FROM table_name WHERE column REGEXP '[PATTERN]';

REGEXP gibt 1 für eine Musterübereinstimmung oder 0 zurück, wenn keine vorhanden ist.

Eine Option für das Gegenteil besteht in Form von NOT REGEXP. MariaDB bietet auch Synonyme für REGEXP und NOT REGEXP, RLIKE und NOT RLIKE an, die aus Kompatibilitätsgründen erstellt wurden.

Das verglichene Muster kann eine Literalzeichenfolge oder etwas anderes wie eine Tabellenspalte sein. In Zeichenfolgen wird die C-Escape-Syntax verwendet, also verdoppeln Sie alle "\" - Zeichen. REGEXP unterscheidet auch nicht zwischen Groß- und Kleinschreibung, mit Ausnahme von Binärzeichenfolgen.

Eine Tabelle möglicher Muster, die verwendet werden können, ist unten angegeben -

Sr.Nr.	Muster & Beschreibung
1	^ Es entspricht dem Anfang der Zeichenfolge.
2	$ Es entspricht dem Ende der Zeichenfolge.
3	. Es entspricht einem einzelnen Zeichen.
4	[...] Es entspricht jedem Zeichen in den Klammern.
5	[^...] Es stimmt mit allen Zeichen überein, die nicht in den Klammern aufgeführt sind.
6	p1|p2|p3 Es entspricht einem der Muster.
7	* Es entspricht 0 oder mehr Instanzen des vorhergehenden Elements.
8	+ Es entspricht einer oder mehreren Instanzen des vorhergehenden Elements.
9	{n} Es entspricht n Instanzen des vorhergehenden Elements.
10	{m,n} Es werden m bis n Instanzen des vorhergehenden Elements abgeglichen.

Überprüfen Sie die unten angegebenen Mustervergleichsbeispiele -

Produkte beginnend mit "pr" -

SELECT name FROM product_tbl WHERE name REGEXP '^pr';

Produkte, die mit "na" enden -

SELECT name FROM product_tbl WHERE name REGEXP 'na$';

Produkte, die mit einem Vokal beginnen -

SELECT name FROM product_tbl WHERE name REGEXP '^[aeiou]';

Transaktionen sind sequentielle Gruppenoperationen. Sie fungieren als eine Einheit und werden erst beendet, wenn alle Vorgänge innerhalb der Gruppe erfolgreich ausgeführt wurden. Ein einzelner Fehler in der Gruppe führt dazu, dass die gesamte Transaktion fehlschlägt und keine Auswirkungen auf die Datenbank hat.

Transaktionen entsprechen ACID (Atomizität, Konsistenz, Isolierung und Haltbarkeit) -

• Atomicity - Es stellt den Erfolg aller Vorgänge sicher, indem Fehler abgebrochen und Änderungen rückgängig gemacht werden.

• Consistency - Es stellt sicher, dass die Datenbank Änderungen bei einer erfolgreichen Transaktion anwendet.

• Isolation - Es ermöglicht den unabhängigen Transaktionsbetrieb von Transaktionen.

• Durability - Es stellt die Persistenz einer erfolgreichen Transaktion im Falle eines Systemausfalls sicher.

Am Anfang einer Transaktionsanweisung steht die Anweisung START TRANSACTION, gefolgt von den Anweisungen COMMIT und ROLLBACK.

• START TRANSACTION startet die Transaktion.

• COMMIT speichert Änderungen an Daten.

• ROLLBACK beendet die Transaktion und zerstört alle Änderungen.

Bei einer erfolgreichen Transaktion handelt COMMIT. Bei einem Fehler handelt ROLLBACK.

Note- Einige Anweisungen verursachen ein implizites Commit und sie verursachen auch einen Fehler, wenn sie in Transaktionen verwendet werden. Beispiele für solche Anweisungen sind unter anderem CREATE, ALTER und DROP.

MariaDB-Transaktionen enthalten auch Optionen wie SAVEPOINT und LOCK TABLES. SAVEPOINT legt einen Wiederherstellungspunkt fest, der mit ROLLBACK verwendet werden soll. Mit LOCK TABLES können Sie den Zugriff auf Tabellen während Sitzungen steuern, um Änderungen in bestimmten Zeiträumen zu vermeiden.

Die Variable AUTOCOMMIT bietet Kontrolle über Transaktionen. Eine Einstellung von 1 erzwingt, dass alle Vorgänge als erfolgreiche Transaktionen betrachtet werden, und eine Einstellung von 0 bewirkt, dass Änderungen nur in einer expliziten COMMIT-Anweisung fortbestehen.

Struktur einer Transaktion

Die allgemeine Struktur einer Transaktionsanweisung besteht darin, mit START TRANSACTION zu beginnen. Der nächste Schritt besteht darin, einen oder mehrere Befehle / Operationen einzufügen, Anweisungen einzufügen, die auf Fehler prüfen, ROLLBACK-Anweisungen einzufügen, um erkannte Fehler zu verwalten, und schließlich eine COMMIT-Anweisung einzufügen, um Änderungen auf erfolgreiche Operationen anzuwenden.

Überprüfen Sie das folgende Beispiel -

START TRANSACTION;
SELECT name FROM products WHERE manufacturer = 'XYZ Corp';
UPDATE spring_products SET item = name;
COMMIT;

Der Befehl ALTER bietet eine Möglichkeit, die Struktur einer vorhandenen Tabelle zu ändern. Dies bedeutet Änderungen wie das Entfernen oder Hinzufügen von Spalten, das Ändern von Indizes, das Ändern von Datentypen oder das Ändern von Namen. ALTER wartet auch darauf, Änderungen zu übernehmen, wenn eine Metadatensperre aktiv ist.

Verwenden von ALTER zum Ändern von Spalten

ALTER gepaart mit DROP entfernt eine vorhandene Spalte. Es schlägt jedoch fehl, wenn die Spalte die einzige verbleibende Spalte ist.

Überprüfen Sie das folgende Beispiel -

mysql> ALTER TABLE products_tbl DROP version_num;

Verwenden Sie eine ALTER ... ADD-Anweisung, um Spalten hinzuzufügen -

mysql> ALTER TABLE products_tbl ADD discontinued CHAR(1);

Verwenden Sie die Schlüsselwörter FIRST und AFTER, um die Platzierung der Spalte festzulegen.

ALTER TABLE products_tbl ADD discontinued CHAR(1) FIRST;
ALTER TABLE products_tbl ADD discontinued CHAR(1) AFTER quantity;

Beachten Sie, dass die Schlüsselwörter FIRST und AFTER nur für ALTER ... ADD-Anweisungen gelten. Außerdem müssen Sie eine Tabelle löschen und dann hinzufügen, um sie neu zu positionieren.

Ändern Sie eine Spaltendefinition oder einen Spaltennamen mithilfe der Klausel MODIFY oder CHANGE in einer ALTER-Anweisung. Die Klauseln haben ähnliche Auswirkungen, verwenden jedoch eine wesentlich andere Syntax.

Sehen Sie sich das unten angegebene CHANGE-Beispiel an -

mysql> ALTER TABLE products_tbl CHANGE discontinued status CHAR(4);

Geben Sie in einer Anweisung mit CHANGE die ursprüngliche Spalte und dann die neue Spalte an, die sie ersetzen soll. Sehen Sie sich unten ein MODIFY-Beispiel an -

mysql> ALTER TABLE products_tbl MODIFY discontinued CHAR(4);

Mit dem Befehl ALTER können auch Standardwerte geändert werden. Überprüfen Sie ein Beispiel -

mysql> ALTER TABLE products_tbl ALTER discontinued SET DEFAULT N;

Sie können es auch verwenden, um Standardeinschränkungen zu entfernen, indem Sie es mit einer DROP-Klausel koppeln.

mysql> ALTER TABLE products_tbl ALTER discontinued DROP DEFAULT;

Verwenden von ALTER zum Ändern von Tabellen

Ändern Sie den Tabellentyp mit der TYPE-Klausel -

mysql> ALTER TABLE products_tbl TYPE = INNODB;

Benennen Sie eine Tabelle mit dem Schlüsselwort RENAME um -

mysql> ALTER TABLE products_tbl RENAME TO products2016_tbl;

Indizes sind Werkzeuge zur Beschleunigung des Abrufs von Datensätzen. Ein Index erzeugt einen Eintrag für jeden Wert in einer indizierten Spalte.

Es gibt vier Arten von Indizes:

• Primary (Ein Datensatz repräsentiert alle Datensätze)

• Unique (Ein Datensatz repräsentiert mehrere Datensätze)

• Plain

• Full-Text (Ermöglicht viele Optionen bei der Textsuche).

Die Begriffe "Schlüssel" und "Index" sind in dieser Verwendung identisch.

Indizes, die einer oder mehreren Spalten zugeordnet sind, unterstützen eine schnelle Suche und eine effiziente Datensatzorganisation. Berücksichtigen Sie beim Erstellen eines Index, welche Spalten in Ihren Abfragen häufig verwendet werden. Erstellen Sie dann einen oder mehrere Indizes. Zeigen Sie Indizes außerdem als Tabellen mit Primärschlüsseln an.

Indizes beschleunigen zwar die Suche oder SELECT-Anweisungen, führen jedoch zu Verzögerungen beim Einfügen und Aktualisieren, da die Operationen sowohl für die Tabellen als auch für die Indizes ausgeführt werden.

Erstellen Sie einen Index

Sie können einen Index über eine Anweisung CREATE TABLE ... INDEX oder eine Anweisung CREATE INDEX erstellen. Die beste Option, die Lesbarkeit, Wartung und Best Practices unterstützt, ist CREATE INDEX.

Überprüfen Sie die unten angegebene allgemeine Syntax des Index -

CREATE [UNIQUE or FULLTEXT or...] INDEX index_name ON table_name column;

Überprüfen Sie ein Beispiel für seine Verwendung -

CREATE UNIQUE INDEX top_sellers ON products_tbl product;

Löschen Sie einen Index

Sie können einen Index mit DROP INDEX oder ALTER TABLE ... DROP löschen. Die beste Option zur Unterstützung von Lesbarkeit, Wartung und Best Practices ist DROP INDEX.

Überprüfen Sie die unten angegebene allgemeine Syntax von Drop Index -

DROP INDEX index_name ON table_name;

Überprüfen Sie ein Beispiel für seine Verwendung -

DROP INDEX top_sellers ON product_tbl;

Benennen Sie einen Index um

Benennen Sie einen Index mit der Anweisung ALTER TABLE um. Überprüfen Sie die unten angegebene allgemeine Syntax -

ALTER TABLE table_name DROP INDEX index_name, ADD INDEX new_index_name;

Überprüfen Sie ein Beispiel für seine Verwendung -

ALTER TABLE products_tbl DROP INDEX top_sellers, ADD INDEX top_2016sellers;

Verwalten von Indizes

Sie müssen alle Indizes untersuchen und verfolgen. Verwenden Sie SHOW INDEX, um alle vorhandenen Indizes aufzulisten, die einer bestimmten Tabelle zugeordnet sind. Sie können das Format des angezeigten Inhalts mithilfe einer Option wie "\ G" festlegen, die ein vertikales Format angibt.

Überprüfen Sie das folgende Beispiel -

mysql > SHOW INDEX FROM products_tbl\G

Tabellenstatistik

Indizes werden häufig verwendet, um Abfragen zu optimieren, da der Zugriff auf Datensätze und die bereitgestellten Statistiken schneller sind. Viele Benutzer empfinden die Indexpflege jedoch als umständlich. MariaDB 10.0 stellte speichermaschinenunabhängige Statistiktabellen zur Verfügung, in denen Datenstatistiken für jede Tabelle in jeder Speichermaschine und sogar Statistiken für nicht indizierte Spalten berechnet werden.

Einige Vorgänge können aufgrund der Geschwindigkeit oder der verfügbaren Daten von temporären Tabellen profitieren. Die Lebensdauer einer temporären Tabelle endet mit dem Beenden einer Sitzung, unabhängig davon, ob Sie sie an der Eingabeaufforderung, mit einem PHP-Skript oder über ein Client-Programm verwenden. Es erscheint auch nicht in typischer Weise im System. Der Befehl SHOW TABLES zeigt keine Liste mit temporären Tabellen an.

Erstellen Sie eine temporäre Tabelle

Das Schlüsselwort TEMPORARY in einer Anweisung CREATE TABLE erzeugt eine temporäre Tabelle. Überprüfen Sie ein Beispiel unten -

mysql>CREATE TEMPORARY TABLE order (
   item_name VARCHAR(50) NOT NULL
   , price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   , quantity INT UNSIGNED NOT NULL DEFAULT 0
);

Beim Erstellen einer temporären Tabelle können Sie vorhandene Tabellen mit der LIKE-Klausel klonen, dh alle ihre allgemeinen Merkmale. Die Anweisung CREATE TABLE, mit der die temporäre Tabelle erzeugt wird, schreibt aufgrund des Schlüsselworts TEMPORARY keine Transaktionen fest.

Temporäre Tabellen unterscheiden sich zwar von nicht temporären Tabellen und werden am Ende einer Sitzung gelöscht. Sie können jedoch bestimmte Konflikte aufweisen.

• Sie stehen manchmal in Konflikt mit temporären Ghost-Tabellen aus abgelaufenen Sitzungen.

• Sie stehen manchmal in Konflikt mit Schattennamen nicht temporärer Tabellen.

Note - Temporäre Tabellen dürfen denselben Namen wie eine vorhandene nicht temporäre Tabelle haben, da MariaDB diese als Differenzreferenz betrachtet.

Verwaltung

Für MariaDB müssen Benutzern Berechtigungen zum Erstellen temporärer Tabellen gewährt werden. Verwenden Sie eine GRANT-Anweisung, um Nicht-Administratoren dieses Privileg zu erteilen.

GRANT CREATE TEMPORARY TABLES ON orders TO 'machine122'@'localhost';

Löschen Sie eine temporäre Tabelle

Obwohl temporäre Tabellen am Ende von Sitzungen im Wesentlichen entfernt werden, haben Sie die Möglichkeit, sie zu löschen. Das Löschen einer temporären Tabelle erfordert die Verwendung des Schlüsselworts TEMPORARY. Best Practices empfehlen, temporäre Tabellen vor nicht temporären Tabellen zu löschen.

mysql> DROP TABLE order;

In einigen Situationen muss eine exakte Kopie einer vorhandenen Tabelle erstellt werden. Die Anweisung CREATE ... SELECT kann diese Ausgabe nicht erzeugen, da sie Dinge wie Indizes und Standardwerte vernachlässigt.

Das Verfahren zum Duplizieren einer Tabelle lautet wie folgt:

• Verwenden Sie SHOW CREATE TABLE, um eine CREATE TABLE-Anweisung zu erstellen, die die gesamte Struktur der Quelltabelle detailliert beschreibt.

• Bearbeiten Sie die Anweisung, um der Tabelle einen neuen Namen zu geben, und führen Sie sie aus.

• Verwenden Sie eine INSERT INTO ... SELECT-Anweisung, wenn Sie auch die Tabellendaten kopieren müssen.

mysql> INSERT INTO inventory_copy_tbl (
   product_id,product_name,product_manufacturer,ship_date)
   
   SELECT product_id,product_name,product_manufacturer,ship_date,
   FROM inventory_tbl;

Eine andere Methode zum Erstellen eines Duplikats verwendet eine CREATE TABLE AS-Anweisung. Die Anweisung kopiert alle Spalten und Spaltendefinitionen und füllt die Kopie mit den Daten der Quelltabelle.

Überprüfen Sie die unten angegebene Syntax -

CREATE TABLE clone_tbl AS
   SELECT columns
   FROM original_tbl
   WHERE conditions];

Sehen Sie sich unten ein Beispiel für seine Verwendung an -

CREATE TABLE products_copy_tbl AS
   SELECT *
   FROM products_tbl;

In Version 10.0.3 hat MariaDB eine als Sequenz bekannte Speicher-Engine eingeführt. Sein Ad-hoc-Vorgang generiert eine ganzzahlige Sequenz für Operationen und wird dann beendet. Die Sequenz enthält positive Ganzzahlen in absteigender oder aufsteigender Reihenfolge und verwendet einen Start-, End- und Inkrementwert.

Die Verwendung in mehreren Abfragen ist aufgrund seiner virtuellen (nicht auf die Festplatte geschriebenen) Natur nur in der ursprünglichen Abfrage nicht zulässig. Sequenztabellen können jedoch über einen ALTER-Befehl in Standardtabellen konvertiert werden. Wenn eine konvertierte Tabelle gelöscht wird, ist die Sequenztabelle weiterhin vorhanden. Sequenzen können auch keine negativen Zahlen erzeugen oder sich im Minimum / Maximum drehen.

Installieren der Sequence Engine

Für die Verwendung von Sequenzen muss die Sequenz-Engine installiert werden, die MariaDB als Plugin und nicht als Binärdatei verteilt. Installieren Sie es mit dem folgenden Befehl:

INSTALL SONAME "ha_sequence";

Überprüfen Sie es nach der Installation -

SHOW ENGINES\G

Denken Sie daran, dass Sie nach der Installation der Engine keine Standardtabelle mit einem Namen erstellen können, der Sequenzsyntax verwendet. Sie können jedoch eine temporäre Tabelle mit einem Sequenzsyntaxnamen erstellen.

Sequenz erstellen

Es gibt zwei Methoden zur Sequenzerstellung:

• Erstellen Sie eine Tabelle und definieren Sie mit dem Attribut AUTO_INCREMENT eine Spalte als automatische Inkrementierung.

• Verwenden Sie eine vorhandene Datenbank und eine Sequenz-SELECT-Abfrage, um eine Sequenz zu erstellen. Die Abfrage verwendet die Syntax seq_ [FROM] _to_ [TO] oder seq_ [FROM] _to_ [TO] _step_STEP.

Best Practices bevorzugen die Verwendung der zweiten Methode. Sehen Sie sich ein Beispiel für eine Sequenzerstellung an -

SELECT * FROM seq_77_to_99;

Sequenzen haben viele Verwendungszwecke -

• Suchen Sie fehlende Werte in einer Spalte, um sich vor verwandten Problemen im Betrieb zu schützen.

SELECT myseq.seq FROM seq_22_to_28 myseq LEFT JOIN table1 t ON myseq.seq
   = x.y WHERE x.y IS NULL;

• Konstruieren Sie eine Kombination von Werten -

SELECT x1.seq, x2.seq FROM seq_5_to_9 x1 JOIN seq_5_to_9 x2 ORDER BY 5, 6;

• Finden Sie Vielfache einer Zahl -

SELECT seq FROM seq_3_to_100_step_4;

• Erstellen Sie eine Datumsreihenfolge für Anwendungen wie Buchungssysteme.
• Konstruieren Sie eine Zeitsequenz.

Wie in früheren Lektionen erläutert, ermöglicht MariaDB in einigen Situationen doppelte Datensätze und Tabellen. Einige dieser Duplikate sind aufgrund unterschiedlicher Daten oder Objekttypen oder aufgrund einer eindeutigen Lebensdauer oder Speicherung des Operationsobjekts keine Duplikate. Diese Duplikate stellen typischerweise auch keine Probleme dar.

In einigen Situationen verursachen Duplikate Probleme und treten häufig aufgrund impliziter Aktionen oder der milderen Richtlinie eines MariaDB-Befehls auf. Es gibt Möglichkeiten, dieses Problem zu kontrollieren, Duplikate zu finden, Duplikate zu löschen und die Erstellung von Duplikaten zu verhindern.

Strategien und Tools

Es gibt vier wichtige Möglichkeiten, um Duplikate zu verwalten:

• Fischen Sie mit JOIN nach ihnen und löschen Sie sie mit einer temporären Tabelle.

• Verwenden Sie INSERT ... ON DUPLICATE KEY UPDATE, um bei Entdeckung eines Duplikats zu aktualisieren.

• Verwenden Sie DISTINCT, um die Ergebnisse einer SELECT-Anweisung zu bereinigen und Duplikate zu entfernen.

• Verwenden Sie INSERT IGNORE, um das Einfügen von Duplikaten zu stoppen.

Verwenden von Join mit einer temporären Tabelle

Führen Sie einfach einen Semi-Join wie einen inneren Join durch und entfernen Sie dann die mit einer temporären Tabelle gefundenen Duplikate.

INSERT verwenden

Wenn INSERT ... ON DUPLICATE KEY UPDATE einen doppelten eindeutigen oder Primärschlüssel entdeckt, führt es eine Aktualisierung durch. Bei der Erkennung mehrerer eindeutiger Schlüssel wird nur der erste aktualisiert. Verwenden Sie es daher nicht für Tabellen mit mehreren eindeutigen Indizes.

Sehen Sie sich das folgende Beispiel an, das zeigt, was in einer Tabelle mit indizierten Werten beim Einfügen in ein ausgefülltes Feld passiert.

INSERT INTO add_dupl VALUES (1,'Apple');
ERROR 1062 (23000): Duplicate entry '1' for key 'PRIMARY'

Note - Wenn kein Schlüssel gefunden wird, wird eine Anweisung INSERT ... ON DUPLICATE KEY UPDATE wie eine normale Anweisung insert ausgeführt.

Verwenden von DISTINCT

DISTINCT-Klauseln entfernen Duplikate aus den Ergebnissen. Die allgemeine Syntax für eine DISTINCT-Klausel lautet wie folgt:

SELECT DISTINCT fields
FROM table
[WHERE conditions];

Note - Die Ergebnisse einer Anweisung mit einer DISTINCT-Klausel -

• Bei Verwendung eines Ausdrucks werden eindeutige Werte zurückgegeben.

• Bei Verwendung mehrerer Ausdrücke werden eindeutige Kombinationen zurückgegeben.

• NULL-Werte werden nicht ignoriert. Daher enthalten die Ergebnisse auch NULL-Werte als eindeutige Werte.

Überprüfen Sie die folgende Anweisung mit einer DISTINCT-Klausel für einen einzelnen Ausdruck:

SELECT DISTINCT product_id
FROM products
WHERE product_name = 'DustBlaster 5000';

Überprüfen Sie das folgende Beispiel mit mehreren Ausdrücken:

SELECT DISTINCT product_name, product_id
FROM products
WHERE product_id < 30

Verwenden von INSERT IGNORE

Eine INSERT IGNORE-Anweisung weist MariaDB an, das Einfügen abzubrechen, wenn ein doppelter Datensatz entdeckt wird. Überprüfen Sie ein Beispiel für seine Verwendung unten -

mysql> INSERT IGNORE INTO customer_tbl (LN, FN)
   VALUES( 'Lex', 'Luther');

Beachten Sie auch die Logik hinter Duplikaten. Einige Tabellen erfordern Duplikate, die auf der Art dieser Tabellendaten basieren. Berücksichtigen Sie diese Anforderungen in Ihrer Strategie zur Verwaltung doppelter Datensätze.

Das einfache Akzeptieren von Benutzereingaben öffnet die Tür zu Exploits. Das Problem ergibt sich hauptsächlich aus der logischen Verwaltung von Daten, aber zum Glück ist es ziemlich einfach, diese Hauptfehler zu vermeiden.

Möglichkeiten zur SQL-Injection treten normalerweise auf, wenn Benutzer Daten wie einen Namen eingeben und die Codelogik diese Eingabe nicht analysiert. Der Code ermöglicht es einem Angreifer stattdessen, eine MariaDB-Anweisung einzufügen, die in der Datenbank ausgeführt wird.

Berücksichtigen Sie immer die von Benutzern eingegebenen Daten, verdächtigen Sie und benötigen Sie vor jeder Verarbeitung eine gründliche Validierung. Führen Sie diese Validierung durch Mustervergleich durch. Wenn die erwartete Eingabe beispielsweise ein Benutzername ist, beschränken Sie die eingegebenen Zeichen auf alphanumerische Zeichen und Unterstriche sowie auf eine bestimmte Länge. Überprüfen Sie ein Beispiel unten -

if(check_match("/^\w{8,20}$/", $_GET['user_name'], $matches)) {
   $result = mysql_query("SELECT * FROM system_users WHERE user_name = $matches[0]");
} else {
   echo "Invalid username";
}

Verwenden Sie außerdem den REGEXP-Operator und die LIKE-Klauseln, um Eingabeeinschränkungen zu erstellen.

Berücksichtigen Sie alle Arten der erforderlichen expliziten Steuerung der Eingabe, z.

• Steuern Sie die verwendeten Escapezeichen.

• Steuern Sie die spezifischen geeigneten Datentypen für die Eingabe. Beschränken Sie die Eingabe auf den erforderlichen Datentyp und die erforderliche Größe.

• Steuern Sie die Syntax der eingegebenen Daten. Lassen Sie nichts außerhalb des benötigten Musters zu.

• Kontrollieren Sie die zulässigen Bedingungen. Blacklist SQL-Schlüsselwörter.

Möglicherweise kennen Sie die Gefahren von Injektionsangriffen nicht oder halten sie für unbedeutend, sie stehen jedoch ganz oben auf der Liste der Sicherheitsbedenken. Berücksichtigen Sie außerdem die Auswirkungen dieser beiden Einträge -

1=1
-or-
*

Code, mit dem einer der beiden zusammen mit dem richtigen Befehl eingegeben werden kann, kann dazu führen, dass alle Benutzerdaten in der Datenbank angezeigt oder alle Daten in der Datenbank gelöscht werden. Keine der beiden Injektionen ist besonders clever. In einigen Fällen verbringen Angreifer nicht einmal Zeit damit, Löcher zu untersuchen. Sie führen blinde Angriffe mit einfachen Eingaben durch.

Berücksichtigen Sie auch die Tools für Mustervergleich und reguläre Ausdrücke, die von jeder mit MariaDB gepaarten Programmier- / Skriptsprache bereitgestellt werden und mehr Kontrolle und manchmal bessere Kontrolle bieten.

Daten dienen als Grundlage für Geschäft und Betrieb. Angesichts verschiedener möglicher Bedrohungen (z. B. Angreifer, Systemfehler, fehlerhafte Upgrades und Wartungsfehler) bleiben Sicherungen von entscheidender Bedeutung. Diese Sicherungen haben viele Formen, und es gibt viele Optionen, um sie mit einer noch größeren Anzahl von Optionen innerhalb dieser Prozesse zu erstellen. Die wichtigsten Dinge, an die Sie sich erinnern sollten, sind der Datenbanktyp, die kritischen Informationen und die Struktur. Diese Informationen bestimmen Ihre beste Option.

OPTIONEN

Die Hauptoptionen für Sicherungen umfassen logische Sicherungen und physische Sicherungen. Logische Sicherungen enthalten SQL-Anweisungen zum Wiederherstellen von Daten. Physische Sicherungen enthalten Kopien von Daten.

• Logical backupsbieten die Flexibilität, Daten auf einem anderen Computer mit einer anderen Konfiguration wiederherzustellen, im Gegensatz zu physischen Sicherungen, die häufig auf denselben Computer und Datenbanktyp beschränkt sind. Logische Sicherungen werden auf Datenbank- und Tabellenebene und physische auf Verzeichnis- und Dateiebene durchgeführt.

• Physical backupssind kleiner als logisch und benötigen weniger Zeit für die Durchführung und Wiederherstellung. Physische Sicherungen enthalten auch Protokoll- und Konfigurationsdateien, logische Sicherungen jedoch nicht.

Sicherungswerkzeuge

Das Hauptwerkzeug für MariaDB-Backups ist mysqldump. Es bietet logische Backups und Flexibilität. Es ist auch eine hervorragende Option für kleine Datenbanken.Mysqldumpspeichert Daten in SQL, CSV, XML und vielen anderen Formaten. Die Ausgabe speichert keine gespeicherten Prozeduren, Ansichten und Ereignisse ohne ausdrückliche Anweisung.

Es gibt drei Möglichkeiten für mysqldump Backups -

• Raw data - Speichern Sie eine Tabelle als Rohdatendatei über die Option --tab, die auch das Ziel der Datei angibt. -

$ mysqldump -u root -p --no-create-info \
   --tab=/tmp PRODUCTS products_tbl

• Data/Definitions export- Diese Option ermöglicht den Export einer einzelnen oder mehrerer Tabellen in eine Datei und unterstützt das Sichern aller vorhandenen Datenbanken auf dem Hostcomputer. Sehen Sie sich ein Beispiel für den Export von Inhalten oder Definitionen in eine Datei an

$ mysqldump -u root -p PRODUCTS products_tbl > export_file.txt

• Transfer - Sie können Datenbanken und Tabellen auch auf einem anderen Host ausgeben

$ mysqldump -u root -p database_name \
   | mysql -h other-host.com database_name

Verwenden der Anweisung THE SELECT ... INTO OUTFILE

Eine weitere Option zum Exportieren von Daten verwendet die Anweisung SELECT ... INTO OUTFILE. Diese einfache Option gibt die Tabelle in eine einfach formatierte Textdatei aus -

mysql> SELECT * FROM products_tbl
   -> INTO OUTFILE '/tmp/products.txt';

Seine Attribute ermöglichen das Formatieren der Datei gemäß Ihren bevorzugten Spezifikationen.

Beachten Sie die folgenden Eigenschaften dieser Aussage:

• Der Dateiname muss Ihren gewünschten Speicherort für die Ausgabe angeben.

• Sie benötigen MariaDB-Dateiberechtigungen, um die Anweisung auszuführen.

• Der Name der Ausgabedatei muss eindeutig sein.

• Sie benötigen Anmeldeinformationen auf dem Host.

• In einer UNIX-Umgebung ist die Ausgabedatei weltweit lesbar, aber ihr Serverbesitz wirkt sich auf Ihre Fähigkeit aus, sie zu löschen. Stellen Sie sicher, dass Sie über Berechtigungen verfügen.

Verwenden von CONNECT in Backups

Der CONNECT-Handler ermöglicht den Export von Daten. Dies erweist sich vor allem in Situationen als nützlich, in denen der Vorgang SELECT ... INTO OUTFILE das Dateiformat nicht unterstützt.

Überprüfen Sie das folgende Beispiel -

create table products
engine = CONNECT table_type = XML file_name = 'products.htm' header = yes
option_list = 'name = TABLE,coltype = HTML,attribute = border = 1;cellpadding = 5'

select plugin_name handler, plugin_version version, plugin_author
author, plugin_description description, plugin_maturity maturity
from information_schema.plugins where plugin_type = 'STORAGE ENGINE';

Andere Werkzeuge

Weitere Optionen für Backups sind:

• XtraBackup- Diese Option zielt auf XtraDB / InnoDB-Datenbanken ab und funktioniert mit jeder Speicher-Engine. Weitere Informationen zu diesem Tool finden Sie auf der offiziellen Website von Percona.

• Snapshots- Einige Dateisysteme erlauben Schnappschüsse. Der Prozess besteht aus dem Leeren der Tabellen mit Lesesperre, dem Mounten des Snapshots, dem Entsperren der Tabellen, dem Kopieren des Snapshots und dem anschließenden Aushängen des Snapshots.

• LVM- Diese beliebte Methode verwendet ein Perl-Skript. Es erhält eine Lesesperre für jede Tabelle und leert die Caches auf die Festplatte. Dann erhält es einen Schnappschuss und entsperrt die Tabellen. Wenden Sie sich an den Beamtenmylvmbackup Website für weitere Informationen.

• TokuBackup- Diese von Percona bereitgestellte Lösung bietet Hot-Backups unter Berücksichtigung der Probleme und Einschränkungen der InnoDB-Backup-Optionen. Es wird eine Transaktions-Soundkopie von Dateien erstellt, während Anwendungen diese weiterhin bearbeiten. Weitere Informationen finden Sie auf der Percona-Website.

INNODB Überlegungen

InnoDB verwendet einen Pufferpool zur Leistungssteigerung. Konfigurieren Sie InnoDB in einer Sicherung so, dass das Kopieren einer gesamten Tabelle in den Pufferpool vermieden wird, da logische Sicherungen normalerweise vollständige Tabellenscans durchführen.

In diesem Kapitel lernen wir verschiedene Methoden zum Laden von Backups kennen. Das Wiederherstellen einer Datenbank aus einer Sicherung ist ein einfacher und manchmal furchtbar langer Prozess.

Beim Laden von Daten gibt es drei Optionen: die Anweisung LOAD DATA, mysqlimport und eine einfache Wiederherstellung von mysqldump.

LOAD DATA verwenden

Die LOAD DATA-Anweisung fungiert als Bulk Loader. Sehen Sie sich ein Beispiel für die Verwendung an, mit dem eine Textdatei geladen wird.

mysql> LOAD DATA LOCAL INFILE 'products_copy.txt' INTO TABLE empty_tbl;

Beachten Sie die folgenden Eigenschaften einer LOAD DATA-Anweisung:

• Verwenden Sie das Schlüsselwort LOCAL, um zu verhindern, dass MariaDB den Host gründlich durchsucht, und verwenden Sie einen ganz bestimmten Pfad.

• Die Anweisung nimmt ein Format an, das aus durch Zeilenvorschübe (Zeilenumbrüche) abgeschlossenen Zeilen und durch Tabulatoren getrennten Datenwerten besteht.

• Verwenden Sie die FIELDS-Klausel, um die Formatierung von Feldern in einer Zeile explizit anzugeben. Verwenden Sie die LINES-Klausel, um das Zeilenende anzugeben. Sehen Sie sich unten ein Beispiel an.

mysql> LOAD DATA LOCAL INFILE 'products_copy.txt' INTO TABLE empty_tbl
   FIELDS TERMINATED BY '|'
   LINES TERMINATED BY '\n';

• Die Anweisung geht davon aus, dass Spalten in der Datendatei dieselbe Reihenfolge der Tabelle verwenden. Wenn Sie eine andere Reihenfolge festlegen müssen, können Sie die Datei wie folgt laden:

mysql> LOAD DATA LOCAL INFILE 'products_copy.txt' INTO TABLE empty_tbl (c, b, a);

Verwenden von MYSQLIMPORT

Das mysqlimport-Tool fungiert als LOAD DATA-Wrapper, der dieselben Vorgänge über die Befehlszeile ermöglicht.

Laden Sie die Daten wie folgt -

$ mysqlimport -u root -p --local database_name source_file.txt

Geben Sie die Formatierung wie folgt an:

$ mysqlimport -u root -p --local --fields-terminated-by="|" \
   --lines-terminated-by="\n" database_name source_file.txt

Verwenden Sie die -columns Option zur Angabe der Spaltenreihenfolge -

$ mysqlimport -u root -p --local --columns=c,b,a \
   database_name source_file.txt

Verwenden von MYSQLDUMP

Wiederherstellen mit mysqldump erfordert diese einfache Anweisung zum Laden der Dump-Datei zurück in den Host -

shell> mysql database_name < source_file.sql

BESONDERE ZEICHEN UND ZITATE

In einer LOAD DATA-Anweisung werden Anführungszeichen und Sonderzeichen möglicherweise nicht richtig interpretiert. Die Anweisung nimmt nicht in Anführungszeichen gesetzte Werte an und behandelt Backslashes als Escapezeichen. Verwenden Sie die FIELDS-Klausel, um die Formatierung festzulegen. Zeigen Sie mit „ENCLOSED BY“ auf Anführungszeichen, wodurch Anführungszeichen von Datenwerten entfernt werden. Änderungen werden mit "ESCAPED BY" beendet.

Dieses Kapitel enthält eine Liste der am häufigsten verwendeten Funktionen mit Definitionen, Erklärungen und Beispielen.

MariaDB-Aggregatfunktionen

Die am häufigsten verwendeten Aggregatfunktionen sind unten angegeben -

Sr.Nr.	Name & Beschreibung
1	COUNT Es zählt die Anzahl der Datensätze. Example - SELECT COUNT (*) FROM customer_table;
2	MIN Es zeigt den Mindestwert einer Reihe von Datensätzen an. Example - SELECT Organisation, MIN (Konto) FROM Verträge GROUP BY Organisation;
3	MAX Es zeigt den Maximalwert einer Reihe von Datensätzen an. Example - SELECT Organisation, MAX (account_size) FROM Verträge GROUP BY Organisation;
4	AVG Es berechnet den Durchschnittswert einer Reihe von Datensätzen. Example - SELECT AVG (account_size) FROM Verträge;
5	SUM Es berechnet die Summe einer Reihe von Datensätzen. Example - SELECT SUM (account_size) FROM Verträge;

MariaDB Altersberechnung

Das TIMESTAMPDIFF Funktion bietet eine Möglichkeit zur Berechnung des Alters -

SELECT CURDATE() AS today;
SELECT ID, DOB, TIMESTAMPDIFF(YEAR,DOB,'2015-07-01') AS age FROM officer_info;

MariaDB-String-Verkettung

Das CONCATDie Funktion gibt die resultierende Zeichenfolge nach einer Verkettungsoperation zurück. Sie können ein oder mehrere Argumente verwenden. Überprüfen Sie die unten angegebene Syntax -

SELECT CONCAT(item, item,...);

Überprüfen Sie das folgende Beispiel -

SELECT CONCAT('Ram', 'bu', 'tan');
Output:Rambutan

MariaDB Datums- / Zeitfunktionen

Nachstehend sind wichtige Datumsfunktionen aufgeführt -

Sr.Nr.	Name & Beschreibung
1	CURDATE() Das Datum wird im Format JJJJ-MM-TT oder JJJJMMTT zurückgegeben. Example - CURDATE AUSWÄHLEN ();
2	DATE() Es gibt das Datum in mehreren Formaten zurück. Example −CREATE TABLE product_release_tbl (x DATE);
3	CURTIME() Es gibt die Zeit im Format HH: MM: SS oder HHMMSS.uuuuuu zurück. Example - CURTIME AUSWÄHLEN ();
4	DATE_SUB() Es addiert oder subtrahiert eine Anzahl von Tagen vom angegebenen Datum. Example - SELECT DATE_SUB ('2016-02-08', INTERVALL 60 TAGE);
5	DATEDIFF() Es bestimmt die Tage zwischen zwei Daten. Example - SELECT DATEDIFF ('2016-01-01 23:59:59', '2016-01-03');
6	DATE ADD() Es addiert oder subtrahiert jede Zeiteinheit zu / von Datum und Uhrzeit. Example - SELECT DATE_ADD ('2016-01-04 23:59:59', INTERVALL 22 SEKUNDEN);
7	EXTRACT() Es extrahiert eine Einheit aus dem Datum. Example - AUSZUG AUSWÄHLEN (JAHR AB '2016-01-08');
8	NOW() Es gibt das aktuelle Datum und die aktuelle Uhrzeit entweder im Format JJJJ-MM-TT HH: MM: SS oder JJJJMMTHHMMS.Uuuuuu zurück. Example - JETZT AUSWÄHLEN ();
9	DATE FORMAT() Es formatiert das Datum gemäß der angegebenen Formatzeichenfolge. Example - SELECT DATE_FORMAT ('2016-01-09 20:20:00', '% W% M% Y');

Es folgen einige wichtige Zeitfunktionen -

Sr.Nr.	Name & Beschreibung
1	HOUR() Es gibt die Stunde der Zeit oder die verstrichenen Stunden zurück. Example - STUNDE AUSWÄHLEN ('19: 17: 09 ');
2	LOCALTIME() Es funktioniert genau wie NOW ().
3	MICROSECOND() Es gibt die Mikrosekunden der Zeit zurück. Example - MICROSECOND AUSWÄHLEN ('16: 30: 00.543876 ');
4	MINUTE() Es gibt die Minuten der Zeit zurück. Example - SELECT MINUTE ('2016-05-22 17:22:01');
5	SECOND() Es gibt die Sekunden des Datums zurück. Example - SELECT SECOND ('2016-03-12 16: 30: 04.000001');
6	TIME_FORMAT() Es formatiert die Zeit gemäß der angegebenen Formatzeichenfolge. Example - SELECT TIME_FORMAT ('22: 02: 20 ','% H% k% h% I% l ');
7	TIMESTAMP() Es bietet einen Zeitstempel für eine Aktivität im Format JJJJ-MM-TT HH: MM: TT. Example - CREATE TABLE orders_ (ID INT, tmst TIMESTAMP);

MariaDB Numerische Funktionen

Im Folgenden sind einige wichtige numerische Funktionen in MariaDB aufgeführt -

Sr.Nr.	Name & Beschreibung
1	TRUNCATE() Es wird eine abgeschnittene Zahl zur Dezimalstellenangabe zurückgegeben. Example - TRUNCATE AUSWÄHLEN (101.222, 1);
2	COS() Es gibt den Kosinus von x Bogenmaß zurück. Example - COS AUSWÄHLEN (PI ());
3	CEILING() Es wird die kleinste Ganzzahl zurückgegeben, die nicht unter x liegt. Example - DECKE AUSWÄHLEN (2.11);
4	DEGREES() Es wandelt Bogenmaß in Grad um. Example - GRAD AUSWÄHLEN (PI ());
5	DIV() Es führt eine Ganzzahldivision durch. Example - 100 DIV 4 AUSWÄHLEN;
6	EXP() Es kehrt e zur Potenz von x zurück. Example - EXP (2) AUSWÄHLEN;
7	FLOOR() Es wird die größte Ganzzahl zurückgegeben, die nicht über x liegt. Example - BODEN AUSWÄHLEN (2.01);
8	LN() Es gibt den natürlichen Logarithmus von x zurück. Example - SELECT LN (3);
9	LOG() Es gibt den natürlichen Logarithmus oder den Logarithmus an eine bestimmte Basis zurück. Example - LOG AUSWÄHLEN (3);
10	SQRT() Es gibt die Quadratwurzel zurück. Example - SELECT SQRT (16);

MariaDB-String-Funktionen

Wichtige Zeichenfolgenfunktionen sind unten angegeben -

Sr.Nr.	Name & Beschreibung
1	INSTR() Es gibt die Position der ersten Instanz eines Teilstrings zurück. Example - SELECT INSTR ('Rambutan', 'Tan');
2	RIGHT() Es werden die Zeichenfolgen ganz rechts zurückgegeben. Example - RECHTS AUSWÄHLEN ('Rambutan', 3);
3	LENGTH() Es gibt die Bytelänge eines Strings zurück. Example - LÄNGE AUSWÄHLEN ('Rambutan');
4	LOCATE() Es gibt die Position der ersten Instanz eines Teilstrings zurück. Example - SELECT LOCATE ('tan', 'rambutan');
5	INSERT() Es wird eine Zeichenfolge mit einem angegebenen Teilstring an einer bestimmten Position zurückgegeben, die geändert wurde. Example - SELECT INSERT ('ramputan', 4, 1, 'b');
6	LEFT() Es werden die Zeichen ganz links zurückgegeben. Example - LINKS AUSWÄHLEN ('Rambutan', 3);
7	UPPER() Es ändert Zeichen in Großbuchstaben. Example - SELECT UPPER (Nachname);
8	LOWER() Es ändert Zeichen in Kleinbuchstaben. Example - SELECT LOWER (Nachname);
9	STRCMP() Es vergleicht Zeichenfolgen und gibt 0 zurück, wenn sie gleich sind. Example - SELECT STRCMP ("Ei", "Käse");
10	REPLACE() Nach dem Ersetzen von Zeichen wird eine Zeichenfolge zurückgegeben. Example - SELECT REPLACE ('sully', 'l', 'n');
11	REVERSE() Es kehrt Zeichen in einer Zeichenfolge um. Example - SELECT REVERSE ('Rennwagen');
12	REPEAT() Es wird eine Zeichenfolge zurückgegeben, die bestimmte Zeichen x-mal wiederholt. Example - SELECT REPEAT ('ha', 10);
13	SUBSTRING() Es gibt einen Teilstring aus einem String zurück, beginnend an Position x. Example - SUBSTRING AUSWÄHLEN ('Rambutan', 3);
14	TRIM() Es entfernt nachfolgende / führende Zeichen aus einer Zeichenfolge. Example - SELECT TRIM (LEADING '_' FROM '_rambutan');