MySQL-Grundlagen in 1 Stunde

Erste Schritte mit MySQL

mySQL (relationales Datenbankmanagementsystem)

MySQL ist ein relationales Datenbankverwaltungssystem, das vom schwedischen Unternehmen MySQL AB entwickelt wurde und derzeit ein Produkt von Oracle ist. MySQL ist eines der beliebtesten relationalen Datenbankverwaltungssysteme. Im Hinblick auf WEB-Anwendungen ist MySQL die beste RDBMS-Anwendungssoftware (Relational Database Management System).

MySQL ist ein relationales Datenbankverwaltungssystem, das Daten in verschiedenen Tabellen speichert, anstatt alle Daten in einem großen Lager abzulegen, was die Geschwindigkeit und Flexibilität erhöht.

Die von MySQL verwendete SQL-Sprache ist die am häufigsten verwendete standardisierte Sprache für den Zugriff auf Datenbanken. MySQL-Software verwendet eine duale Lizenzierungsrichtlinie und ist in eine Community Edition und eine kommerzielle Edition unterteilt. Aufgrund seiner geringen Größe, hohen Geschwindigkeit, niedrigen Gesamtbetriebskosten und insbesondere seines Open Source-Charakters wird MySQL im Allgemeinen als Website-Datenbank für die Entwicklung kleiner und mittelgroßer Websites gewählt.
Aufgrund der hervorragenden Leistung der Community Edition kann es in Kombination mit PHP und Apache eine gute Entwicklungsumgebung bilden.

1. Eine Datenbank ist ein Lager, das Daten entsprechend Datenstrukturen organisiert, speichert und verwaltet. Jede Datenbank verfügt über eine oder mehrere verschiedene APIs zum Erstellen, Zugreifen, Verwalten, Suchen und Kopieren gespeicherter Daten.

2. Verwenden Sie relationale Datenbankverwaltungssysteme (RDBMS), um große Datenmengen zu speichern und zu verwalten. Eine relationale Datenbank ist eine Datenbank, die auf der Grundlage des relationalen Modells erstellt wurde und mathematische Konzepte und Methoden wie Mengenalgebra verwendet, um die Daten in der Datenbank zu verarbeiten.

3. RDBMS-Funktionen:

1. Daten erscheinen in Tabellenform

2. Jede Zeile ist ein Datensatzname

3. Jede Spalte ist das Datenfeld, das dem Datensatznamen entspricht

4. Viele Zeilen und Spalten bilden ein Formular

5. Mehrere Formulare bilden die Datenbank

4. RDBMS-Terminologie

Redundanz: Speichern Sie doppelt so viele Daten. Redundanz kann das System schneller machen.

Primärschlüssel: Ein Primärschlüssel ist eindeutig. Eine Datentabelle kann nur einen Primärschlüssel enthalten. Mit dem Primärschlüssel können Sie Daten abfragen.

Fremdschlüssel: Ein Fremdschlüssel wird verwendet, um zwei Tabellen zu verknüpfen.

Zusammengesetzter Schlüssel: Ein zusammengesetzter Schlüssel (Composite Key) verwendet mehrere Spalten als Indexschlüssel und wird im Allgemeinen für zusammengesetzte Indizes verwendet.

Indizes: Verwenden Sie Indizes, um schnell auf bestimmte Informationen in einer Datenbanktabelle zuzugreifen. Ein Index ist eine Struktur, die die Werte einer oder mehrerer Spalten einer Datenbanktabelle ordnet. Ähnlich dem Inhaltsverzeichnis eines Buches.

Referenzielle Integrität: Referenzielle Integrität erfordert, dass eine Beziehung keine Referenzen auf nicht vorhandene Entitäten zulässt. Die Entitätsintegrität ist eine Integritätsbeschränkung, die vom relationalen Modell eingehalten werden muss, um die Datenkonsistenz sicherzustellen.

5. MySQL ist ein relationales Datenbankverwaltungssystem, das Daten in verschiedenen Tabellen speichert, anstatt alle Daten in einem großen Lager abzulegen, was die Geschwindigkeit und Flexibilität erhöht.

MySQL-Verwaltung

6. Starten und stoppen Sie den MySQL-Server:

(1) Prüfen Sie, ob der MySQL-Server gestartet ist:

ps -ef | grepmysqld

(2) Starten Sie den MySQL-Server:

root@host# cd /usr/bin

./safe_mysqld&

(3) Fahren Sie den aktuell laufenden MySQL-Server herunter:

root@host# cd /usr/bin

./mysqladmin -u root -p shutdown

Passwort eingeben: ******

7. MySQL-Benutzereinstellungen

Fügen Sie der Benutzertabelle in der MySQL-Datenbank einen neuen Benutzer hinzu:

root@host# mysql -u root –p //Datenbank auswählen Passwort eingeben:*******
mysql> mysql verwenden;
Datenbank geändert

mysql> INSERT INTO Benutzer
(Host, Benutzer, Passwort,
select_priv, insert_priv, update_priv) //Berechtigung festlegen Y
WERTE ('localhost', 'Gast',
PASSWORT('guest123'), 'J', 'J', 'J');

Abfrage OK, 1 Zeile betroffen (0,20 Sek.)

mysql> FLUSH-PRIVILEGIEN;

Beachten Sie, dass die Anweisung FLUSH PRIVILEGES ausgeführt werden muss. Dieser Befehl lädt die Autorisierungstabelle nach der Ausführung neu.

Eine weitere Möglichkeit zum Hinzufügen von Benutzern ist der SQL-Befehl GRANT

mysql> GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP
-> ZU TUTORIALS.*
-> ZU 'zara'@'localhost'
-> IDENTIFIZIERT DURCH „zara123“;

8. Befehle zur Verwaltung von MySQL

Datenbankname verwenden: Wählen Sie die zu verwendende MySQL-Datenbank aus:

mysql> verwenden Sie W3CSCHOOL;

Datenbank geändert

DATENBANKEN ANZEIGEN: Listet die Datenbanken des MySQL-Datenbankverwaltungssystems auf:

mysql> DATENBANKEN ANZEIGEN;

TABELLEN ANZEIGEN: Zeigt alle Tabellen in der angegebenen Datenbank an. Bevor Sie diesen Befehl verwenden, müssen Sie mit dem Befehl use die zu bedienende Datenbank auswählen.

mysql> useW3CSCHOOL;

Datenbank geändert

mysql> TABELLEN ANZEIGEN;

SPALTEN AUS Datentabelle ANZEIGEN: Zeigt die Eigenschaften der Datentabelle, den Attributtyp, Informationen zum Primärschlüssel, ob dieser NULL ist, den Standardwert und andere Informationen an.

mysql> SPALTEN AUS W3Cschool_tbl ANZEIGEN;

+-----------------+--------------+------+-----+---------+---------+----------+

| Feld | Typ | Null | Schlüssel | Standard | Extra |

+-----------------+--------------+------+-----+---------+---------+----------+

INDEX AUS Datentabelle ANZEIGEN: Zeigt detaillierte Indexinformationen der Datentabelle an, einschließlich des PRIMÄRSCHLÜSSELS.

