Vollständige MySQL-Collapse-Abfrage, reguläre Übereinstimmung, ausführliche Erklärung

Vollständige MySQL-Collapse-Abfrage, reguläre Übereinstimmung, ausführliche Erklärung

Überblick

Im vorherigen Kapitel haben wir die Filterbedingungen für Abfragen kennengelernt. Wir haben gelernt, dass MySQL mithilfe des Platzhalters „like %“ ein Fuzzy-Matching durchführen kann. Ebenso unterstützt es auch das Abgleichen anderer regulärer Ausdrücke. Wir verwenden den REGEXP-Operator in MySQL, um das Abgleichen regulärer Ausdrücke durchzuführen. Nutzung und Likes

Ähnlich wie , aber viel leistungsfähiger und kann einige sehr spezielle und komplexe Regelübereinstimmungen erreichen. Wenn der reguläre Ausdruck mit dem Befehl REGEXP abgeglichen wird, wird 1 zurückgegeben, wenn die Übereinstimmung wahr ist, und 0, wenn die Übereinstimmung nicht wahr ist. Wenn standardmäßig keine Übereinstimmungsregeln hinzugefügt werden, entspricht REGEXP etwa „%%“. Das Hinzufügen von NOT am Anfang (NOT REGEXP) entspricht NOT LIKE.

Matching-Musteranalyse

In der folgenden Tabelle sind die Übereinstimmungsmuster für reguläre Ausdrücke aufgelistet, die auf den REGEXP-Operator angewendet werden können. Die Beschreibung ist relativ detailliert. Wir werden sie später einzeln testen.


Passendes Muster

beschreiben

^

Stimmt mit dem Anfang der Eingabezeichenfolge überein. Wenn die Eigenschaft „Multiline“ des REGEXP-Objekts gesetzt ist, entspricht ^ auch der Position nach „\n“ oder „\r“.

$

Stimmt mit dem Ende der Eingabezeichenfolge überein. Wenn die Eigenschaft „Multiline“ des REGEXP-Objekts gesetzt ist, entspricht „$“ auch der Position vor „\n“ oder „\r“.

.

Stimmt mit jedem einzelnen Zeichen außer "\n" überein. Um jedes Zeichen einschließlich „\n“ abzugleichen, verwenden Sie das Muster „[.\n]“.

[….]

Eine Sammlung von Charakteren. Stimmt mit einem beliebigen der enthaltenen Zeichen überein. Beispielsweise kann „[abc]“ mit „a“ in „plain“ übereinstimmen.

[^...]

Die Menge der nicht übereinstimmenden Zeichen. Stimmt mit jedem Zeichen überein, das nicht in der Zeichenfolge enthalten ist. Beispielsweise kann „[^abc]“ mit dem „p“ in „plain“ übereinstimmen.

[nm]

Stimmt mit jedem einzelnen Zeichen zwischen m und n überein, wie etwa [0-9], [az], [AZ]

*

Stimmt null oder mehrmals mit dem vorhergehenden Unterausdruck überein. Beispielsweise entspricht a* den Begriffen „a“ und „ab“. * Entspricht {0,}.

+

Stimmt ein- oder mehrmals mit dem vorhergehenden Unterausdruck überein. Beispielsweise entspricht „a+“ den Begriffen „ab“ und „abc“, aber nicht „a“. + ist gleichbedeutend mit {1,}.

?

Stimmt ein- oder mehrmals mit dem vorhergehenden Unterausdruck überein. Beispielsweise entspricht „a?“ sowohl „ab“ als auch „a“. ? ist gleichwertig mit {0,1}.

a1|a2|a3

Stimmt mit a1 oder a2 oder a3 überein. Beispielsweise entspricht „z|food“ „z“ oder „food“. „(z|f)ood“ passt zu „zood“ oder „food“.

{N}

