Bảng dưới liệt kê chi tiết các hàm xử lý chuỗi quan trọng trong MySQL.
Bảng dưới liệt kê chi tiết các hàm xử lý chuỗi quan trọng trong MySQL.
Tên hàm
Miêu tả
Hàm ASCII()
Trả về giá trị số của ký tự cực tả (bên trái nhất)
Hàm BIN()
Trả về một biểu diễn chuỗi của tham số
Hàm BIT_LENGTH()
Trả về độ dài (số bit) của tham số
Hàm CHAR_LENGTH()
Trả về số ký tự của tham số
Hàm CHAR()
Trả về ký tự cho mỗi số nguyên đã truyền
Hàm CHARACTER_LENGTH()
Giống hàm CHAR_LENGTH()
Hàm CONCAT_WS()
Viết tắt của Concatenate With Separator, là một mẫu hàm CONCAT() đặc biệt
Hàm CONCAT()
Nối chuỗi
Hàm CONV()
Chuyển đổi các số sang các cơ số khác nhau
Hàm ELT()
Trả về chuỗi tại chỉ mục
Hàm EXPORT_SET()
Trả về một chuỗi để mà với một bit được thiết lập trong bits, bạn lấy một chuỗi on, và với mỗi khi không được thiết lập trong bits, bạn lấy chuỗi off. Các bit trong tham số bits được tính từ phải qua trái
Hàm FIELD()
Trả về chỉ mục (vị trí) của tham số đầu tiên trong dãy các tham số
Hàm FIND_IN_SET()
Trả về chỉ mục (vị trí) của tham số đầu tiên trong tham số thứ hai
Hàm FORMAT()
Trả về một số được định dạng với một vị trí sau dấu thập phân đã cho
Hàm HEX()
Trả về một biểu diễn chuỗi của một giá trị thuộc hệ cơ số 16
Hàm INSERT()
Chèn một chuỗi con tại vị trí đã cho với số ký tự đã xác định
Hàm INSTR()
Trả về chỉ mục cho sự xuất hiện đầu tiên của chuỗi con
Hàm LCASE()
Giống hàm LOWER()
Hàm LEFT()
Trả về ký tự bên trái nhất
Hàm LENGTH()
Trả về độ dài (số byte) của một chuỗi
Hàm LOAD_FILE()
Tải file đã được đặt tên
Hàm LOCATE()
Trả về vị trí của sự xuất hiện đầu tiên của chuỗi con
Hàm LOWER()
Trả về tham số trong kiểu chữ thường
Hàm LPAD()
Trả về tham số chuỗi đã được thêm vào bên trái với chuỗi đã cho
Hàm LTRIM()
Xóa các Leading space (theo dõi ví dụ để hiểu ý nghĩa của leading space nếu bạn chưa biết)
Hàm MAKE_SET()
Trả về một tập hợp chuỗi được phân biệt bởi dấu phảy mà có bit tương ứng trong tập hợp các bit
Hàm MID()
Trả về một chuỗi phụ bắt đầu từ vị trí đã cho
Hàm OCT()
Trả về biểu diễn chuỗi của tham số thuộc hệ cơ số 8
Hàm OCTET_LENGTH()
Giống hàm LENGTH()
Hàm ORD()
Nếu ký tự cực tả của tham số là một ký tự được biểu diễn bởi nhiều byte, trả về mã hóa của ký tự đó
Hàm POSITION()
Giống hàm LOCATE()
Hàm QUOTE()
Lấy tham số để sử dụng trong một lệnh SQL
Hàm REGEXP
Pattern matching (so khớp mẫu) sử dụng Regular Expression
Hàm REPEAT()
Lặp lại một chuỗi với số lần đã cho
Hàm REPLACE()
Thay thế một chuỗi đã cho nếu xuất hiện
Hàm REVERSE()
Đảo ngược các ký tự trong một chuỗi
Hàm RIGHT()
Trả về ký tự bên phải nhất
Hàm RPAD()
Phụ thêm chuỗi với số lần đã cho
Hàm RTRIM()
Gỡ bỏ các Trailing space
Hàm SOUNDEX()
Trả về một chuỗi soundex
Hàm SOUNDS LIKE
So sánh các sound
Hàm SPACE()
Trả về một chuỗi gồm số khoảng trống đã cho
Hàm STRCMP()
So sánh hai chuỗi
Hàm SUBSTRING_INDEX()
Trả về một chuỗi con từ một chuỗi trước số lần xuất hiện đã cho của delimiter
Hàm SUBSTRING(), SUBSTR()
Trả về chuỗi phụ như đã xác định
Hàm TRIM()
Gỡ bỏ Leading và Trailing space
Hàm UCASE()
Giống hàm UPPER()
Hàm UNHEX()
Chuyển đổi mỗi cặp chữ số thập lục phân thành một ký tự
Hàm UPPER()
Chuyển đổi thành chữ hoa
Hàm ASCII(str)
Trả về giá trị số của ký tự bên trái nhất (cực tả) của chuỗi str. Trả về 0 nếu str là chuỗi trống. Trả về NULL nếu str là NULL. Hàm ASCII() làm việc với các ký tự có giá trị số từ 0 tới 255.
Hàm BIN(N)
Trả về một biểu diễn chuỗi của giá trị nhị phân N, với N là một số long BIGINT. Hàm này tương đương với CONV(N,10,2). Hàm trả về NULL nếu N là NULL.
Hàm BIT_LENGTH(str)
Trả về độ dài (số bit) của chuỗi str.
Hàm CHAR(N,... [USING charset_name])
Hàm CHAR() thông dịch mỗi tham số N như là một số nguyên và trả về một chuỗi gồm các ký tự được cung cấp bởi các giá trị mã hóa của các số nguyên đó. Các giá trị NULL bị bỏ qua.
Hàm CHAR_LENGTH(str)
Trả về độ dài (số ký tự) của chuỗi str. Một ký tự được biểu diễn bởi nhiều byte được đếm như là một ký tự đơn. Nghĩa là, với một chuỗi chứa 5 ký tự, mỗi ký tự có độ dài 2 byte, thì hàm LENGTH() trả về 10 còn hàm CHAR_LENGTH() trả về 5.
Hàm CHARACTER_LENGTH(str)
CHARACTER_LENGTH() là giống hàm CHAR_LENGTH().
Hàm CONCAT(str1,str2,...)
Trả về chuỗi là kết quả của việc nối chuỗi các tham số. Có thể có 1 hoặc nhiều tham số. Nếu tất cả tham số là các chuỗi không phải nhị phân (non-binary), kết quả là một chuỗi không phải là nhị phân. Nếu các tham số bao gồm bất kỳ chuỗi nhị phân nào, thì kết quả là một chuỗi nhị phân. Một tham số dạng số được chuyển đổi thành dạng chuỗi tương đương. Nếu bạn muốn tránh điều này, bạn có thể sử dụng một type cast tường minh, như trong ví dụ sau:
Hàm CONCAT_WS(separator,str1,str2,...)
Hàm CONCAT_WS() là viết tắt của Concatenate With Separator và là một dạng hàm CONCAT() đặc biệt. Tham số đầu tiên là Separator cho các tham số còn lại. Separator này được thêm vào giữa các chuỗi để được nối chuỗi. Separator có thể là một chuỗi. Nếu Separator là NULL thì kết quả trả về là NULL.
Hàm CONV(N,from_base,to_base)
Chuyển đổi số giữa các hệ cơ số khác nhau. Trả về một chuỗi biểu diễn số N, đã được chuyển đổi từ hệ cơ số from_base sang hệ cơ số to_base. Trả về NULL nếu bất kỳ tham số nào là NULL. Tham số N được thông dịch như là một số nguyên, nhưng có thể được xác định như là một số nguyên hoặc một chuỗi. Nếu to_base là một số âm, thì N được xem như một số có dấu. Nếu không thì, N được xem như một số không dấu. Hàm CONV() làm việc với 64 bit.
Hàm ELT(N,str1,str2,str3,...)
Hàm trả về str1 nếu N = 1, trả về str2 nếu N = 2, và cứ tiếp tục như vậy. Trả về NULL nếu N nhỏ hơn 1 hoặc lớn hơn số tham số. Hàm ELT() là sự bổ sung của FIELD().
Hàm EXPORT_SET(bits,on,off[,separator[,number_of_bits]])
Trả về một chuỗi để mà với một bit được thiết lập trong bits, bạn lấy một chuỗi on, và với mỗi khi không được thiết lập trong bits, bạn lấy chuỗi off. Các bit trong tham số bits được tính từ phải qua trái. Các chuỗi được thêm vào kết quả từ trái qua phải, phân biệt nhau bởi separator (theo mặc định là dấu phảy). Số bit nên được xem xét được cung cấp bởi tham số number_of_bits (mặc định là 64).
Hàm FIELD(str,str1,str2,str3,...)
Trả về chỉ mục (vị trí bắt đầu từ 1) của str trong danh sách str1, str2, str3, … Trả về 0 nếu str không được tìm thấy.
Hàm FIND_IN_SET(str,strlist)
Trả về một giá trị trong dãy từ 1 tới N nếu chuỗi str là trong danh sách chuỗi strlist chứa N chuỗi con.
Hàm FORMAT(X,D)
Định dạng số X trong định dạng như '#,###,###.##', được làm tròn về D vị trí sau dấu phảy, và trả về kết quả dưới dạng một chuỗi. Nếu D là 0, thì kết quả không có dấu thập phân hay phần thập phân.
Hàm HEX(N_or_S)
Nếu N_or_S là một số, trả về một biểu diễn chuỗi của giá trị thập lục phân N, với N là một số long BIGINT. Hàm này tương đương với hàm CONV(N,10,16).
Nếu N_or_S là một chuỗi, trả về biểu diễn chuỗi thập lục phân của N_or_S với mỗi ký tự trong đó được chuyển đổi thành hai chữ số thập lục phân.
Hàm INSERT(str,pos,len,newstr)
Trả về chuỗi str, với chuỗi con bắt đầu tại vị trí pos tới len được thay thế với chuỗi newstr. Trả về chuỗi ban đầu nếu giá trị tham số pos là không nằm trong độ dài của chuỗi. Thay thế phần còn lại của chuỗi từ vị trí pos nếu giá trị tham số len là không ở trong độ dài phần còn lại của chuỗi. Trả về NULL nếu bất kỳ tham số nào là NULL.
Hàm INSTR(str,substr)
Trả về vị trí của lần xuất hiện đầu tiên của chuỗi con substr trong chuỗi str. Hàm này tương tự như dạng hai tham số của hàm LOCATE(), ngoại trừ việc thứ tự của tham số bị đảo ngược.
Hàm LCASE(str)
Hàm LCASE() là giống hàm LOWER().
Hàm LEFT(str,len)
Trả về các ký tự có độ dài len bắt đầu từ bên trái nhất của chuỗi str, hoặc trả về NULL nếu bất kỳ tham số nào là NULL.
Hàm LENGTH(str)
Trả về độ dài (số byte) của chuỗi str. Một ký tự được biểu diễn bằng bao nhiêu byte thì đếm bấy nhiêu byte. Nghĩa là, với một chuỗi chứa 5 ký tự, mỗi ký tự có độ dài 2 byte, hàm LENGTH() trả về 10, trong khi hàm CHAR_LENGTH() trả về 5.
Hàm LOAD_FILE(file_name)
Đọc file và trả về các nội dung file dưới dạng chuỗi. Để sử dụng hàm này, file phải được đặt trên Server Host, bạn phải xác định pathname đầy đủ tới file đó, và bạn phải có quyền FILE. File phải là có thể đọc bởi tất cả mọi người và kích cỡ của nó nhỏ hơn max_allowed_packet byte.
Nếu file không tồn tại hoặc không thể đọc bởi vì một trong các điều kiện trước đó không được thỏa mãn, hàm sẽ trả về NULL.
Như trong SQL 5.0.19, biến hệ thống character_set_filesystem điều khiển trình thông dịch các filename mà được cung cấp ở dạng literal string (chuỗi hằng).
Hàm LOCATE(substr,str), LOCATE(substr,str,pos)
Cú pháp đầu tiên trả về vị trí của lần xuất hiện đầu tiên của chuỗi phụ substr trong chuỗi str. Cú pháp thứ hai trả về vị trí của lần xuất hiện đầu tiên của chuỗi phụ substr trong chuỗi str, bắt đầu từ vị trí pos. Trả về 0 nếu substr là không trong str.
Hàm LOWER(str)
Trả về chuỗi str với tất cả ký tự đã được chuyển đổi thành chữ thường.
Hàm LPAD(str,len,padstr)
Trả về chuỗi str, đã được phụ thêm vào bên trái bởi chuỗi padstr với len ký tự. Nếu str là dài hơn len, thì giá trị trả về bị rút gọn về len ký tự.
Hàm LTRIM(str)
Trả về chuỗi str sau khi gỡ bỏ các Leading space.
Hàm MAKE_SET(bits,str1,str2,...)
Trả về một tập giá trị (một chuỗi chứa các chuỗi con phân biệt nhau bởi dấu chấm phảy) gồm các chuỗi mà có bit tương ứng trong tập bits. Tham số str1 tương ứng với bit 0, str2 tương ứng bit 1, và cứ tiếp tục. Các giá trị NULL trong str1, str2, … không được phụ thêm vào kết quả.
Hàm MID(str,pos,len)
Hàm MID(str,pos,len) là giống hàm SUBSTRING(str,pos,len).
Hàm OCT(N)
Trả về một biểu diễn chuỗi của giá trị bát phân N, với N là một số long BIGINT. Hàm này tương đương với hàm CONV(N,10,8). Trả về NULL nếu N là NULL.
Hàm OCTET_LENGTH(str)
Hàm OCTET_LENGTH() là giống hàm LENGTH().
Hàm ORD(str)
Nếu ký tự bên trái nhất của chuỗi str là một ký tự được biểu diễn bởi nhiều byte, trả về mã hóa cho ký tự đó, được tính toán từ các giá trị số của các byte cấu thành bởi sử dụng công thức này.
(1st byte code)
(2nd byte code . 256)
(3rd byte code . 2562) ...
Nếu ký tự bên trái nhất không là một ký tự được biểu diễn bởi nhiều byte, hàm ORD() trả về cùng giá trị như hàm ASCII().
mysql> SELECT QUOTE('Don\'t!'); +---------------------------------------------------------+ | QUOTE('Don\'t!') | +---------------------------------------------------------+ | 'Don\'t!' | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT 'ABCDEF' REGEXP 'A%C%%'; +---------------------------------------------------------+ | 'ABCDEF' REGEXP 'A%C%%' | +---------------------------------------------------------+ | 0 | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT 'ABCDE' REGEXP '.'; +---------------------------------------------------------+ | 'ABCDE' REGEXP '.' | +---------------------------------------------------------+ | 1 | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT 'new\nline' REGEXP 'new\.\*line'; +---------------------------------------------------------+ | 'new\nline' REGEXP 'new\*.\line' | +---------------------------------------------------------+ | 1 | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT REPEAT('SQL', 3); +---------------------------------------------------------+ | REPEAT('SQL', 3) | +---------------------------------------------------------+ | SQLSQLSQL | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww'); +---------------------------------------------------------+ | REPLACE('www.mysql.com', 'w', 'Ww') | +---------------------------------------------------------+ | WwWwWw.mysql.com | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT REVERSE('abcd'); +---------------------------------------------------------+ | REVERSE('abcd') | +---------------------------------------------------------+ | dcba | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT RIGHT('foobarbar', 4); +---------------------------------------------------------+ | RIGHT('foobarbar', 4) | +---------------------------------------------------------+ | rbar | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT RPAD('hi',5,'?'); +---------------------------------------------------------+ | RPAD('hi',5,'?') | +---------------------------------------------------------+ | hi??? | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT RTRIM('barbar '); +---------------------------------------------------------+ | RTRIM('barbar ') | +---------------------------------------------------------+ | barbar | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT SOUNDEX('Hello'); +---------------------------------------------------------+ | SOUNDEX('Hello') | +---------------------------------------------------------+ | H400 | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT SPACE(6); +---------------------------------------------------------+ | SELECT SPACE(6) | +---------------------------------------------------------+ | ' ' | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT STRCMP('MOHD', 'MOHD'); +---------------------------------------------------------+ | STRCMP('MOHD', 'MOHD') | +---------------------------------------------------------+ | 0 | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT STRCMP('AMOHD', 'MOHD'); +---------------------------------------------------------+ | STRCMP('AMOHD', 'MOHD') | +---------------------------------------------------------+ | -1 | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT STRCMP('MOHD', 'AMOHD'); +---------------------------------------------------------+ | STRCMP('MOHD', 'AMOHD') | +---------------------------------------------------------+ | 1 | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT SUBSTRING('Quadratically',5); +---------------------------------------------------------+ | SSUBSTRING('Quadratically',5) | +---------------------------------------------------------+ | ratically | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT SUBSTRING('foobarbar' FROM 4); +---------------------------------------------------------+ | SUBSTRING('foobarbar' FROM 4) | +---------------------------------------------------------+ | barbar | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT SUBSTRING('Quadratically',5,6); +---------------------------------------------------------+ | SUBSTRING('Quadratically',5,6) | +---------------------------------------------------------+ | ratica | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2); +---------------------------------------------------------+ | SUBSTRING_INDEX('www.mysql.com', '.', 2) | +---------------------------------------------------------+ | www.mysql | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT TRIM(' bar '); +---------------------------------------------------------+ | TRIM(' bar ') | +---------------------------------------------------------+ | bar | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx'); +---------------------------------------------------------+ | TRIM(LEADING 'x' FROM 'xxxbarxxx') | +---------------------------------------------------------+ | barxxx | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx'); +---------------------------------------------------------+ | TRIM(BOTH 'x' FROM 'xxxbarxxx') | +---------------------------------------------------------+ | bar | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz'); +---------------------------------------------------------+ | TRIM(TRAILING 'xyz' FROM 'barxxyz') | +---------------------------------------------------------+ | barx | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT UNHEX('4D7953514C'); +---------------------------------------------------------+ | UNHEX('4D7953514C') | +---------------------------------------------------------+ | SQL | +---------------------------------------------------------+ 1 row in set (0.00 sec)
mysql> SELECT UPPER('Allah-hus-samad'); +---------------------------------------------------------+ | UPPER('Allah-hus-samad') | +---------------------------------------------------------+ | ALLAH-HUS-SAMAD | +---------------------------------------------------------+ 1 row in set (0.00 sec)
Last updated