SHOW TABLE STATUS LIKE data table\G: Dieser Befehl gibt die Leistungs- und Statistikinformationen des MySQL-Datenbankverwaltungssystems aus.

mysql> SHOW TABLESTATUS FROM W3CSCHOOL; # Informationen zu allen Tabellen in der W3CSCHOOL-Datenbank anzeigen

mysql> SHOW TABLESTATUS from W3CSCHOOL LIKE 'W3Cschool%'; #Informationen zu Tabellen, deren Namen mit W3Cschool beginnen

mysql> SHOW TABLESTATUS from W3CSCHOOL LIKE 'W3Cschool%'\G; #Fügen Sie \G hinzu, um die Abfrageergebnisse spaltenweise auszudrucken

9. PHP MySQL-Funktionsformat: mysql_function(Wert, Wert, …);

MySQL-Verbindung

10. Herstellen einer Verbindung im MySQL-Binärmodus

[root@host]# mysql -uroot -p
Passwort eingeben:******
Nach einer erfolgreichen Anmeldung wird das mysql>-Eingabeaufforderungsfenster angezeigt, in dem Sie beliebige SQL-Anweisungen ausführen können.
Um das mysql>-Eingabeaufforderungsfenster zu verlassen, verwenden Sie den Befehl exit: mysql> exit

11. Herstellen einer Verbindung zu MySQL mithilfe eines PHP-Skripts

PHP stellt die Funktion mysql_connect() zum Herstellen einer Verbindung mit der Datenbank bereit.
connectionmysql_connect(server,user,passwd,new_link,client_flag);5Alle Parameter sind optional. Verwenden Sie die PHP-Funktion mysql_close(), um die Verbindung zur MySQL-Datenbank zu trennen.
bool mysql_close (Ressource $link_identifier);
Normalerweise sollten Sie mysql_close() nicht verwenden, da offene, nicht persistente Verbindungen nach Abschluss der Skriptausführung automatisch geschlossen werden.
mysql_close() schließt keine dauerhafte Verbindung, die durch mysql_pconnect() hergestellt wurde.

$conn = mysql_connect($dbhost, $dbuser, $dbpass);
wenn(!$conn)
{
die('Verbindung konnte nicht hergestellt werden: ' .mysql_error());
}
echo 'Verbindung erfolgreich hergestellt';
mysql_close($conn);

MySQL-Datenbank erstellen/löschen

12. Erstellen einer Datenbank mit mysqladmin

Melden Sie sich als Root-Benutzer an. Der Root-Benutzer verfügt über die höchsten Berechtigungen und kann mit dem Befehl mysql mysqladmin eine Datenbank erstellen.
[root@host]#mysqladmin -u root -pcreate/drop W3CSCHOOL
Passwort eingeben:*****

13. Erstellen einer Datenbank mit einem PHP-Skript

PHP verwendet die Funktion mysql_query, um eine MySQL-Datenbank zu erstellen oder zu löschen.

bool mysql_query( sql, Verbindung);
 
$conn = mysql_connect($dbhost,$dbuser, $dbpass);
wenn(!$conn)
{
 die('Verbindungsfehler: ' . mysql_error());
}
echo 'Verbindung erfolgreich<br />';
$sql = 'Datenbank W3CSCHOOL erstellen/löschen';
: $retval = mysql_query( $sql, $conn );
wenn(!$retval )
{
 die('Datenbank konnte nicht erstellt werden: ' . mysql_error());
}
echo "Datenbank W3CSCHOOL wurde erfolgreich erstellt\n";
mysql_close($conn);

MySQL-Datenbank auswählen

14. MySQL-Datenbank mit PHP-Skript auswählen

PHP bietet die Funktion mysql_select_db zum Auswählen einer Datenbank.

bool mysql_select_db( db_name, Verbindung );
$conn = mysql_connect($dbhost,$dbuser, $dbpass);
wenn(!$conn)
{
 die('Verbindung fehlgeschlagen: ' . mysql_error());
}

echo 'Verbindung erfolgreich';
mysql_select_db('W3CSCHOOL');
mysql_close($conn);

MySQL-Tabelle erstellen/löschen

15. MySQL-Tabelle erstellen

Zum Erstellen einer MySQL-Tabelle werden folgende Angaben benötigt:

Tabellenname

Tabellenfeldname

Definieren Sie jedes Tabellenfeld

Erstellungssyntax: CREATE TABLE Tabellenname (Spaltenname Spaltentyp);

Syntax zum Löschen: DROP TABLE Tabellenname;

Im folgenden Beispiel erstellen wir eine Datentabelle w3cschool_tbl in der W3CSCHOOL-Datenbank:

tutorials_tbl(
 tutorial_id INT NICHT NULL AUTO_INCREMENT,
 tutorial_title VARCHAR(100) NICHT NULL,
 tutorial_author VARCHAR(40) NICHT NULL,
 Einreichungsdatum DATUM,
 PRIMÄRSCHLÜSSEL ( w3cschool_id )
);

16. Erstellen Sie eine Tabelle über die Eingabeaufforderung

Verwenden Sie die SQL-Anweisung CREATE TABLE, um eine Datentabelle zu erstellen.

mysql> TABELLE ERSTELLEN w3cschool_tbl(
 -> w3cschool_id INT NOTNULL AUTO_INCREMENT,
 -> w3cschool_title VARCHAR(100) NICHT NULL,
 -> w3cschool_author VARCHAR(40) NICHT NULL,
 -> Einreichungsdatum DATUM,
 -> PRIMÄRSCHLÜSSEL (w3cschool_id)
 -> );

Der MySQL-Befehlsabschluss ist ein Semikolon (;).

17. Verwenden Sie PHP-Skripte, um Tabellen zu erstellen/löschen oder Daten einzufügen

Syntax: bool mysql_query(sql, Verbindung);

$sql = "CREATE TABLEtutorials_tbl( "Erstellen"tutorial_id INT NOTNULL AUTO_INCREMENT, ".
  „tutorial_title VARCHAR(100) NICHT NULL, „.
  „tutorial_author VARCHAR(40) NICHT NULL, ".
  "Übermittlungs_DatumDATE, ".
  "Primärschlüssel (Tutorial-ID)); "
;
$sql = "DROP TABLEw3cschool_tbl"; deletemysql_select_db('TUTORIALS');
$retval = mysql_query( $sql, $conn); //Parameter werden festgelegt, um den Erfolg zu bestimmen;
wenn(!$retval )
{
 die('Erstellen der Datentabelle fehlgeschlagen: ' . mysql_error());
}
echo "Datentabelle erfolgreich erstellt\n";
mysql_close($conn);

MySQL-Daten einfügen

18. Die allgemeine INSERT INTO SQL-Syntax zum Einfügen von Daten in eine MySQL-Tabelle lautet:

INSERT INTO Tabellenname (Feld1, Feld2, ... FeldN)
WERTE
(Wert1,Wert2,...WertN);

Wenn die Daten vom Zeichentyp sind, müssen einfache oder doppelte Anführungszeichen verwendet werden, z. B.: „Wert“.

Fügen Sie einen Datensatz in die Tabelle w3cschool_tbl ein:

mysql> INSERT INTOw3cschool_tbl
->(w3cschool_Titel, w3cschool_Autor, Einreichungsdatum)
->WERTE
->("PHP lernen", "JohnPoul", JETZT());

