1. Bitfunktionen
Für Bitoperationen verwendet MySQL den BIGINT-Algorithmus (64-Bit), sodass der maximale Bereich dieser Operatoren 64 Bit beträgt.
|
Bitweise ODER:
MYSQL> 15;
-> Bit-Ganzzahl ohne Vorzeichen.
&
Bitweise UND:
mysql> SELECT 29 & 15;
-> Das Ergebnis ist eine 64 Bit-Ganzzahl ohne Vorzeichen.
^
Bitweises XOR:
SELECT 1 ^ 1; 0;
MySQL> 11 ^ 3;
-> 8
Das Ergebnis ist eine 64-Bit-Ganzzahl ohne Vorzeichen.
<<
Verschiebt eine Longlong-Zahl (BIGINT) um zwei Stellen nach links.
mysql> SELECT 1 << 2;
-> 4
Das Ergebnis ist eine 64-Bit-Ganzzahl.
>>
Verschieben Sie eine Longlong-Zahl (BIGINT) um zwei Stellen nach rechts.
mysql> SELECT 4 >> 2;
-> 1
Das Ergebnis ist eine 64-Bit-Ganzzahl.
~
Alle Bits invertieren.
mysql> SELECT 5 & ~1;
-> 4
Das Ergebnis ist eine 64-Bit-Ganzzahl.
BIT_COUNT(N)
Gibt die Anzahl der im Parameter N eingestellten Bits zurück
mysql> SELECT BIT_COUNT(29);
-> 🎜>
2. Verschlüsselungsfunktion In diesem Abschnitt werden Verschlüsselung und verschlüsselte Werte vorgestellt. Wenn Sie einige von kryptografischen Funktionen zurückgegebene Ergebnisse speichern möchten, die beliebige Bytewerte enthalten können, verwenden Sie BLOB-Spalten anstelle von CHAR- oder VARCHAR-Spalten, um das potenzielle Problem der Änderung einiger Datenwerte aufgrund der Entfernung nachfolgender Leerzeichen zu vermeiden. AES_ENCRYPT(str,key_str) , AES_DECRYPT(crypt_str,key_str)Diese Funktionen ermöglichen die Verschlüsselung und Datenverschlüsselung mit dem offiziellen AES-Algorithmus (Advanced Encryption Standard), früher bekannt als „Rijndael“. Die Länge des geheimen Schlüssels beträgt 128 Bit, Sie können ihn jedoch durch Ändern der Quelle auf 256 Bit erweitern. Wir haben uns für 128 Bit entschieden, weil es viel schneller ist und dieser Grad an Vertraulichkeit für die meisten Zwecke ausreichend ist. Eingabeparameter können beliebig lang sein. Wenn ein Parameter NULL ist, ist auch das Ergebnis der Funktion NULL. Da es sich bei AES um einen Algorithmus auf Blockebene handelt, wird Padding verwendet, um Zeichenfolgen mit unausgeglichener Länge zu codieren, sodass die Länge der resultierenden Zeichenfolge 16 * (trunc(string_length / 16) 1) beträgt. Wenn AES_DECRYPT() ungültige Daten oder falsche Auffüllung erkennt, wird NULL zurückgegeben. Wenn die eingegebenen Informationen oder das Passwort jedoch ungültig sind, gibt AES_DECRYPT() möglicherweise einen Wert ungleich NULL zurück (bei dem es sich möglicherweise um nutzlose Informationen handelt). Sie können die AES-Funktion verwenden, um die Daten in verschlüsselter Form zu speichern, indem Sie Ihre Abfrage ändern: INSERT INTO t VALUES (1,AES_ENCRYPT('text','password')) ;AES_ENCRYPT() und AES_DECRYPT() können als die sichersten Verschlüsselungsfunktionen für universelle Passwörter in MySQL angesehen werden. DECODE(crypt_str,pass_str)Verwenden Sie pass_str als Passwort, um die verschlüsselte Zeichenfolge crypt_str zu entschlüsseln. crypt_str sollte die von ENCODE() zurückgegebene Zeichenfolge sein. ENCODE(str,pass_str)Verwenden Sie pass_str als Passwort, um str zu entschlüsseln. Verwenden Sie DECODE(), um das Ergebnis zu entschlüsseln. Das Ergebnis ist eine binäre Zeichenfolge mit der gleichen Länge wie str. Wenn Sie es in einer Spalte behalten möchten, verwenden Sie den Spaltentyp BLOB. DES_DECRYPT(crypt_str[,key_str])Verwenden Sie DES_ENCRYPT(), um eine Zeichenfolge zu verschlüsseln. Wenn ein Fehler auftritt, gibt diese Funktion NULL zurück. Beachten Sie, dass diese Funktion nur funktioniert, wenn MySQL mit SSL-Unterstützung konfiguriert ist. Wenn der Parameter key_str nicht angegeben ist, überprüft DES_DECRYPT() zunächst das erste Byte der verschlüsselten Zeichenfolge, um die DES-Verschlüsselungsschlüsselnummer zu ermitteln, die zum Verschlüsseln der ursprünglichen Zeichenfolge verwendet wurde, und ruft sie dann aus der DES-Schlüsseldatei ab Lesen Sie die Schlüsselwörter, um die Informationen zu entschlüsseln. Damit es ausgeführt werden kann, muss der Benutzer über SUPER-Berechtigungen verfügen. Sie können --des-key-file server wählen, um die Schlüsseldatei anzugeben. Wenn Sie einen key_str-Parameter an diese Funktion übergeben, wird die Zeichenfolge als Schlüssel zum Entschlüsseln der Nachricht verwendet. Wenn der Parameter crypt_str keine verschlüsselte Zeichenfolge zu sein scheint, gibt MySQL den angegebenen crypt_str zurück. DES_ENCRYPT(str[,(key_num|key_str)])Verschlüsseln Sie die Zeichenfolge mit den vom Triple-DES-Algorithmus angegebenen Schlüsselwörtern. Wenn ein Fehler auftritt, gibt diese Funktion NULL zurück. Beachten Sie, dass diese Funktion nur ausgeführt wird, nachdem MySQL mit SSL-Unterstützung konfiguriert wurde. Die Wahl des zu verwendenden Verschlüsselungsschlüsselworts basiert auf dem zweiten Argument von DES_ENCRYPT(), gegeben: ParameterbeschreibungKeine Parameter. Verwenden Sie das erste Schlüsselwort aus der DES-Schlüsselwortdatei.
key_num verwendet die Schlüsselnummer (0-9), die in der DES-Schlüsselwortdatei angegeben ist.
key_str Verschlüsselt str mit der angegebenen Schlüsselwortzeichenfolge.
Wählen Sie --des-key-file server, um die Schlüsselwortdatei anzugeben.
Die zurückgegebene Zeichenfolge ist eine binäre Zeichenfolge, wobei das erste Zeichen CHAR(128 | key_num) ist.
Plus 128 erleichtert die Identifizierung verschlüsselter Schlüsselwörter. Wenn Sie einen Zeichenfolgenschlüssel verwenden, ist key_num 127.
Die resultierende Stringlänge ist new_len = orig_len (8-(orig_len % 8)) 1.
Jede Zeile in der DES-Schlüsselwortdatei hat das folgende Format:
key_num des_key_str
Jede key_num muss eine Zahl im Bereich von 0 bis 0 sein. Die Reihenfolge der Zeilen in der Datei ist beliebig. des_key_str ist die Zeichenfolge, die zum Verschlüsseln von Informationen verwendet wird. Zwischen der Zahl und dem Schlüsselwort sollte mindestens ein Leerzeichen stehen. Wenn Sie für DES_ENCRYPT() keine Schlüsselwortargumente angeben, ist das erste Schlüsselwort das verwendete Standardschlüsselwort.
Mit der FLUSH DES_KEY_FILE-Anweisung können Sie MySQL neue Schlüsselwerte aus der Schlüsseldatei lesen lassen. Dazu ist es erforderlich, dass Sie über die RELOAD-Berechtigung verfügen.
Ein Vorteil eines Standardsatzes von Schlüsselwörtern besteht darin, dass er Anwendungen die Möglichkeit bietet, verschlüsselte Spaltenwerte zu überprüfen, ohne dem Endbenutzer die Möglichkeit zu geben, diese Werte zu entschlüsseln.
mysql> SELECT customer_address FROM customer_table
> WHERE crypted_credit_card = DES_ENCRYPT('credit_card_number');
ENCRYPT(str[,salt])
Verschlüsseln Sie str mit dem Unix-Systemaufruf crypt(). Der Salt-Parameter sollte eine Zeichenfolge mit mindestens 2 Zeichen sein. Wenn der Salt-Parameter nicht angegeben ist, wird ein beliebiger Wert verwendet.
mysql> SELECT ENCRYPT('hello');
-> 'VxuFAJXVARROc'
Zumindest in einigen Systemen ist ENCRYPT() mit Ausnahme der ersten acht Zeichen von str Alles andere wird ignoriert. Dieses Verhalten wird durch die Ausführung des unterstrichenen Systemaufrufs crypt() bestimmt.
Wenn crypt() auf Ihrem System nicht verfügbar ist (wie unter Windows), gibt ENCRYPT() immer NULL zurück. Aus diesem Grund empfehlen wir Ihnen stattdessen die Verwendung von MD5() oder SHA1(), da diese beiden Funktionen für alle Plattformen geeignet sind.
MD5(str)
Berechnet eine MD5-128-Bit-Prüfsumme für eine Zeichenfolge. Der Wert wird als binäre Zeichenfolge mit 32 Hexadezimalziffern zurückgegeben. Wenn der Parameter NULL ist, wird NULL zurückgegeben. Der Rückgabewert kann beispielsweise als Hash-Schlüssel verwendet werden.
mysql> SELECT MD5('testing');
-> 'ae2b1fca515949e5d54fb22b8ed95575'
Dies ist „RSA Data Security, Inc. MD5 Message-Digest-Algorithmus.“
Wenn Sie diesen Wert in Großbuchstaben umwandeln möchten, sehen Sie sich die Binärzeichenfolgenkonvertierung im Element BINARY-Operator unter „Cast-Funktionen und Operatoren“ an.
OLD_PASSWORD(str)
Wenn die Implementierung von PASSWORD() zur Verbesserung der Sicherheit geändert wird, wird OLD_PASSWORD() zu MySQL hinzugefügt. OLD_PASSWORD() gibt den Wert der alten PASSWORD()-Implementierung (vor 4.1) zurück und ermöglicht Ihnen gleichzeitig das Festlegen von Passwörtern für alle Clients vor 4.1, die eine Verbindung zu Ihrem 5.1-MySQL-Server herstellen müssen, ohne diese zu unterbrechen.
PASSWORD(str)
Berechnen Sie die Passwortzeichenfolge aus der ursprünglichen Passwortzeichenfolge und geben Sie sie zurück. Wenn der Parameter NULL ist, wird NULL zurückgegeben. Diese Funktion wird verwendet, um verschlüsselte MySQL-Passwörter in der Spalte „Passwort“ der Benutzerautorisierungstabelle zu speichern.
mysql> Verschlüsselung ist einseitig (irreversibel).
PASSWORD() führt die Passwortverschlüsselung anders durch als Unix-Passwörter verschlüsselt werden. Siehe ENCRYPT().
Hinweis: Die Funktion PASSWORD() wird vom Authentifizierungssystem in MySQL Server verwendet. Sie sollten sie nicht in Ihren eigenen Anwendungen verwenden. Um denselben Zweck zu erreichen, kann stattdessen MD5() oder SHA1() verwendet werden. Weitere Informationen zum Umgang mit Passwörtern und zur Authentifizierung in Ihrer Anwendung finden Sie unter RFC 2195. Wie in RFC 3174 (Secure Hash Algorithms) beschrieben. Der Wert wird als 40-stellige Hexadezimalzahl oder als NULL zurückgegeben, wenn das Argument NULL ist. Eine mögliche Verwendung dieser Funktion ist die Verwendung als Hash-Schlüssel. Sie können es auch als passwortsichere Funktion zum Speichern von Passwörtern verwenden.
mysql> SHA() und SHA1() haben die gleiche Bedeutung.
3. Informationsfunktion
BENCHMARK(count,expr)
Die Funktion BENCHMARK() wiederholt die Zählung, um den Ausdruck expr auszuführen. Damit lässt sich berechnen, wie schnell MySQL Ausdrücke verarbeitet. Der resultierende Wert ist normalerweise 0. Eine weitere Verwendung erfolgt innerhalb des MySQL-Clients, der die Anzahl der Abfrageausführungen melden kann:
mysql> SELECT BENCHMARK(1000000,ENCODE('hello','goodbye'));
+----------------------------------------------+ | BENCHMARK(1000000,ENCODE('hello','goodbye')) | +----------------------------------------------+ | 0 | +----------------------------------------------+ 1 row in set (4.74 sec)
Die hier gemeldete Zeit ist die gemeinsame Zeit auf dem Client, nicht die CPU-Zeit auf dem Server . Es wird empfohlen, BENCHMARK() mehrmals auszuführen und die Ergebnisse im Verhältnis zur Auslastung des Serverrechners zu interpretieren.
· CHARSET(str)
Gibt den Zeichensatz des String-Arguments zurück.
mysql> SELECT CHARSET('abc'); -> 'latin1' mysql> SELECT CHARSET(CONVERT('abc' USING utf8)); -> 'utf8' mysql> SELECT CHARSET(USER()); -> 'utf8'
· COERCIBILITY(str)
Gibt den ganzzahligen Kompressibilitätswert des String-Arguments zurück.
mysql> SELECT COERCIBILITY('abc' COLLATE latin1_swedish_ci); -> 0 mysql> SELECT COERCIBILITY(USER()); -> 3 mysql> SELECT COERCIBILITY('abc'); -> 4
Der Rückgabewert hat folgende Bedeutung:
Kompressibilität Bedeutung Beispiel
0 Explizite Sortierung Wert mit COLLATE-Klausel
1 Keine Sortierung String-Verkettung mit unterschiedlicher Sortierung
2 Explizite Sortierung Spaltenwert
3 Systemkonstante USER() Rückgabewert
4 Komprimierbare Literalzeichenfolge
5 Kann ignoriert werden NULL oder ein von NULL abgeleiteter Ausdruck
Der folgende Wert hat eine höhere Priorität.
COLLATION(str)
Gibt die Sortiermethode von String-Parametern zurück.
mysql> SELECT COLLATION('abc');
-> 'latin1_swedish_ci'
mysql> SELECT COLLATION(_utf8'abc'); utf8_general_ci'
CONNECTION_ID()
Gibt die Verbindungs-ID (Thread-ID) für die Verbindung zurück. Jede Verbindung hat ihre eigene eindeutige ID.
mysql> SELECT CONNECTION_ID();
-> 23786
CURRENT_USER, CURRENT_USER()
Gibt den authentifizierten Benutzernamen und Host der aktuellen Sitzung zurück Namenskombination. Dieser Wert entspricht dem MySQL-Konto, das Ihre Zugriffsrechte bestimmt. Innerhalb einer gespeicherten Prozedur, der das Merkmal SQL SECURITY DEFINER zugewiesen ist, gibt CURRENT_USER() den Ersteller der Prozedur zurück.
Der Wert von CURRENT_USER() kann sich vom Wert von USER() unterscheiden.
mysql> SELECT USER();
-> 'davida@localhost'
mysql> SELECT * FROM mysql.user;
ERROR 1044 : Zugriff für Benutzer ''@'localhost' auf
Datenbank 'mysql'
mysql> SELECT CURRENT_USER();
-> >
Dieses Beispiel erklärt, dass, obwohl der Client einen Davida-Benutzernamen angegeben hat (wie durch den Wert der USER()-Funktion angezeigt), der Server den Client mithilfe eines anonymen Benutzerkontos authentifiziert hat (siehe den CURRENT_USER()-Wert von NULL USER name). Teil). Ein Grund dafür ist, dass One nicht über genügend Konten in der Autorisierungsliste für Davida verfügt. Die von CURRENT_USER() zurückgegebene Zeichenfolge verwendet den utf8-Zeichensatz. DATABASE()Gibt den standardmäßigen (aktuellen) Datenbanknamen unter Verwendung des utf8-Zeichensatzes zurück. In einer gespeicherten Prozedur ist die Standarddatenbank die mit der Prozedur verknüpfte Datenbank, sie muss jedoch nicht unbedingt mit der Standarddatenbank im aufrufenden Kontext identisch sein. mysql> SELECT DATABASE();-> 'test'Wenn keine Standarddatenbank vorhanden ist, gibt DATABASE() NULL zurück. FOUND_ROWS()Eine SELECT-Anweisung kann eine LIMIT-Klausel enthalten, um die Anzahl der vom Server an den Client zurückgegebenen Zeilen zu begrenzen. In manchen Fällen ist es notwendig zu wissen, wie viele Zeilen die Anweisung ohne LIMIT zurückgegeben hat, ohne die Anweisung erneut auszuführen. Um diese Anzahl von Zeilen zu ermitteln, wählen Sie SQL_CALC_FOUND_ROWS in der SELECT-Anweisung aus und rufen Sie dann FOUND_ROWS() auf: mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name-> 100 LIMIT 10 ; mysql>Das zweite SELECT gibt eine Zahl zurück, die angibt, wie viele Zeilen das erste SELECT ohne die LIMIT-Klausel zurückgegeben hat (wenn die obige SELECT-Anweisung nicht die SQL_CALC_FOUND_ROWS enthält Option, sodass FOUND_ROWS() möglicherweise unterschiedliche Ergebnisse zurückgibt, wenn LIMIT verwendet wird und wenn es nicht verwendet wird. Die effektive Anzahl der von FOUND_ROWS() übergebenen Zeilen ist sofort gültig und wird nicht zum Überspringen von Anweisungen nach der SELECT SQL_CALC_FOUND_ROWS-Anweisung verwendet. Wenn Sie später auf diesen Wert zurückgreifen müssen, speichern Sie ihn: mysql> >Wenn Sie SELECT SQL_CALC_FOUND_ROWS verwenden, muss MySQL berechnen, wie viele Zeilen es in der Gesamtergebnismenge gibt. Dies ist jedoch schneller als das erneute Ausführen der Abfrage ohne LIMIT, da die Ergebnismenge nicht an den Client gesendet werden muss.SQL_CALC_FOUND_ROWS 和 FOUND_ROWS() 在当你希望限制一个问询返回的行数时很有用，同时还能不需要再次运行问询而确定全部结果集合中的行数。一个例子就是提供页式显示的Web脚本，该显示包含显示搜索结果其它部分的页的连接。使用FOUND_ROWS() 使你确定剩下的结果需要多少其它的页。
SQL_CALC_FOUND_ROWS 和 FOUND_ROWS() 的应用对于UNION 问询比对于简单SELECT 语句更为复杂，原因是在UNION 中，LIMIT 可能会出现在多个位置。它可能适用于UNION中的个人 SELECT语句，或是总体上 到UNION 结果的全程。
SQL_CALC_FOUND_ROWS对于 UNION的意向是它应该不需要全程LIMIT而返回应返回的行数。SQL_CALC_FOUND_ROWS 和UNION 一同使用的条件是：
SQL_CALC_FOUND_ROWS 关键词必须出现在UNION的第一个 SELECT中。
FOUND_ROWS()的值只有在使用 UNION ALL时才是精确的。若使用不带ALL的UNION，则会发生两次删除， 而 FOUND_ROWS() 的指只需近似的。
假若UNION 中没有出现 LIMIT ，则SQL_CALC_FOUND_ROWS 被忽略，返回临时表中的创建的用来处理UNION的行数。
LAST_INSERT_ID() LAST_INSERT_ID(expr)
自动返回最后一个INSERT或 UPDATE 问询为 AUTO_INCREMENT列设置的第一个 发生的值。
mysql> SELECT LAST_INSERT_ID();
-> 195
产生的ID 每次连接后保存在服务器中。这意味着函数向一个给定客户端返回的值是该客户端产生对影响AUTO_INCREMENT列的最新语句第一个 AUTO_INCREMENT值的。这个值不能被其它客户端影响，即使它们产生它们自己的 AUTO_INCREMENT值。这个行为保证了你能够找回自己的 ID 而不用担心其它客户端的活动，而且不需要加锁或处理。
假如你使用一个非“magic”值来更新某一行的AUTO_INCREMENT 列，则LAST_INSERT_ID() 的值不会变化(换言之, 一个不是 NULL也不是 0的值)。
重点: 假如你使用单INSERT语句插入多个行， LAST_INSERT_ID() 只返回插入的第一行产生的值。其原因是这使依靠其它服务器复制同样的 INSERT语句变得简单。
例如：
mysql> USE test;
Database changed mysql> CREATE TABLE t ( -> id INT AUTO_INCREMENT NOT NULL PRIMARY KEY, -> name VARCHAR(10) NOT NULL -> );Query OK, 0 rows affected (0.09 sec) mysql> INSERT INTO t VALUES (NULL, 'Bob'); Query OK, 1 row affected (0.01 sec) mysql> SELECT * FROM t;+----+------+ | id | name | +----+------+ | 1 | Bob | +----+------+ 1 row in set (0.01 sec) mysql> SELECT LAST_INSERT_ID();+------------------+ | LAST_INSERT_ID() | +------------------+ | 1 | +------------------+ 1 row in set (0.00 sec) mysql> INSERT INTO t VALUES -> (NULL, 'Mary'), (NULL, 'Jane'), (NULL, 'Lisa');Query OK, 3 rows affected (0.00 sec) Records: 3 Duplicates: 0 Warnings: 0 mysql> SELECT * FROM t; +----+------+ | id | name | +----+------+ | 1 | Bob | | 2 | Mary | | 3 | Jane | | 4 | Lisa | +----+------+ 4 rows in set (0.01 sec) mysql> SELECT LAST_INSERT_ID();+------------------+ | LAST_INSERT_ID() | +------------------+ | 2 | +------------------+ 1 row in set (0.00 sec)
虽然第二个问询将3 个新行插入 t, 对这些行的第一行产生的 ID 为 2, 这也是 LAST_INSERT_ID()返回的值。
假如你使用 INSERT IGNORE而记录被忽略，则AUTO_INCREMENT 计数器不会增量，而 LAST_INSERT_ID() 返回0,这反映出没有插入任何记录。
若给出作为到LAST_INSERT_ID()的参数expr ，则参数的值被函数返回，并作为被LAST_INSERT_ID()返回的下一个值而被记忆。这可用于模拟序列：
创建一个表，用来控制顺序计数器并使其初始化：
o mysql> CREATE TABLE sequence (id INT NOT NULL);
o mysql> INSERT INTO sequence VALUES (0);
使用该表产生这样的序列数 ：
o mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1);
o mysql> SELECT LAST_INSERT_ID();
UPDATE 语句会增加顺序计数器并引发向LAST_INSERT_ID() 的下一次调用，用来返回升级后的值。 SELECT 语句会检索这个值。 mysql_insert_id() C API函数也可用于获取这个值。
你可以不用调用LAST_INSERT_ID()而产生序列，但这样使用这个函数的效用在于 ID值被保存在服务器中，作为自动产生的值。它适用于多个用户，原因是多个用户均可使用 UPDATE语句并用SELECT语句(或mysql_insert_id()),得到他们自己的序列值，而不会影响其它产生他们自己的序列值的客户端或被其它产生他们自己的序列值的客户端所影响。
注意， mysql_insert_id() 仅会在INSERT 和UPDATE语句后面被升级， 因此你不能在执行了其它诸如SELECT或 SET 这样的SQL语句后使用 C API 函数来找回 LAST_INSERT_ID(expr) 对应的值。
ROW_COUNT()
ROW_COUNT() gibt die Anzahl der Zeilen zurück, die durch die vorherige Anweisung aktualisiert, eingefügt oder gelöscht wurden. Diese Anzahl von Zeilen entspricht der Anzahl der vom MySQL-Client angezeigten Zeilen und dem von der C-API-Funktion mysql_affected_rows() zurückgegebenen Wert.
mysql> INSERT INTO t VALUES(1),(2),(3);
Abfrage abgeschlossen, es gibt 3 Zeilen in der Tabelle (0,00 Sekunden)
Datensätze: 3 Wiederholungen: 0 Warnungen: 0
mysql>
-------------
|. ) |
-------------
| 3 |
-------------
Es gibt 1 Zeile in der Tabelle (0,00 Sekunden)
mysql> DELETE FROM t WHERE i IN(1,2);
Abfrage abgeschlossen, 2 Zeilen gefunden (0,00 Sekunden)
mysql> ; SELECT ROW_COUNT();
-------------
| ROW_COUNT() |
-------------
| 2 |
-------------
Es gibt 1 Zeile in der Tabelle (0,00 Sekunden)
SCHEMA()
Diese Funktion hat die gleiche Bedeutung wie DATABASE().
SESSION_USER()
SESSION_USER() und USER() haben die gleiche Bedeutung.
SYSTEM_USER()
SYSTEM_USER() und USER() haben die gleiche Bedeutung.
USER()
Gibt den aktuellen MySQL-Benutzernamen und Hostnamen zurück/
MYSQL>
-> localhost '
Dieser Wert gibt den Benutzernamen an, den Sie beim Herstellen einer Verbindung zum Server angegeben haben, und den Client-Host, mit dem Sie verbunden sind. Dieser Wert kann vom Wert von CURRENT_USER() abweichen.
Sie können den Benutzernamenteil wie folgt extrahieren:
mysql> SELECT SUBSTRING_INDEX(USER(),'@',1);
-> 🎜 >
Da USER() einen Wert im utf8-Zeichensatz zurückgibt, sollten Sie auch sicherstellen, dass „@“-Zeichenfolgenliterale in diesem Zeichensatz interpretiert werden: mysql> _utf8' @',1);-> 'davida'VERSION()Gibt eine Zeichenfolge zurück, die die MySQL-Serverversion angibt. Diese Zeichenfolge verwendet den utf8-Zeichensatz. mysql> SELECT VERSION();-> '5.1.2-alpha-standard'Beachten Sie, dass dies bedeutet, wenn Ihre Versionszeichenfolge mit -log endet Der Login wurde aktiviert. 4. Andere Funktionen DEFAULT(col_name)Gibt den Standardwert einer Tabellenspalte zurück. Wenn die Spalte keinen Standardwert hat, tritt ein Fehler auf. mysql> UPDATE t SET i = DEFAULT(i) 1 WHERE id < 100;FORMAT(X,D)Schreiben Sie das Format der Zahl X als ' #,###,###.##', auf D Stellen nach dem Dezimalpunkt runden und das Ergebnis als Zeichenfolge zurückgeben. Wenn D 0 ist, hat das zurückgegebene Ergebnis weder einen Dezimalpunkt noch einen Dezimalteil. mysql> SELECT FORMAT(12332.123456, 4);-> '12,332.1235'mysql> > -> '12,332.1000'mysql& gt ; SELECT FORMAT(12332.2,0);-> '12,332'GET_LOCK(str,timeout)Versuchen Sie, eine Sperre mit dem durch string angegebenen Namen zu erhalten str mit einem Timeout von Timeout-Sekunden. Gibt 1 zurück, wenn die Sperre erfolgreich erhalten wurde, 0, wenn der Vorgang abgelaufen ist (z. B. weil ein anderer Client den Namen zuvor blockiert hat) und NULL, wenn ein Fehler auftritt (z. B. Speichermangel oder die Verbindung zum Thread „mysqladmin kill“ getrennt ist). . Wenn Sie mit GET_LOCK() eine Sperre erhalten haben, wird die Sperre aufgehoben, wenn Sie RELEASE_LOCK() ausführen oder Ihre Verbindung getrennt wird (normal oder ungewöhnlich). Mit dieser Funktion können Sie eine Anwendungssperre durchführen oder eine Datensatzsperre simulieren. Namen sind serverweit gesperrt. Wenn ein Name bereits von einem Client blockiert wurde, blockiert GET_LOCK() jede Anfrage eines anderen Clients, denselben Namen zu blockieren. Dadurch können Clients, die sich auf einen Sperrnamen geeinigt haben, bei der Durchführung beratender Sperren unter Verwendung dieses Namens zusammenarbeiten. Beachten Sie jedoch, dass dadurch auch ein Client, der nicht Teil einer Gruppe zusammenarbeitender Clients ist, einen Namen blockieren kann, sei es im Dienst oder unbeabsichtigt, wodurch verhindert wird, dass zusammenarbeitende Clients den Namen blockieren. Eine Möglichkeit, das Auftreten dieser Situation zu reduzieren, besteht darin, datenbankspezifische oder anwendungsspezifische Blockierungsnamen zu verwenden. Verwenden Sie beispielsweise einen Blocknamen der Form db_name.str oder app_name.str. mysql> SELECT GET_LOCK('lock1',10);-> 1
mysql> SELECT IS_FREE_LOCK('lock2');
-> >
-> 1
mysql> SELECT RELEASE_LOCK('lock1');
Beachten Sie, dass der zweite RELEASE_LOCK()-Aufruf NULL zurückgibt, da die Sperre „lock1“ durch den zweiten GET_LOCK()-Aufruf blockiert wird entspannen.
INET_ATON(expr)
mysql> SELECT INET_ATON('209.207.224.40');
-> 3520061480
Die generierten Zahlen sind immer in der Netzwerk-Byte-Reihenfolge. Wie im obigen Beispiel werden die Zahlen wie folgt berechnet: 209×2563 207×2562 224×256 40.
INET_ATON() versteht auch Kurzform-IP-Adressen:
mysql> 2130706433
-> '209.207.224.40'
| 🎜>|. 14 |
--------
Diese Funktion wurde in MySQL 5.0.12 hinzugefügt. Es ist nur für den internen Gebrauch bestimmt. Möglicherweise sehen Sie diese Funktion im mysqlbinlog-Bücherregal.
mysql> SELECT UUID();
-> '6ccd780c-baba-1026-9564-0040f4311e29'
Beachten Sie, dass UUID() die Kopierfunktion nicht unterstützt.
VALUES(col_name)
In einer INSERT … ON DUPLICATE KEY UPDATE …-Anweisung können Sie die Funktion VALUES(col_name) in der UPDATE-Klausel verwenden, um auf den INSERT-Teilspaltenwert der Anweisung zuzugreifen . Mit anderen Worten: VALUES(col_name) in der UPDATE-Klausel greift auf den Wert von col_name zu, der eingefügt werden muss, und es tritt kein Konflikt mit doppelten Schlüsseln auf. Diese Funktion ist besonders nützlich bei mehrzeiligen Einfügungen. Die Funktion VALUES() ist nur in INSERT ... UPDATE-Anweisungen sinnvoll und gibt in anderen Fällen nur NULL zurück.
mysql> INSERT INTO table (a,b,c) VALUES (1,2,3),(4,5,6)
-> ON DUPLICATE KEY UPDATE c=VALUES (a) WERTE(b);
MySQL ändert den Namen der Datentabelle
MySQL erstellt eine gespeicherte Prozedur
Der Unterschied zwischen Mongodb und MySQL
So überprüfen Sie, ob das MySQL-Passwort vergessen wurde
MySQL-Datenbank erstellen
MySQL-Standard-Transaktionsisolationsstufe
Der Unterschied zwischen SQL Server und MySQL
mysqlPasswort vergessen
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