n ist eine nicht negative Ganzzahl. Stimmt mit einer bestimmten Anzahl von Malen überein. Beispielsweise entspricht 'o{2}' nicht dem 'o' in „Bob“, wohl aber den beiden o's in „food“.

{N,}

Stimmt mit dem vorhergehenden Unterausdruck n bis mehrmals überein. Beispielsweise trifft 'o{2,}' nicht nur auf „food“, sondern auch auf „foood“ zu.

{n,m}

n und m sind beide nicht-negative ganze Zahlen, wobei n <= m. Stimmt mindestens n-mal und höchstens m-mal überein.

{,M}

Entspricht dem vorhergehenden Teilausdruck 0 bis m Mal

(….)

Elementkombination, d. h. das Kombinieren von Musterelementen zu einem einzigen Element, z. B. (do)* bedeutet Übereinstimmung mit 0 oder mehr do

Passendes Muster

Ordnet den ersten Teil der Zeichenfolge zu. Dies entspricht der Zeichenfolge, die mit s beginnt. Bei Übereinstimmung wird 1 zurückgegeben. Bei Nichtübereinstimmung wird 0 zurückgegeben. Auf die Tabelle angewendet, gibt es die passenden Daten zurück.

mysql> wähle 'selina' REGEXP '^s';
+----------------------+
| 'selina' REGEXP '^s' |
+----------------------+
| 1 |
+----------------------+
1 Reihe im Set

mysql> wähle 'aelina' REGEXP '^s';
+----------------------+
| 'aelina' REGEXP '^s' |
+----------------------+
| 0 |
+----------------------+
1 Reihe im Set
mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+----------+-----+
5 Reihen im Set

mysql> Auswahl * von Benutzer2, wobei Name REGEXP '^s' ist;
+----+--------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+---------+-----+
| 3 | Sol | 21 | Xiamen | 0 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+---------+-----+
2 Reihen im Set

Passendes Muster $

Übereinstimmung vom Ende der Zeichenfolge aus. Dies stimmt mit Daten überein, deren Name mit d endet.

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+----------+-----+
5 Reihen im Set

mysql> Auswahl * von Benutzer2, wobei Name REGEXP 'd$' ist;
+----+-------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+---------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
+----+-------+-----+---------+-----+
1 Reihe im Set

Passendes Muster.

. entspricht jedem einzelnen Zeichen. Das folgende Skript entspricht n gefolgt von einem beliebigen Zeichen.

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+----------+-----+
5 Reihen im Set

mysql> wähle * von Benutzer2, wobei Name REGEXP 'n.' ist;
+----+--------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+---------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+---------+-----+
3 Reihen im Set

Passendes Muster [...]

Dies bedeutet, dass jedes einzelne Zeichen in den Klammern übereinstimmt, solange mindestens ein Zeichen die Bedingungen erfüllt. Im folgenden Beispiel können nur die Namen brand und weng mit b, w und z übereinstimmen.

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+----------+-----+
5 Reihen im Set

mysql> wähle * von Benutzer2, wobei Name REGEXP [bwz] ist;
1064 - Ihre SQL-Syntax weist einen Fehler auf. Überprüfen Sie im Handbuch zu Ihrer MySQL-Serverversion, welche Syntax in der Nähe von „[bwz]“ in Zeile 1 zu verwenden ist.
mysql> wähle * von Benutzer2, wobei Name REGEXP '[bwz]' ist;
+----+-------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+---------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 4 | weng | 33 | guizhou | 1 |
+----+-------+-----+---------+-----+
2 Reihen im Set

Passendes Muster [^...]

[^...] bedeutet, dass jedes Zeichen übereinstimmt, das nicht in der Zeichenfolge enthalten ist. Beispielsweise kann „[^brand]“ mit „h“ in „helen“, „s“ in „sol“, „w“ in „weng“ und „s“ in „selina“ übereinstimmen, aber nicht mit „brand“ und wird daher herausgefiltert.

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+----------+-----+
5 Reihen im Set