(->) ist kein Bestandteil der SQL-Anweisung. Es stellt lediglich eine neue Zeile dar. Wenn die SQL-Anweisung zu lang ist, können Sie mit der Eingabetaste eine neue Zeile erstellen, in die Sie die SQL-Anweisung schreiben können. Das Befehlsabschlusszeichen der SQL-Anweisung ist ein Semikolon (;).

19. Einfügen von Daten per PHP-Skript

$sql = "INSERT INTO w3cschool_tbl ".
"(w3cschool_Titel,w3cschool_Autor,Einreichungsdatum)".
"WERTE ".
"('$w3cschool_title','$w3cschool_author','$submission_date')";

MySQL-Abfragedaten

20. Die allgemeine SELECT-Syntax zum Abfragen von Daten in einer MySQL-Datenbank lautet:

SELECT Spaltenname, Spaltenname
FROM Tabellenname
[WHERE-Klausel]
[OFFSET M] [GRENZE N]

Über den SELECT-Befehl können ein oder mehrere Datensätze gelesen werden.

Mit OFFSET können Sie den Datenoffset angeben, an dem die SELECT-Anweisung mit der Abfrage beginnt. Standardmäßig ist der Offset 0.

Mit dem LIMIT-Attribut können Sie die Anzahl der zurückgegebenen Datensätze festlegen.

Sie können ein Sternchen (*) verwenden, um andere Felder zu ersetzen. Die SELECT-Anweisung gibt dann alle Felddaten in der Tabelle zurück.

mysql> SELECT * aus w3cschool_tbl

einundzwanzig. Verwenden eines PHP-Skripts zum Abrufen von Daten

Verwenden Sie die PHP-Funktion mysql_query() und den SQL-Befehl SELECT, um Daten abzurufen.
Mit dieser Funktion werden SQL-Befehle ausgeführt und anschließend alle abgefragten Daten über die PHP-Funktion mysql_fetch_array() verwendet bzw. ausgegeben.

Versuchen Sie das folgende Beispiel, um alle Datensätze in der Datentabelle w3cschool_tbl anzuzeigen

$sql = 'WÄHLEN Sie w3cschool_id,w3cschool_title,
w3cschool_author,Einreichungsdatum
VON w3cschool_tbl';
mysql_select_db('W3CSCHOOL');
: $retval = mysql_query( $sql, $conn );
wenn(!$retval )
{
die('Daten konnten nicht abgerufen werden: ' .mysql_error());
}
während($row =mysql_fetch_array($retval, MYSQL_ASSOC))
während($row =mysql_fetch_assoc($retval))

Anzeigen einer Tabelle mit dem Parameter MYSQL_NUM

während($row =mysql_fetch_array($retval, MYSQL_NUM))

Anzeigen einer Tabelle mit dem Parameter MYSQL_NUM

{
echo "Tutorial-ID: {$row['w3cschool_id']} <br>".
„Titel: {$row['w3cschool_title']} <br> “.
„Autor: {$row['w3cschool_author']} <br> “.
„Einreichungsdatum: {$row['submission_date']}<br> “.
"---------------------------------<br>";
}
mysql_free_result($retval); Gibt Cursorspeicher frei
echo "Daten erfolgreich abgerufen\n";
mysql_close($conn);

MYSQL_ASSOC, setzen Sie diesen Parameter, um ein assoziatives Array als Abfrageergebnis zurückzugeben. Sie können den Feldnamen als Index des Arrays verwenden.

MySQL-Daten auswählen

zweiundzwanzig. Verwenden Sie die SQL-SELECT-Anweisung, um Daten aus der MySQL-Tabelle zu lesen.

Wenn Sie Daten aus einer Tabelle bedingt auswählen müssen, können Sie der SELECT-Anweisung eine WHERE-Klausel hinzufügen. Nachfolgend sehen Sie die allgemeine Syntax der SQL SELECT-Anweisung, die die WHERE-Klausel zum Lesen von Daten aus einer Tabelle verwendet:

SELECT Feld1, Feld2, ... FeldN FROM Tabellenname1, Tabellenname2 ...
[WO Bedingung1 [UND[ODER]] Bedingung2...

Die WHERE-Klausel kann auch in SQL-Befehlen DELETE oder UPDATE verwendet werden.
Verwenden Sie LIKE zum Vergleichen von Zeichenfolgen, da sonst beim Zeichenfolgenvergleich in der WHERE-Klausel von MySQL die Groß-/Kleinschreibung nicht beachtet wird. Sie können das Schlüsselwort BINARY verwenden, um Zeichenfolgenvergleiche in der WHERE-Klausel unter Beachtung der Groß-/Kleinschreibung durchzuführen.

dreiundzwanzig. Einlesen von Daten per PHP-Skript

Verwenden Sie die PHP-Funktion mysql_query() und denselben SQL-SELECT-Befehl mit einer WHERE-Klausel, um Daten abzurufen. Mit dieser Funktion werden SQL-Befehle ausgeführt und anschließend alle abgefragten Daten über mysql_fetch_array() ausgegeben.

$sql = 'WÄHLEN Sie w3cschool_id,w3cschool_title,
w3cschool_author, Einreichungsdatum
VON w3cschool_tbl
WO w3cschool_author="Sanjay"';

MySQL-UPDATE

vierundzwanzig. Um Daten in MySQL zu ändern oder zu aktualisieren, können wir den SQL-Befehl UPDATE verwenden.

Allgemeine SQL-Syntax:

UPDATE Tabellenname SET Feld1=Neuer-Wert1, Feld2=Neuer-Wert2

[WHERE-Klausel]

Aktualisieren Sie den Feldwert w3cschool_title von w3cschool_id 3 in der Datentabelle:

mysql>UPDATE w3cschool_tbl
-> SET w3cschool_title='JAVA lernen'
-> WO w3cschool_id=3;

Daten mit PHP-Skript aktualisieren

$sql = 'UPDATE w3cschool_tbl
SETw3cschool_title="JAVA lernen"
WO w3cschool_id=3';

MySQL LÖSCHEN

25. DELETE FROM table_name[WHERE-Klausel

Wenn keine WHERE-Klausel angegeben ist, werden alle Datensätze in der MySQL-Tabelle gelöscht.

Sie können jede beliebige Bedingung in der WHERE-Klausel angeben

Löschen Sie den Datensatz mit w3cschool_id 3 in der Tabelle w3cschool_tbl

mysql> LÖSCHEN FROMw3cschool_tbl WO w3cschool_id=3;

Löschen von Daten per PHP-Skript

$sql = 'LÖSCHEN AUS w3cschool_tbl
WO w3cschool_id=3';

MySQL LIKE-Klausel

Das Prozentzeichen (%) wird in der QL LIKE-Klausel zur Darstellung beliebiger Zeichen verwendet.

Ohne das Prozentzeichen (%) hat die LIKE-Klausel die gleiche Wirkung wie das Gleichheitszeichen (=).
26. Die allgemeine Syntax der QL SELECT-Anweisung mit der LIKE-Klausel zum Lesen von Daten aus einer Tabelle lautet:
SELECT Feld1, Feld2, ... FeldN Tabellenname1, Tabellenname2 ...
WO Feld1 WIE Bedingung1 [UND [ODER]] Feld2 = 'ein Wert'
LIKE wird normalerweise mit %, ähnlich einer Metazeichensuche verwendet

Verwenden der LIKE-Klausel in PHP-Skripten

$sql = 'WÄHLEN Sie w3cschool_id, w3cschool_title,
w3cschool_author,Einreichungsdatum
VON w3cschool_tbl
WO w3cschool_author LIKE "%jay%"';

MySQL-Sortierung

SELECT Feld1, Feld2, ... FeldN Tabellenname1, Tabellenname2 ...

ORDER BY Feld1,[Feld2...] [ASC [DESC]]

Mit den Schlüsselwörtern ASC oder DESC werden die Abfrageergebnisse in aufsteigender oder absteigender Reihenfolge angezeigt. Standardmäßig erfolgt die Sortierung aufsteigend.

MySQL-Gruppierung

SELECT Spaltenname, Funktion(Spaltenname)
FROM Tabellenname
WHERE SpaltennameOperatorwert
GROUP BY Spaltenname;

WITH ROLLUP kann dieselben Statistiken (SUM, AVG, COUNT...) basierend auf gruppierten statistischen Daten durchführen.

mergel, um einen Namen festzulegen, der NUll ersetzen kann, mergel-Syntax:

Wählen Sie Koaleszenz (a, b, c);

Parameterbeschreibung: Wenn a==null, wähle b; wenn b==null, wähle c; wenn a!=null, wähle a; wenn abc beide null sind, gib null zurück (bedeutungslos).

mysql> SELECT coalesce(Name, 'Gesamt'), SUM(singin) als singin_countFROM employee_tbl GROUP BY Name WITHROLLUP;

+--------------------------+--------------+

| koaleszieren(Name, 'Gesamt') | Anzahl der Singins |

+--------------------------+--------------+

| 2 |

| Xiao Ming | 7 |

| Xiao Wang | 7 |

| Gesamt | 16 |

+--------------------------+--------------+

MySQL-Abfrage für mehrere Tabellen

27. Verwenden Sie JOIN von MySQL, um mehrere Tabellen in SELECT-, UPDATE- und DELETE-Anweisungen zu kombinieren.

JOIN kann anhand seiner Funktionen grob in folgende drei Kategorien unterteilt werden:

INNER JOIN (Inner Join oder Equijoin): Ruft Datensätze mit übereinstimmenden Feldern in zwei Tabellen ab.
LEFT JOIN: Ruft alle Datensätze in der linken Tabelle ab, auch wenn in der rechten Tabelle keine entsprechenden Datensätze vorhanden sind.
RIGHT JOIN: Das Gegenteil von LEFT JOIN. Wird verwendet, um alle Datensätze in der rechten Tabelle abzurufen, auch wenn in der linken Tabelle keine entsprechenden übereinstimmenden Datensätze vorhanden sind.

| w3cschool_Autor | w3cschool_Anzahl |

+-----------------+----------------+

| Mahran | 20 |

| mahnaz | NULL |

| Jen | NULL |

| Gill | 20 |

| John Poul | 1 |

| Sanjay | 1 |

+-----------------+----------------+

mysql> AUSWÄHLEN * von w3cschool_tbl;

+-------------+----------------+-----------------+-----------------+

| w3cschool_id | w3cschool_titel | w3cschool_autor | Einreichungsdatum |

+-------------+----------------+-----------------+-----------------+

| 1 | PHP lernen | John Poul |24.05.2007 |
| 2 | LearnMySQL | Abdul S | 24.05.2007 |
| 3 | JAVATutorial | Sanjay | 06.05.2007 |

Verbinden Sie die beiden obigen Tabellen, um die w3cschool_count-Feldwerte zu lesen, die allen w3cschool_author-Feldern in der w3cschool_tbl-Tabelle in der tcount_tbl-Tabelle entsprechen:

mysql> SELECT a.w3cschool_id, a.w3cschool_author, b.w3cschool_count FROM w3cschool_tbl a INNER JOIN tcount_tbl b ON a.w3cschool_author = b.w3cschool_author;

+--------------+------------------+-----------+

| w3cschool_id | w3cschool_autor | w3cschool_anzahl |

+--------------+------------------+-----------+

| 1 | John Poul | 1 |

| 3 | Sanjay | 1 |

w3cschool_tbl ist die linke Tabelle, tcount_tbl ist die rechte Tabelle,

mysql> SELECT a.w3cschool_id, a.w3cschool_author, b.w3cschool_count FROM w3cschool_tbl a LEFTJOIN tcount_tbl b ON a.w3cschool_author = b.w3cschool_author;

+-------------+-----------------+----------------+

| w3cschool_id | w3cschool_autor | w3cschool_anzahl |

+-------------+-----------------+----------------+

| 1 | John Poul | 1 |

| 2 | Abdul S | NULL |

| 3 | Sanjay | 1 |

Alle ausgewählten Felddaten aus der Datentabelle w3cschool_tbl auf der linken Seite, auch wenn in der Tabelle tcount_tbl auf der rechten Seite kein entsprechender w3cschool_author-Feldwert Abdul S vorhanden ist.

MySQL NULL

IS NULL: Dieser Operator gibt „true“ zurück, wenn der Spaltenwert NULL ist.
IS NOT NULL: Der Operator gibt „true“ zurück, wenn der Spaltenwert nicht NULL ist.

Der Vergleich eines NULL-Werts mit einem anderen Wert (auch NULL) gibt immer „false“ zurück.

Umgang mit NULL-Werten mittels PHP-Skript:

In PHP-Skripten können Sie mithilfe von if...else-Anweisungen prüfen, ob eine Variable leer ist, und entsprechende bedingte Anweisungen generieren.

MySQL-reguläre Ausdrücke

28. Der REGEXP-Operator wird in MySQL verwendet, um reguläre Ausdrücke abzugleichen.

^ Stimmt mit dem Anfang der Eingabezeichenfolge überein. Wenn die Eigenschaft „Multiline“ des RegExp-Objekts festgelegt ist, entspricht ^ auch der Position nach „\n“ oder „\r“.
$ entspricht dem Ende der Eingabezeichenfolge. Wenn die Eigenschaft „Multiline“ des RegExp-Objekts gesetzt ist, entspricht „$“ auch der Position vor „\n“ oder „\r“.
. passt zu jedem einzelnen Zeichen außer "\n". Um jedes Zeichen einschließlich „\n“ abzugleichen, verwenden Sie ein Muster wie „[.\n]“.

Beispiel (Tabellenname: person_tbl) zur Vertiefung unseres Verständnisses:

Suche nach allen Daten, die im Namensfeld mit „st“ beginnen:

mysql> SELECT Name FROM Person_Tabelle WHERE Name REGEXP '^st';

Suche alle Daten, die im Namensfeld mit „ok“ enden:

mysql> SELECT Name FROM person_tbl WHERE Name REGEXP 'ok$';

Suche nach allen Daten, die die Zeichenfolge „mar“ im Namensfeld enthalten:

mysql> SELECT Name FROM Person_Tabelle WHERE Name REGEXP 'mar';

Suche alle Daten im Namensfeld, die mit einem Vokal beginnen oder mit der Zeichenfolge „ok“ enden:

mysql> SELECT Name FROM Person_Tabelle WHERE Name REGEXP'^[aeiou]|ok$';

MySQL-Transaktionen

29. MySQL-Transaktionen werden hauptsächlich zur Verarbeitung von Daten mit großen Operationsvolumina und hoher Komplexität verwendet.

In MySQL unterstützen nur Datenbanken oder Tabellen, die die Innodb-Datenbank-Engine verwenden, Transaktionen.

Mithilfe der Transaktionsverarbeitung kann die Integrität der Datenbank gewahrt werden, indem sichergestellt wird, dass Batches von SQL-Anweisungen entweder alle oder keine ausgeführt werden.

Transaktionen werden zum Verwalten von Einfüge-, Aktualisierungs- und Löschanweisungen verwendet.

Transaktionen müssen vier Bedingungen erfüllen (ACID): Atomarität, Konsistenz, Isolation und Dauerhaftigkeit

1. Atomarität von Transaktionen: Eine Reihe von Transaktionen ist entweder erfolgreich oder wird zurückgezogen.

2. Stabilität: Bei ungültigen Daten (z. B. Fremdschlüsseleinschränkungen) wird die Transaktion zurückgezogen.

3. Isolation: Transaktionen laufen unabhängig voneinander. Wenn das Ergebnis einer Transaktion andere Transaktionen beeinflusst, werden die anderen Transaktionen zurückgezogen. Eine 100-prozentige Isolierung der Transaktionen erfordert Einbußen bei der Geschwindigkeit.

4. Zuverlässigkeit: Nach einem Software- oder Hardwareabsturz verwendet der InnoDB-Datentabellentreiber die Protokolldatei, um sie zu rekonstruieren und zu ändern. Zuverlässigkeit und hohe Geschwindigkeit können nicht gleichzeitig erreicht werden. Die Option innodb_flush_log_at_trx_commit bestimmt, wann Transaktionen im Protokoll gespeichert werden.

Verwenden Sie Transaktionen in der MySQL-Konsole, um Folgendes auszuführen:

1. Eine Transaktion starten

Transaktion starten

2. Einen Speicherpunkt erstellen

Sicherungspunkt Sicherungspunktname

3. Bedienung

4. Sie können einen Rollback oder ein Commit durchführen. Wenn kein Problem vorliegt, führen Sie ein Commit durch. Wenn ein Problem vorliegt, führen Sie einen Rollback durch.

Verwenden von Transaktionsbeispielen in PHP

mysql_query("SETAUTOCOMMIT=0"); //So einstellen, dass kein automatisches Commit ausgeführt wird, da MySQL standardmäßig sofort ausgeführt wird mysql_query("BEGIN"); //Transaktionsdefinition starten

wenn(!mysql_query("insertinto trans (id) values('2')"))
{
mysql_query("ROOLBACK"); //Beurteilen, ob die Ausführung fehlschlägt und zurücksetzen}
mysql_query("COMMIT");//Transaktion ausführen mysql_close($handler);
MySQL ALTER

30. Wenn Sie den Namen einer Datentabelle oder ein Datentabellenfeld ändern, müssen Sie den MySQL-Befehl ALTER verwenden.

Der ALTER-Befehl und die DROP-Klausel werden verwendet, um die i-te Spalte der oben erstellten Tabelle zu löschen:

mysql> ALTER TABLE test alter_tbl DROP i;

Wenn in der Datentabelle nur noch ein Feld übrig ist, kann DROP nicht zum Löschen des Felds verwendet werden.

Verwenden Sie die ADD-Klausel, um der Datentabelle Spalten hinzuzufügen, fügen Sie das Feld „i“ zur Tabelle „testalter_tbl“ hinzu und definieren Sie den Datentyp:

mysql> ALTER TABLE testalter_tbl ADD i INT;

Nachdem die folgende ALTERTABLE-Anweisung erfolgreich ausgeführt wurde, verwenden Sie SHOW COLUMNS, um die Änderungen in der Tabellenstruktur anzuzeigen:

ALTER TABLE testalter_tbl DROP i;
ALTER TABLE testalter_tbl ADD i INT FIRST;
ALTER TABLE testalter_tbl DROP i;
ALTER TABLE testalter_tbl ADD i INT NACH c;

Die Schlüsselwörter FIRST und AFTER werden nur in der ADD-Klausel verwendet. Wenn Sie also die Position eines Tabellenfelds zurücksetzen möchten, müssen Sie zuerst DROP verwenden, um das Feld zu entfernen, und dann ADD verwenden, um das Feld hinzuzufügen und die Position festzulegen.

Ändern Sie den Feldtyp und den Namen:

31. Verwenden Sie die MODIFY- oder CHANGE-Klausel im ALTER-Befehl.

Um den Typ des Felds c von CHAR(1) in CHAR(10) zu ändern, können Sie den folgenden Befehl ausführen:
mysql> ALTER TABLE test alter_tbl MODIFY c CHAR(10);
Bei Verwendung der CHANGE-Klausel ist die Syntax ganz anders. Nach dem Schlüsselwort CHANGE folgen Sie dem Namen des Felds, das Sie ändern möchten, und geben Sie dann den Typ und den Namen des neuen Felds an. Versuchen Sie das folgende Beispiel:
mysql> ALTER TABLE testalter_tbl CHANGE ij BIGINT;
<pWenn Sie nun das Feld j von BIGINT auf INT ändern möchten, lautet die SQL-Anweisung wie folgt:
mysql> ALTER TABLE testalter_tbl CHANGE jj INT;

ALTER ändert den Standardwert eines Felds, mysql> ALTER TABLE testalter_tbl ALTER i SET DEFAULT 1000;
ALTER und DROP löschen den Standardwert der Spalte, ALTER TABLEtestalter_tbl ALTER i DROP DEFAULT;
ALTER und TYPE ändern den Datentabellentyp, mysql> ALTER TABLEtestalter_tbl TYPE = MYISAM;
ALTER TABLE verwendet RENAME, um den Namen der Datentabelle zu ändern, mysql> ALTER TABLE testalter_tbl RENAME TO alter_tbl;

MySQL-Indizes

Indizes können die Abrufgeschwindigkeit von MySQL erheblich verbessern. Indizes werden in einspaltige Indizes und kombinierte Indizes unterteilt. Ein einspaltiger Index ist ein Index, der nur eine einzige Spalte enthält. Eine Tabelle kann mehrere einspaltige Indizes haben, diese sind jedoch keine zusammengesetzten Indizes. Zusammengesetzter Index, d. h. ein Index enthält mehrere Spalten.
Erstellen Sie einen Index und stellen Sie sicher, dass der Index auf die SQL-Abfrageanweisung angewendet wird (normalerweise als Bedingung der WHERE-Klausel).
Der Index ist ebenfalls eine Tabelle, die den Primärschlüssel und die Indexfelder speichert und auf die Datensätze der Entitätstabelle verweist.
Nachteile: Obwohl Indizes die Abfragegeschwindigkeit erheblich verbessern, verringern sie auch die Geschwindigkeit beim Aktualisieren von Tabellen, wie z. B. INSERT, UPDATE und DELETE. Denn beim Aktualisieren einer Tabelle muss MySQL nicht nur die Daten, sondern auch die Indexdatei speichern.
3 Möglichkeiten zum Erstellen eines gemeinsamen Indexes

CREATE INDEX indexName ONmytable(Benutzername(Länge));

Beim Typ CHAR oder VARCHAR kann die Länge kleiner sein als die tatsächliche Länge des Felds; beim Typ BLOB oder TEXT muss die Länge angegeben werden.

Tabellenstruktur ändern

ALTER mytable ADD INDEX[indexName] ON (Benutzername(Länge))

Direkt beim Erstellen einer Tabelle angeben

TABELLE ERSTELLEN meineTabelle( 
ID INT NICHT NULL, 
Benutzername VARCHAR(16) NOTNULL, 
INDEX [Indexname] (Benutzername (Länge)) 
);

Syntax zum Löschen eines Indexes

DROP INDEX [Indexname] ONmytable;

Eindeutiger Index: Fügen Sie UNIQUE davor hinzu

Hinzufügen und Löschen von Indizes mit dem ALTER-Befehl

Es gibt vier Möglichkeiten, einer Tabelle Indizes hinzuzufügen:

ALTER TABLE tbl_name ADD PRIMARYKEY (column_list): Diese Anweisung fügt einen Primärschlüssel hinzu, was bedeutet, dass der Indexwert eindeutig sein muss und nicht NULL sein darf.
ALTER TABLE tbl_name ADD UNIQUEindex_name(column_list): Diese Anweisung erstellt einen Index, dessen Werte eindeutig sein müssen (außer NULL, das mehrfach vorkommen kann).
ALTER TABLE tbl_name ADD INDEXindex_name (column_list): Fügt einen normalen Index hinzu. Der Indexwert kann mehrfach vorkommen.
ALTER TABLE tbl_name ADD FULLTEXTindex_name (column_list): Diese Anweisung gibt den Index als FULLTEXT für die Volltextindizierung an.

Verwenden Sie den ALTER-Befehl zum Hinzufügen und Löschen von Primärschlüsseln

Ein Primärschlüssel kann nur auf eine Spalte angewendet werden. Wenn Sie einen Primärschlüsselindex hinzufügen, müssen Sie sicherstellen, dass der Primärschlüssel standardmäßig nicht leer (NOT NULL) ist. Nachfolgend sind einige Beispiele aufgeführt:

mysql> ALTER TABLE-Test alter_tbl MODIFY i INT NOT NULL;

mysql> ALTER TABLE-Test alter_tbl ADD PRIMARY KEY (i);

Sie können einen Primärschlüssel auch mit dem ALTER-Befehl löschen:

mysql> ALTER TABLE testalter_tbl DROP PRIMARY KEY;

Der Befehl SHOW INDEX listet die relevanten Indexinformationen in der Tabelle auf. Sie können die Ausgabe durch Hinzufügen von \G formatieren.

mysql> SHOW INDEX FROM Tabellenname\G

Temporäre MySQL-Tabellen

Temporäre Tabellen sind nur für die aktuelle Verbindung sichtbar. Wenn Sie die Verbindung schließen, löscht MySQL die Tabelle automatisch und gibt den gesamten Speicherplatz frei.

mysql> Temporäre Tabelle erstellen SalesSummary

mysql> DROP TABLE Verkaufszusammenfassung;

MySQL-Kopiertabelle

Erstellen Sie eine neue Klontabelle clone_tbl. Wenn Sie die Daten in eine Tabelle kopieren möchten, können Sie dazu die Anweisung INSERT INTO... SELECT verwenden.

mysql> INSERT INTOclone_tbl (w3cschool_id,
-> w3cschool_title,
-> w3cschool_author,
-> Einreichungsdatum)
-> WÄHLEN Sie w3cschool_id, w3cschool_title,
-> w3cschool_author,Einreichungsdatum
->VON w3cschool_tbl;

MySQL-Metadaten

Ich möchte die folgenden drei Arten von MySQL-Informationen wissen:

Informationen zum Abfrageergebnis: Die Anzahl der Datensätze, die von der Anweisung SELECT, UPDATE oder DELETE betroffen sind.
Datenbank- und Datentabelleninformationen: Enthält die Strukturinformationen der Datenbank und der Datentabellen.
MySQL-Serverinformationen: Enthält den aktuellen Status des Datenbankservers, Versionsnummer usw.

(1) Verwenden Sie do(), um $query auszuführen

mein $count = $dbh->do($query);

(2) Verwenden Sie prepare() und execute(), um $query auszuführen

mein $sth =$dbh->vorbereiten ($query);

mein $count =$sth->execute();

Verwenden Sie in PHP die Funktion mysql_affected_rows(), um die Anzahl der von einer Abfrageanweisung betroffenen Datensätze abzurufen.

: $result_id = mysql_query ($query, $conn_id);
# Wenn die Abfrage fehlschlägt, returnieren Sie $count = ($result_id ?mysql_affected_rows ($conn_id) : 0);
print ("$countrows waren betroffen\n");

Liste der Datenbanken und Tabellen

PERL-Beispiele

# Alle verfügbaren Tabellen in der aktuellen Datenbank abrufen.

meine @tables =$dbh->tables ( );
für jeden $table (@tables) {
 drucke "Tabellenname $table\n";
}

PHP-Beispiel:

: Wenn Sie eine MySQL-Datenbank verwenden, müssen Sie sie in der MySQL-Datenbankverwaltungsroutine aktualisieren.
während ($db = mysql_fetch_object($db_list))
{
 echo $db->Datenbank . "<br/>";
}

MySQL-Sequenz

Eine MySQL-Sequenz ist eine Menge von Ganzzahlen: 1, 2, 3, ...,

Verwenden Sie MySQL AUTO_INCREMENT, um die Spalte zu definieren.

mysql> CREATE TABLE einfügen

-> (

-> id INT UNSIGNED NOT NULL AUTO_INCREMENT,

Verwenden Sie die Funktion LAST_INSERT_ID() in SQL, um den Wert der Auto-Increment-Spalte in der zuletzt eingefügten Tabelle abzurufen.

PERL-Beispiele

Verwenden Sie das Attribut mysql_insertid, um den Wert von AUTO_INCREMENT zu erhalten. Nachfolgend sind einige Beispiele aufgeführt:

$dbh->do("INSERT INTO Insekt (Name, Datum, Herkunft)

WERTE('Motte','2001-09-14','Fensterbank')");

mein $seq = $dbh->{mysql_insertid};

PHP-Beispiel

PHP verwendet die Funktion mysql_insert_id(), um den Wert der Spalte AUTO_INCREMENT in der ausgeführten SQL-Einfügeanweisung abzurufen.

mysql_query("INSERT INTO Insekt (Name, Datum, Herkunft)
WERTE('Motte','2001-09-14','Fensterbank')",$conn_id);
: $seq = mysql_insert_id($conn_id);

Sequenz zurücksetzen

Wenn Sie mehrere Datensätze in der Datentabelle gelöscht und die AUTO_INCREMENT-Spalten der verbleibenden Daten neu angeordnet haben, können Sie dies tun, indem Sie die Auto-Increment-Spalte löschen und anschließend erneut hinzufügen.

mysql> ALTER TABLEinsect DROP id;

mysql> ALTER TABLEinsect

-> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,

-> Primärschlüssel (ID) hinzufügen;

Normalerweise beginnt die Sequenz bei 1. Wenn Sie jedoch einen Startwert von 100 angeben müssen:

-> id INT UNSIGNEDNOT NULL AUTO_INCREMENT = 100,

Oder verwenden Sie nach erfolgreicher Erstellung der Tabelle die folgende Anweisung, um dies zu erreichen:

mysql> ALTER TABLE tAUTO_INCREMENT = 100;

MySQL verarbeitet doppelte Daten

Verhindern, dass doppelte Daten in der Tabelle erscheinen

Legen Sie das angegebene Feld in der MySQL-Datentabelle als PRIMARY KEY- oder UNIQUE-Index fest, um die Eindeutigkeit der Daten sicherzustellen.

Legen Sie die Felder „Vorname“ und „Nachname“ in der Tabelle so fest, dass sie eindeutige Daten enthalten. Sie können einen dualen Primärschlüsselmodus festlegen, um die Eindeutigkeit der Daten festzulegen. Wenn Sie einen dualen Primärschlüssel festlegen, darf der Standardwert dieses Schlüssels nicht NULL sein und kann auf NOT NULL festgelegt werden. Wie unten dargestellt:

CREATE TABLE person_tbl
(
 Vorname CHAR(20) NOT NULL,
 Nachname CHAR(20) NOT NULL,
 sexCHAR(10),
 PRIMÄRSCHLÜSSEL (Nachname, Vorname)
);

Der Unterschied zwischen INSERT IGNORE INTO und INSERT INTO besteht darin, dass INSERT IGNORE die Daten ignoriert, die bereits in der Datenbank vorhanden sind. Wenn keine Daten in der Datenbank vorhanden sind, werden neue Daten eingefügt. Wenn Daten vorhanden sind, werden die Daten übersprungen. Dadurch können die vorhandenen Daten in der Datenbank beibehalten und der Zweck erreicht werden, Daten in die Lücke einzufügen.

Bei Verwendung von INSERT IGNORE INTO tritt nach der Ausführung kein Fehler auf und es werden keine doppelten Daten in die Datentabelle eingefügt:

mysql> INSERT IGNORE INTO person_tbl(Nachname, Vorname)

->WERTE('Jay', 'Thomas');

Abfrage OK, 1 Zeile betroffen (0,00 Sek.)

REPLACE INTO in: Wenn ein Datensatz mit demselben Primär- oder Eindeutigkeitsnamen vorhanden ist, löschen Sie diesen zuerst. Neue Datensätze erneut einfügen.

UNIQUE(Nachname, Vorname)

Abfrage doppelter Datensätze

Wählen Sie Benutzername, Anzahl (*) als Anzahl aus der Benutzertabelle, gruppieren Sie nach Benutzername mit Anzahl > 1;

Wählen Sie * aus Personen aus

wobei peopleId in (wähle peopleId aus der Personengruppe nach peopleId mit count(peopleId) > 1)

Zählen doppelter Daten

Zählen Sie die Anzahl der doppelten Datensätze von Vorname und Nachname in der Tabelle:

mysql> SELECT COUNT(*) als Wiederholungen, Nachname, Vorname

 ->VON person_tbl
 ->GROUP BY Nachname, Vorname
 -> MIT Wiederholungen > 1;

Filtern doppelter Daten

Um nicht doppelte Daten zu lesen, können Sie das Schlüsselwort DISTINCT in der SELECT-Anweisung verwenden, um doppelte Daten herauszufiltern.

mysql> SELECT DISTINCT Nachname, Vorname

->VON person_tbl

->ORDER BY Nachname;

Sie können GROUP BY auch verwenden, um nicht doppelte Daten in der Datentabelle zu lesen:

mysql> SELECT Nachname, Vorname
 ->VON person_tbl
 ->GROUP BY (Nachname, Vorname);

Deduplizierung

Um doppelte Daten in einer Tabelle zu löschen, können Sie die folgende SQL-Anweisung verwenden:

mysql> CREATE TABLE tmp SELECT Nachname, Vorname, Geschlecht

 -> VONperson_tbl;

 -> GROUP BY (Nachname, Vorname);

mysql> DROP TABLE person_tbl;

mysql> ALTER TABLE tmp RENAME TO person_tbl;

Sie können der Datentabelle auch INDEX (Index) und PRIMAY KEY (Primärschlüssel) hinzufügen, um doppelte Datensätze in der Tabelle zu löschen. So geht's:

mysql> ALTER IGNORE TABLE person_tbl
 ->Primärschlüssel hinzufügen (Nachname, Vorname);

MySQL und SQL-Injection

Wenn Sonderzeichen nicht gefiltert werden, wird folgendes SQL angezeigt:

//Setzen Sie $name, um SQL-Anweisungen einzufügen, die wir nicht benötigen

$name = "Qadir';LÖSCHEN AUS Benutzern;";

mysql_query("SELECT * FROM Benutzer WHERE name='{$name}'");

In der obigen Injektionsanweisung haben wir die Variable $name nicht gefiltert und eine unnötige SQL-Anweisung in $name eingefügt, die alle Daten in der Benutzertabelle löscht.

Um SQL-Injection zu verhindern, achten Sie auf die folgenden Punkte:

1. Vertrauen Sie niemals Benutzereingaben. Zur Validierung der Benutzereingaben können Sie reguläre Ausdrücke verwenden oder die Länge begrenzen; einfache Anführungszeichen in doppelte „-“ usw. umwandeln.

2. Verwenden Sie niemals dynamische SQL-Assembly. Sie können parametrisiertes SQL verwenden oder direkt gespeicherte Prozeduren verwenden, um Daten abzufragen und darauf zuzugreifen.

3. Verwenden Sie niemals eine Datenbankverbindung mit Administratorrechten. Verwenden Sie für jede Anwendung eine separate Datenbankverbindung mit eingeschränkten Berechtigungen.

4. Speichern Sie vertrauliche Informationen nicht direkt und verschlüsseln oder hashen Sie Passwörter und sensible Informationen nicht.

5. Die Ausnahmeinformationen der Anwendung sollten so wenig Eingabeaufforderungen wie möglich enthalten. Am besten verwenden Sie benutzerdefinierte Fehlermeldungen, um die ursprünglichen Fehlerinformationen zu umschließen.

6. Die Erkennungsmethode für SQL-Injection verwendet im Allgemeinen Hilfssoftware oder Website-Plattformen zur Erkennung. Die Software verwendet im Allgemeinen das SQL-Injection-Erkennungstool jsky und die Website-Plattform verfügt über das Erkennungstool der Website-Sicherheitsplattform Yisi. MDCSOFT SCAN usw. Durch den Einsatz von MDCSOFT-IPS können Sie wirksam vor SQL-Injection, XSS-Angriffen usw. schützen.

In Skriptsprachen wie Perl und PHP können Benutzereingabedaten maskiert werden, um SQL-Injection zu verhindern.

Die MySQL-Erweiterung von PHP bietet die Funktion mysql_real_escape_string() zum Escapen spezieller Eingabezeichen.

wenn (get_magic_quotes_gpc())
{
 $name = Streifen Schrägstriche($name);
}

: $name = mysql_real_escape_string($name);
mysql_query("SELECT * FROM Benutzer WHERE name='{$name}'");

Injektion in Like-Anweisung

Wenn der Benutzer bei der Ausführung einer ähnlichen Abfrage Werte eingibt, die „_“ und „%“ enthalten, kann die folgende Situation auftreten: Der Benutzer wollte ursprünglich nur „abcd_“ abfragen, die Abfrageergebnisse enthielten jedoch „abcd_“, „abcde“, „abcdf“ usw.; Probleme können auch auftreten, wenn der Benutzer „30%“ (Anm.: dreißig Prozent) abfragen möchte.

In PHP-Skripten können wir die Funktion addcslashes() verwenden, um die obige Situation zu behandeln, wie im folgenden Beispiel gezeigt:

$sub =addcslashes(mysql_real_escape_string("%etwas_"), "%_");

// $sub == \%etwas\_

mysql_query("SELECT * FROM Nachrichten WHERE Betreff LIKE '{$sub}%'");

Die Funktion addcslashes() fügt vor dem angegebenen Zeichen einen Backslash hinzu.

Syntax:

addcslashes(Zeichenfolge,Zeichen)

MySQL-Exportdaten

Exportieren von Daten mit der Anweisung SELECT ... INTO OUTFILE

Exportieren Sie die Daten in der Datentabelle w3cschool_tbl in die Datei /tmp/tutorials.txt:

mysql> SELECT * FROM tutorials_tbl

-> IN DIE AUSGABEDATEI '/tmp/tutorials.txt';

Erzeugt eine Datei mit durch Kommas getrennten Werten. Dieses Format kann von vielen Programmen verwendet werden.

WÄHLEN Sie a, b, a + b in OUTFILE '/tmp/result.text'
FELDER, DIE DURCH ',' BEENDET WERDEN, OPTIONAL EINGESCHLOSSEN DURCH '"'
Mit '\n' abgeschlossene Zeilen
VON Testtabelle;

Die Anweisung SELECT ... INTO OUTFILE hat die folgenden Eigenschaften:

LOAD DATA INFILE ist die umgekehrte Operation der SELECT ... INTO OUTFILE, SELECT-Syntax. Um die Daten einer Datenbank in eine Datei zu schreiben, verwenden Sie SELECT ... INTO OUTFILE, und um die Datei wieder in die Datenbank einzulesen, verwenden Sie LOAD DATA INFILE.

Mit SELECT ... INTO OUTFILE 'Dateiname' können die ausgewählten Zeilen in eine Datei geschrieben werden. Die Datei wird auf dem Server-Host erstellt. Daher müssen Sie über das FILE-Privileg verfügen, um diese Syntax verwenden zu können.

Die Ausgabe kann keine vorhandene Datei sein. Verhindern Sie, dass Dateidaten manipuliert werden.

Sie benötigen ein Konto, um sich beim Server anzumelden und Dateien abzurufen. Andernfalls hat SELECT ... INTO OUTFILE keine Auswirkung.

Unter UNIX wird die Datei so erstellt, dass sie lesbar ist und über die Berechtigungen des MySQL-Servers verfügt. Dies bedeutet, dass Sie die Datei zwar lesen können, sie jedoch möglicherweise nicht löschen können.

Tabelle als Rohdaten exportieren

mysqldump ist ein von MySQL verwendetes Dienstprogramm zum Sichern von Datenbanken.

Exportieren Sie die Tabelle „tutorials_tbl“ in das Verzeichnis /tmp:

$ mysqldump -u root -p --no-create-info \

--tab=/tmp W3CSCHOOL w3cschool_tbl

Passwort ******

Um die gesamte Datenbank zu exportieren, können Sie den folgenden Befehl verwenden:

$ mysqldump -u root -pW3CSCHOOL > database_dump.txt

Passwort ******

Um alle Datenbanken zu sichern, können Sie den folgenden Befehl verwenden:

$ mysqldump -u root -p --all-databases > database_dump.txt

Passwort ******

Geben Sie den Datenbanknamen und die Tabelle im Befehl mysqldump an.

Führen Sie den folgenden Befehl auf dem Quellhost aus, um die Daten in der Datei dump.txt zu sichern:

$ mysqldump -u root -pdatabase_name table_name> dump.txt

Passwort *****

Importieren Sie die gesicherte Datenbank in den MySQL -Server.

$ mysql -u root -pdatabase_name <Dump.txt Passwort *****

Der folgende Befehl importiert die exportierten Daten direkt in den Remote -Server. Bitte stellen Sie jedoch sicher, dass die beiden Server verbunden sind und auf einander zugreifen können: </p>

$ mysqldump -u root -pdatabase_name \

|.

MySQL -Importdaten

Lesen Sie den Datei -Dump.txt aus dem aktuellen Verzeichnis und fügen Sie die Daten in die Datei in die mytbl -Tabelle der aktuellen Datenbank ein.

MySQL> Datalocal Infile 'Dump.txt' in Tabelle mytbl laden;

Wenn der Benutzer eine FIELDS-Klausel angibt, sind deren Klauseln (TERMINATED BY, [OPTIONALLY] ENCLOSED BY und ESCAPED BY) ebenfalls optional, der Benutzer muss jedoch mindestens eine davon angeben.

mysql> laden datalocal infile 'Dump.txt' in Tabelle mytbl

-> FELDER MIT ':' ABGESCHLOSSEN

-> ZEILEN, DIE DURCH „\r\n“ BEENDET WERDEN;

Gibt die Reihenfolge der Spalten an.

Beispielsweise lautet die Spaltenreihenfolge in der Datendatei a, b, c, aber die Spaltenreihenfolge in der Einfügetabelle lautet b, c, a. Die Syntax für den Datenimport lautet wie folgt:

MySQL> Datalocal Infile 'Dump.txt' laden Sie

-> IN TABELLE mytbl (b, c, a);

Daten mit MySQLimport importieren

Der MySQLimport-Client bietet eine Befehlszeilenschnittstelle zur Anweisung loadData InfileQL. Die meisten Optionen für mysqlimport entsprechen direkt der Klausel LOAD DATA INFILE.

Um Daten aus der Datei dump.txt in die Tabelle mytbl zu importieren, verwenden Sie den folgenden Befehl:

$ mysqlimport -U root -p - -local database_name Dump.txt

Passwort *****

Der Befehl mysqlimport kann Optionen angeben, um das angegebene Format festzulegen. Das Format der Befehlsanweisung lautet wie folgt:

$ mysqlimport -U root-p--lokal-fields-termined-by = ":" \

-lines-termined-by = "\ r \ n" Database_name Dump.txt

Passwort *****

Verwenden Sie die Option --columns in der mysqlimport-Anweisung, um die Reihenfolge der Spalten festzulegen:

$ mysqlimport -u root -p - -local --Säulen = B, C, A \

Database_Name Dump.txt

Passwort *****