mysql> wähle * von Benutzer2, wobei Name REGEXP '[^Marke]' ist;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+----------+-----+
4 Reihen im Set

Anpassungsmodus [nm]

Stimmt mit jedem einzelnen Zeichen zwischen m und n überein, wie beispielsweise [0-9], [az], [AZ]. Im folgenden Code wird jedes Element „sol“, das nicht zwischen a - e liegt, herausgefiltert.

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+----------+-----+
5 Reihen im Set

mysql> wähle * von Benutzer2, wobei Name REGEXP '[ae]' ist;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+----------+-----+
4 Reihen im Set

Passendes Muster*

Stimmt null oder mehrmals mit dem vorhergehenden Unterausdruck überein. Beispielsweise entspricht a* den Begriffen „a“ und „ab“. * Entspricht {0,}. Das folgende „e*g“ passt nur zum Namen „weng“.

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+----------+-----+
5 Reihen im Set

mysql> Auswahl * von Benutzer2, wobei Name REGEXP 'zB' ist;
+----+------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+------+-----+---------+-----+
| 4 | weng | 33 | guizhou | 1 |
+----+------+-----+---------+-----+
1 Reihe im Set

Matching-Modus+

Stimmt ein- oder mehrmals mit dem vorhergehenden Unterausdruck überein. Beispielsweise entspricht „a+“ den Begriffen „ab“ und „abc“, aber nicht „a“. + ist gleichbedeutend mit {1,}. Wie im folgenden Skript gezeigt, werden die Bedingungen durch eine Kombination aus 1 bis mehr als n plus einem d erfüllt, und nur „Marke“ und „annd“ erfüllen die Bedingungen.

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
| 6 | anny | 23 | shanghai | 0 |
| 7 | und | 24 | shanghai | 1 |
+----+--------+-----+----------+-----+
7 Reihen im Set

mysql> Auswahl * von Benutzer2, wobei Name REGEXP 'n+d' ist;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 7 | und | 24 | shanghai | 1 |
+----+-------+-----+----------+-----+
2 Reihen im Set

Matching-Modus?

Stimmt ein- oder mehrmals mit dem vorhergehenden Unterausdruck überein. Beispielsweise entspricht „a?“ den Wörtern „ab“ und „a“. ? ist gleichwertig mit {0,1}. e ist 1 oder 0 und wird dann durch l eingeschränkt, sodass es nur drei gibt, die die Anforderungen erfüllen.

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
| 6 | anny | 23 | shanghai | 0 |
| 7 | und | 24 | shanghai | 1 |
+----+--------+-----+----------+-----+
7 Reihen im Set

mysql> Auswahl * von Benutzer2, wobei Name REGEXP 'e?l' ist;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+----------+-----+
3 Reihen im Set

Entspricht dem Muster a1|a2|a3

Stimmt mit a1 oder a2 oder a3 überein. Beispielsweise kann „nn|en“ unten jeweils mit „anny“, „annd“ und „helen“, „weng“ übereinstimmen.

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
| 6 | anny | 23 | shanghai | 0 |
| 7 | und | 24 | shanghai | 1 |
+----+--------+-----+----------+-----+
7 Reihen im Set

mysql> Auswahl * von Benutzer2, wobei Name REGEXP 'nn|en' ist;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 2 | Helen | 20 | Quanzhou | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 6 | anny | 23 | shanghai | 0 |
| 7 | und | 24 | shanghai | 1 |
+----+-------+-----+----------+-----+
4 Reihen im Set

Entspricht dem Muster {n} {n,} {n,m} {,m}

n und m sind beide nicht-negative ganze Zahlen, wobei n <= m. Stimmt mindestens n-mal und höchstens m-mal überein. m ist leer und stellt jede Zahl >= n dar, und n ist leer und stellt 0 dar.

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
| 6 | anny | 23 | shanghai | 0 |
| 7 | und | 24 | shanghai | 1 |
+----+--------+-----+----------+-----+
7 Reihen im Set

mysql> wähle * von Benutzer2, wobei Name REGEXP 'n{2}' ist;
+----+------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+------+-----+----------+-----+
| 6 | anny | 23 | shanghai | 0 |
| 7 | und | 24 | shanghai | 1 |
+----+------+-----+----------+-----+
2 Reihen im Set

mysql> wähle * von Benutzer2, wobei Name REGEXP 'n{1,2}' ist;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
| 6 | anny | 23 | shanghai | 0 |
| 7 | und | 24 | shanghai | 1 |
+----+--------+-----+----------+-----+
6 Reihen im Set

mysql> wähle * von Benutzer2, wobei Name REGEXP 'l{1,}' ist;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+----------+-----+
3 Reihen im Set

Entspricht einem Muster(...)

Angenommen, der Inhalt der Klammern ist abc, wird abc als Ganzes abgeglichen und die Daten, die dieser Regel entsprechen, werden herausgefiltert. Nehmen wir als Beispiel und kombinieren wir es mit dem oben erworbenen Wissen.

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | selina | 25 | NULL | 0 |
| 6 | anny | 23 | shanghai | 0 |
| 7 | und | 24 | shanghai | 1 |
+----+--------+-----+----------+-----+
7 Reihen im Set

mysql> wähle * von Benutzer2, wobei Name REGEXP '(an)+' ist;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 6 | anny | 23 | shanghai | 0 |
| 7 | und | 24 | shanghai | 1 |
+----+-------+-----+----------+-----+
3 Reihen im Set

mysql> wähle * von Benutzer2, wobei Name REGEXP '(ann)+' ist;
+----+------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+------+-----+----------+-----+
| 6 | anny | 23 | shanghai | 0 |
| 7 | und | 24 | shanghai | 1 |
+----+------+-----+----------+-----+
2 Reihen im Set

mysql> wähle * von Benutzer2, wobei Name REGEXP '(an).*d{1,2}' ist;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 7 | und | 24 | shanghai | 1 |
+----+-------+-----+----------+-----+
2 Reihen im Set

Entspricht den Sonderzeichen \\

Die reguläre Ausdruckssprache besteht aus Sonderzeichen, die bestimmte Bedeutungen haben. Wir haben ., [], |, *, + usw. gesehen. Wie gleichen wir diese Zeichen ab? Im folgenden Beispiel verwenden wir \\ zum Abgleichen mit Sonderzeichen, \\ ist das führende Zeichen, \\- bedeutet die Suche nach - und \\. bedeutet die Suche nach ..

mysql> wähle * von Benutzer3;
+----+------+-------+
| ID | Alter | Name |
+----+------+-------+
| 1 | 20 | Marke |
| 2 | 22 | Sol |
| 3 | 20 | Helene |
| 4 | 19,5 | klein |
+----+------+-------+
4 Reihen im Set

mysql> wähle * von Benutzer3, wobei Alter REGEXP '[0-9]+\\.[0-9]+' ist;
+----+------+------+
| ID | Alter | Name |
+----+------+------+
| 4 | 19,5 | klein |
+----+------+------+
1 Reihe im Set

Zusammenfassen

1. Wenn wir Daten mit regulären Ausdrücken abgleichen müssen, können wir die Operatoren REGEXP und NOT REGEXP verwenden (ähnlich wie LIKE und NOT LIKE);

2. Bei REGEXP wird die Groß-/Kleinschreibung standardmäßig nicht berücksichtigt, Sie können jedoch das Schlüsselwort BINARY verwenden, um die Groß-/Kleinschreibung zu erzwingen: WHERE NAME REGEXP BINARY '^[AZ]';

3. REGEXP verwendet standardmäßig eine teilweise Übereinstimmung, d. h. es gibt „true“ zurück, wenn eine Übereinstimmung vorliegt. Beispiel: SELECT 'A123' REGEXP BINARY '[AZ]' gibt 1 zurück;

4. Wenn Sie () zum Abgleichen verwenden, wird der Inhalt innerhalb der Klammern als Ganzes abgeglichen. Beispielsweise muss (ABC) mit dem gesamten ABC übereinstimmen.

5. Dies ist nur eine Einführung in die Grundlagen regulärer Ausdrücke. Wenn Sie ein tieferes Verständnis wünschen, können Sie das Tutorial zu regulären Ausdrücken zu Rate ziehen, das meiner Meinung nach gut geschrieben ist.

Dies ist das Ende dieses Artikels mit der detaillierten Erklärung der regulären Übereinstimmung für MySQL-Abfragen. Weitere Informationen zur regulären Übereinstimmung für MySQL-Abfragen finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!

Das könnte Sie auch interessieren:
  • So verwenden Sie reguläre Ausdrucksabfragen in MySQL
  • MySQL-Abfrage mit regulären Ausdrücken enthält Datensätze, die keine Ziffern oder Zeichen sind
  • So verwenden Sie reguläre Ausdrucksabfragen in MySql
  • Detaillierte Erläuterung der MySql-Basisabfrage, Join-Abfrage, Unterabfrage und regulären Ausdrucksabfrage
  • Zusammenfassung klassischer Beispiele für MySQL-Abfrageoperationen mit regulären Ausdrücken
  • Offizielles MySql-Handbuch, Studiennotizen 2 MySql-Fuzzy-Abfrage und regulärer Ausdruck

<<:  Methoden und Schritte zum Bereitstellen einer GitLab-Umgebung basierend auf Docker

>>:  Details zur Verwendung von JS-Array-Methoden some, every und find

Artikel empfehlen

OpenSSL-Zertifikate in der Linux-Umgebung generieren

1. Umgebung: CentOS7, Openssl1.1.1k. 2. Konzept: ...

So installieren Sie Docker unter CentOS und veröffentlichen Docker remote in Springboot

Inhaltsverzeichnis 1. Installation von JDK1.8 unt...

js implementiert Array-Abflachung

Inhaltsverzeichnis So reduzieren Sie ein Array 1....

Eine kurze Diskussion über den virtuellen Speicher von Linux

Inhaltsverzeichnis Herkunft Virtueller Speicher P...

Lernen Sie die Grundlagen von nginx

Inhaltsverzeichnis 1. Was ist nginx? 2. Was kann ...

Hintergrundbild-Cache unter IE6

Fehler beim Flackern des CSS-Hintergrundbilds in ...

Das Vue-Cropper-Plugin realisiert die Kapselung der Bildaufnahme- und Upload-Komponente

Der spezifische Code zum Einkapseln der Bildaufna...

Implementierung von verschiebbaren Zeilen und Spalten sowie Auswahlspaltenkomponenten basierend auf der el-table-Kapselung

Wirkung Brauchen Sie eine Umgebung Ansicht elemen...

Analyse des Implementierungsprozesses der Docker-Intranet-Penetration-FRP-Bereitstellung

1. Erstellen Sie ein Konfigurationsdateiverzeichn...

Unterschied zwischen MySQL Btree-Index und Hash-Index

In MySQL werden die meisten Indizes (wie PRIMARY ...

MySQL-Partitionierungspraxis mit Navicat

MySQL-Partitionierung ist hilfreich bei der Verwa...

Implementierung von FIFO in der Linux-Prozesskommunikation

FIFO-Kommunikation (First In First Out) FIFO-Name...

Detaillierte Einführung in Robots.txt

Robots.txt ist eine reine Textdatei, in der Websi...

Einführung in Docker-Container

Docker-Übersicht Docker ist eine Open-Source-Lösu...

JavaScript zum Erzielen eines Fensteranzeigeeffekts

In diesem Artikel wird der spezifische JavaScript...