Hàm này được sử dụng để nối chuỗi bên trong bất ký lệnh SQL nào ✅ Chất
Thủ Thuật Hướng dẫn Hàm này được sử dụng để nối chuỗi bên trong bất ký lệnh SQL nào 2022
Hoàng Đức Anh đang tìm kiếm từ khóa Hàm này được sử dụng để nối chuỗi bên trong bất ký lệnh SQL nào được Cập Nhật vào lúc : 2022-12-20 07:00:14 . Với phương châm chia sẻ Mẹo Hướng dẫn trong nội dung bài viết một cách Chi Tiết 2022. Nếu sau khi tham khảo nội dung bài viết vẫn ko hiểu thì hoàn toàn có thể lại Comments ở cuối bài để Tác giả lý giải và hướng dẫn lại nha.Hàm xử lý chuỗi trong SQL được sử dụng để thao tác với chuỗi. Bảng dưới liệt kê rõ ràng những hàm xử lý chuỗi quan trọng trong SQL.
Tên hàmMiê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 màn 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 từng 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 những số sang những cơ số rất 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 lúc 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 những 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ố trong những đượ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 màn 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 việc 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ự việc 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 những Leading space (theo dõi ví dụ để hiểu ý nghĩa của leading space nếu bạn chưa chắc như đinh) 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 những bit Hàm MID() Trả về một chuỗi phụ bắt nguồn từ vị trí đã cho Hàm OCT() Trả về màn 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 màn 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 những 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ỏ những Trailing space Hàm SOUNDEX() Trả về một chuỗi soundex Hàm SOUNDS LIKE So sánh những sound Hàm SPACE() Trả về một chuỗi gồm số khoảng chừ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ữ hoaHà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() thao tác với những ký tự có mức giá trị số từ 0 tới 255.
SQL> SELECT ASCII('2'); +---------------------------------------------------------+ | ASCII('2') | +---------------------------------------------------------+ | 50 | +---------------------------------------------------------+ 1 row in set (0.00 sec) SQL> SELECT ASCII('dx'); +---------------------------------------------------------+ | ASCII('dx') | +---------------------------------------------------------+ | 100 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm BIN(N)
Trả về một màn biểu diễn chuỗi của giá trị nhị phân N, với N là một số trong những 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.
SQL> SELECT BIN(12); +---------------------------------------------------------+ | BIN(12) | +---------------------------------------------------------+ | 1100 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm BIT_LENGTH(str)
Trả về độ dài (số bit) của chuỗi str.
SQL> SELECT BIT_LENGTH('text'); +---------------------------------------------------------+ | BIT_LENGTH('text') | +---------------------------------------------------------+ | 32 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm CHAR(N,... [USING ten_charset])
Hàm CHAR() thông dịch mỗi tham số N như thể một số trong những nguyên và trả về một chuỗi gồm những ký tự được đáp ứng bởi những giá trị mã hóa của những số nguyên đó. Các giá trị NULL bị bỏ qua.
SQL> SELECT CHAR(77,121,83,81,'76'); +---------------------------------------------------------+ | CHAR(77,121,83,81,'76') | +---------------------------------------------------------+ | SQL | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm CHAR_LENGTH(str)
Trả về độ dài (số ký tự) của chuỗi str. Một ký tự được màn biểu diễn bởi nhiều byte được đếm như thể 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.
SQL> SELECT CHAR_LENGTH("text"); +---------------------------------------------------------+ | CHAR_LENGTH("text") | +---------------------------------------------------------+ | 4 | +---------------------------------------------------------+ 1 row in set (0.00 sec)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 những tham số. Có thể có một hoặc nhiều tham số. Nếu tất cả tham số là những 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 những tham số gồm có 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 quy đổi thành dạng chuỗi tương đương. Nếu bạn muốn tránh điều này, bạn hoàn toàn có thể sử dụng một type cast tường minh, như trong ví dụ sau:
SQL> SELECT CONCAT('My', 'S', 'quốc lộ'); +---------------------------------------------------------+ | CONCAT('My', 'S', 'quốc lộ') | +---------------------------------------------------------+ | SQL | +---------------------------------------------------------+ 1 row in set (0.00 sec)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 những tham số còn sót lại. Separator này được thêm vào Một trong những chuỗi để được nối chuỗi. Separator hoàn toàn có thể là một chuỗi. Nếu Separator là NULL thì kết quả trả về là NULL.
SQL> SELECT CONCAT_WS(',','First name','Last Name' ); +---------------------------------------------------------+ | CONCAT_WS(',','First name','Last Name' ) | +---------------------------------------------------------+ | First name, Last Name | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm CONV(N,tu_co_so,sang_co_so)
Chuyển đổi số Một trong những hệ cơ số rất khác nhau. Trả về một chuỗi màn biểu diễn số N, đã được quy đổi từ hệ cơ số tu_co_so sang hệ cơ số sang_co_so. Trả về NULL nếu bất kỳ tham số nào là NULL. Tham số N được thông dịch như thể một số trong những nguyên, nhưng hoàn toàn có thể được xác định như thể một số trong những nguyên hoặc một chuỗi. Nếu sang_co_so là một số trong những âm, thì N được xem như một số trong những có dấu. Nếu không thì, N được xem như một số trong những không dấu. Hàm CONV() thao tác với 64 bit.
SQL> SELECT CONV('a',16,2); +---------------------------------------------------------+ | CONV('a',16,2) | +---------------------------------------------------------+ | 1010 | +---------------------------------------------------------+ 1 row in set (0.00 sec)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 to hơn số tham số. Hàm ELT() là sự việc tương hỗ update của FIELD().
SQL> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo'); +---------------------------------------------------------+ | ELT(1, 'ej', 'Heja', 'hej', 'foo') | +---------------------------------------------------------+ | ej | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm EXPORT_SET(bits,on,off[,separator[,so_luong_bit]])
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 lúc 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ố lượng bit nên được xem xét được đáp ứng bởi tham số so_luong_bit (mặc định là 64).
SQL> SELECT EXPORT_SET(5,'Y','N',',',4); +---------------------------------------------------------+ | EXPORT_SET(5,'Y','N',',',4) | +---------------------------------------------------------+ | Y,N,Y,N | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm FIELD(str,str1,str2,str3,...)
Trả về chỉ mục (vị trí bắt nguồn từ 1) của str trong list str1, str2, str3, … Trả về 0 nếu str không được tìm thấy.
SQL> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo'); +---------------------------------------------------------+ | FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo') | +---------------------------------------------------------+ | 2 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm FIND_IN_SET(str,danh_sach_str)
Trả về một giá trị trong dãy từ 1 tới N nếu chuỗi str là trong list chuỗi danh_sach_str chứa N chuỗi con.
SQL> SELECT FIND_IN_SET('b','a,b,c,d'); +---------------------------------------------------------+ | SELECT FIND_IN_SET('b','a,b,c,d') | +---------------------------------------------------------+ | 2 | +---------------------------------------------------------+ 1 row in set (0.00 sec)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òn dấu thập phân hay phần thập phân.
SQL> SELECT FORMAT(12332.123456, 4); +---------------------------------------------------------+ | FORMAT(12332.123456, 4) | +---------------------------------------------------------+ | 12,332.1235 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm HEX(So_hoac_Chuoi)
Nếu So_hoac_Chuoi là một số, trả về một màn biểu diễn chuỗi của giá trị thập lục phân N, với N là một số trong những long BIGINT. Hàm này tương đương với hàm CONV(N,10,16).
Nếu So_hoac_Chuoi là một chuỗi, trả về màn biểu diễn chuỗi thập lục phân của So_hoac_Chuoi với mỗi ký tự trong đó được quy đổi thành hai chữ số thập lục phân.
SQL> SELECT HEX(255); +---------------------------------------------------------+ | HEX(255) | +---------------------------------------------------------+ | FF | +---------------------------------------------------------+ 1 row in set (0.00 sec) SQL> SELECT 0x616263; +---------------------------------------------------------+ | 0x616263 | +---------------------------------------------------------+ | abc | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm INSERT(str,pos,len,newstr)
Trả về chuỗi str, với chuỗi con khởi đầ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 sót 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 sót lại của chuỗi. Trả về NULL nếu bất kỳ tham số nào là NULL.
SQL> SELECT INSERT('Quadratic', 3, 4, 'What'); +---------------------------------------------------------+ | INSERT('Quadratic', 3, 4, 'What') | +---------------------------------------------------------+ | QuWhattic | +---------------------------------------------------------+ 1 row in set (0.00 sec)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.
SQL> SELECT INSTR('foobarbar', 'bar'); +---------------------------------------------------------+ | INSTR('foobarbar', 'bar') | +---------------------------------------------------------+ | 4 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm LCASE(str)
Hàm LCASE() là giống hàm LOWER().
Hàm LEFT(str,len)
Trả về những ký tự có độ dài len bắt nguồn 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.
SQL> SELECT LEFT('foobarbar', 5); +---------------------------------------------------------+ | LEFT('foobarbar', 5) | +---------------------------------------------------------+ | fooba | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm LENGTH(str)
Trả về độ dài (số byte) của chuỗi str. Một ký tự được màn 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.
SQL> SELECT LENGTH('text'); +---------------------------------------------------------+ | LENGTH('text') | +---------------------------------------------------------+ | 4 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm LOAD_FILE(ten_file)
Đọc file và trả về những 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à hoàn toàn 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 chính bới một trong những đ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 khối mạng lưới hệ thống character_set_filesystem điều khiển trình thông dịch những filename mà được đáp ứng ở dạng literal string (chuỗi hằng).
SQL> UPDATE table_test -> SET blob_col=LOAD_FILE('/tmp/picture') -> WHERE id=1; ...........................................................Quảng cáo
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 nguồn từ vị trí pos. Trả về 0 nếu substr là không trong str.
SQL> SELECT LOCATE('bar', 'foobarbar'); +---------------------------------------------------------+ | LOCATE('bar', 'foobarbar') | +---------------------------------------------------------+ | 4 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm LOWER(str)
Trả về chuỗi str với tất cả ký tự đã được quy đổi thành chữ thường.
SQL> SELECT LOWER('QUADRATICALLY'); +---------------------------------------------------------+ | LOWER('QUADRATICALLY') | +---------------------------------------------------------+ | quadratically | +---------------------------------------------------------+ 1 row in set (0.00 sec)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 thế nữa len, thì giá trị trả về bị rút gọn về len ký tự.
SQL> SELECT LPAD('hi',4,'??'); +---------------------------------------------------------+ | LPAD('hi',4,'??') | +---------------------------------------------------------+ | ??hi | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm LTRIM(str)
Trả về chuỗi str sau khi gỡ bỏ những Leading space.
SQL> SELECT LTRIM(' barbar'); +---------------------------------------------------------+ | LTRIM(' barbar') | +---------------------------------------------------------+ | barbar | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm MAKE_SET(bits,str1,str2,...)
Trả về một tập giá trị (một chuỗi chứa những chuỗi con phân biệt nhau bởi dấu chấm phảy) gồm những 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ả.
SQL> SELECT MAKE_SET(1,'a','b','c'); +---------------------------------------------------------+ | MAKE_SET(1,'a','b','c') | +---------------------------------------------------------+ | a | +---------------------------------------------------------+ 1 row in set (0.00 sec)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 màn biểu diễn chuỗi của giá trị bát phân N, với N là một số trong những 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.
SQL> SELECT OCT(12); +---------------------------------------------------------+ | OCT(12) | +---------------------------------------------------------+ | 14 | +---------------------------------------------------------+ 1 row in set (0.00 sec)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 màn biểu diễn bởi nhiều byte, trả về mã hóa cho ký tự đó, được tính toán từ những giá trị số của những 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 màn biểu diễn bởi nhiều byte, hàm ORD() trả về cùng giá trị như hàm ASCII().
SQL> SELECT ORD('2'); +---------------------------------------------------------+ | ORD('2') | +---------------------------------------------------------+ | 50 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm POSITION(substr IN str)
Hàm POSITION(substr IN str) là giống hàm LOCATE(substr,str).
Hàm QUOTE(str)
Trích dẫn một chuỗi để cho một kết quả mà hoàn toàn có thể được sử dụng như thể một giá trị tài liệu bị thoát trong một lệnh SQL. Chuỗi được trả về được bao trong những trích dẫn đơn và với mỗi sự thể hiện của ('), (''), ASCII NULL, và Control-Z đều được đặt trước bởi một dấu gạch chéo ngược (). Nếu tham số là NULL, giá trị trả về là từ NULL không được bao trong dấu trích dẫn đơn.
SQL> SELECT QUOTE('Don't!'); +---------------------------------------------------------+ | QUOTE('Don't!') | +---------------------------------------------------------+ | 'Don't!' | +---------------------------------------------------------+ 1 row in set (0.00 sec)GHI CHÚ: Nếu bạn kiểm tra lại setup, và nếu có bất kỳ bug với hàm này, thì tốt hơn hết là đừng sử dụng nó.
Hàm expr REGEXP pattern
Hàm này thực hiện một so khớp mẫu (pattern match) của expr với pattern. Trả về 1 nếu expr so khớp với pattern, nếu không thì trả về 0. Nếu expr hoặc pattern là NULL, thì kết quả là NULL. REGEXP là không phân biệt kiểu chữ, ngoại trừ khi được sử dụng với những chuỗi nhị phân.
SQL> SELECT 'ABCDEF' REGEXP 'A%C%%'; +---------------------------------------------------------+ | 'ABCDEF' REGEXP 'A%C%%' | +---------------------------------------------------------+ | 0 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Một ví dụ khác là:
SQL> SELECT 'ABCDE' REGEXP '.*'; +---------------------------------------------------------+ | 'ABCDE' REGEXP '.*' | +---------------------------------------------------------+ | 1 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Thêm một ví dụ nữa:
SQL> SELECT 'new*n*line' REGEXP 'new\*.\*line'; +---------------------------------------------------------+ | 'new*n*line' REGEXP 'new\*.\*line' | +---------------------------------------------------------+ | 1 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm REPEAT(str,count)
Trả về một chuỗi chứa chuỗi str được lặp lại count lần. Nếu count là nhỏ hơn 1, trả về chuỗi trống. Trả về NULL nếu str hoặc count là NULL.
SQL> SELECT REPEAT('SQL', 3); +---------------------------------------------------------+ | REPEAT('SQL', 3) | +---------------------------------------------------------+ | SQLSQLSQL | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm REPLACE(str,from_str,to_str)
Trả về chuỗi str với tất cả lần xuất hiện của chuỗi từ from_str được thay thế bởi chuỗi to_str. Hàm REPLACE() thực hiện một so khớp phân biệt kiểu chữ khi tìm kiếm cho from_str.
SQL> SELECT REPLACE('www.mysql.com', 'w', 'Ww'); +---------------------------------------------------------+ | REPLACE('www.mysql.com', 'w', 'Ww') | +---------------------------------------------------------+ | WwWwWw.mysql.com | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm REVERSE(str)
Trả về chuỗi str với thứ tự những ký tự bị đảo ngược.
SQL> SELECT REVERSE('abcd'); +---------------------------------------------------------+ | REVERSE('abcd') | +---------------------------------------------------------+ | dcba | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm RIGHT(str,len)
Trả về len ký tự ở bên phải nhất từ chuỗi str, hoặc NULL nếu bất kỳ tham số nào là NULL.
SQL> SELECT RIGHT('foobarbar', 4); +---------------------------------------------------------+ | RIGHT('foobarbar', 4) | +---------------------------------------------------------+ | rbar | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm RPAD(str,len,padstr)
Trả về chuỗi str, đã được thêm vào bên phải với chuỗi padstr với độ dài là len ký tự. Nếu str là dài hơn thế nữa len, giá trị trả về bị rút gọn về len ký tự.
SQL> SELECT RPAD('hi',5,'?'); +---------------------------------------------------------+ | RPAD('hi',5,'?') | +---------------------------------------------------------+ | hi??? | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm RTRIM(str)
Trả về chuỗi str sau khi đã vô hiệu những Trailing space.
SQL> SELECT RTRIM('barbar '); +---------------------------------------------------------+ | RTRIM('barbar ') | +---------------------------------------------------------+ | barbar | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm SOUNDEX(str)
Trả về một chuỗi soundex từ str.
SQL> SELECT SOUNDEX('Hello'); +---------------------------------------------------------+ | SOUNDEX('Hello') | +---------------------------------------------------------+ | H400 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm bieu_thuc_1 SOUNDS LIKE bieu_thuc_2
Hàm này giống dạng SOUNDEX(bieu_thuc_1) = SOUNDEX(bieu_thuc_2).
Hàm SPACE(N)
Trả về một chuỗi chứa N ký tự khoảng chừng trống.
SQL> SELECT SPACE(6); +---------------------------------------------------------+ | SELECT SPACE(6) | +---------------------------------------------------------+ | ' ' | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm STRCMP(str1, str2)
So sánh hai chuỗi và trả về 0 nếu cả hai chuỗi là tương đương, trả về -1 nếu tham số đầu là nhỏ hơn tham số thứ hai theo thứ tự sắp xếp hiện tại, nếu không thì trả về 1.
SQL> SELECT STRCMP('MOHD', 'MOHD'); +---------------------------------------------------------+ | STRCMP('MOHD', 'MOHD') | +---------------------------------------------------------+ | 0 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Một ví dụ khác:
SQL> SELECT STRCMP('AMOHD', 'MOHD'); +---------------------------------------------------------+ | STRCMP('AMOHD', 'MOHD') | +---------------------------------------------------------+ | -1 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Bạn theo dõi thêm một ví dụ:
SQL> SELECT STRCMP('MOHD', 'AMOHD'); +---------------------------------------------------------+ | STRCMP('MOHD', 'AMOHD') | +---------------------------------------------------------+ | 1 | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm SUBSTRING(str,pos) Hàm SUBSTRING(str FROM pos) Hàm SUBSTRING(str,pos,len) Hàm SUBSTRING(str FROM pos FOR len)
Mẫu hàm mà không còn tham số len sẽ trả về một chuỗi con từ chuỗi str khởi đầu tại vị trí pos. Mẫu hàm với tham số len trả về một chuỗi phụ có độ dài là len ký tự từ chuỗi str bắt nguồn từ vị trí pos. Mẫu hàm sử dụng FROM là cú pháp SQL chuẩn. Cũng hoàn toàn có thể sử dụng một giá trị âm cho pos. Trong trường hợp này, phần khởi đầu của chuỗi phụ là những ký tự pos từ phần cuối của chuỗi, thay vì phần khởi đầu. Một giá trị âm hoàn toàn có thể được sử dụng cho pos trong bất kỳ mẫu hàm nào.
SQL> SELECT SUBSTRING('Quadratically',5); +---------------------------------------------------------+ | SSUBSTRING('Quadratically',5) | +---------------------------------------------------------+ | ratically | +---------------------------------------------------------+ 1 row in set (0.00 sec) SQL> SELECT SUBSTRING('foobarbar' FROM 4); +---------------------------------------------------------+ | SUBSTRING('foobarbar' FROM 4) | +---------------------------------------------------------+ | barbar | +---------------------------------------------------------+ 1 row in set (0.00 sec) SQL> SELECT SUBSTRING('Quadratically',5,6); +---------------------------------------------------------+ | SUBSTRING('Quadratically',5,6) | +---------------------------------------------------------+ | ratica | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm SUBSTRING_INDEX(str,delim,count)
Trả về chuỗi con từ chuỗi str trước count lần xuất hiện của delimiter được xác định bởi delim. Nếu count là dương, mọi thứ bên trái của delimeter ở đầu cuối (đếm từ trái) sẽ được trả về. Nếu count là âm, mọi thứ bên phải của delimiter ở đầu cuối (đếm từ phải) sẽ được trả về. Hàm SUBSTRING_INDEX() thực hiện một so khớp phân biệt kiểu chữ khi tìm kiếm cho delim.
SQL> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2); +---------------------------------------------------------+ | SUBSTRING_INDEX('www.mysql.com', '.', 2) | +---------------------------------------------------------+ | www.mysql | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm TRIM([ TRAILING [remstr] FROM] str) Hàm TRIM([remstr FROM] str)
Trả về chuỗi str với tất cả tiền tố hoặc hậu tố remstr đã bị gỡ bỏ. Nếu không còn specifier nào (ví dụ: BOTH, LEADING, TRAILING) được đáp ứng, thì BOTH là mặc định. Tham số remstr là tùy ý và nếu không được xác định, những khoảng chừng trống bị gỡ bỏ.
SQL> SELECT TRIM(' bar '); +---------------------------------------------------------+ | TRIM(' bar ') | +---------------------------------------------------------+ | bar | +---------------------------------------------------------+ 1 row in set (0.00 sec) SQL> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx'); +---------------------------------------------------------+ | TRIM(LEADING 'x' FROM 'xxxbarxxx') | +---------------------------------------------------------+ | barxxx | +---------------------------------------------------------+ 1 row in set (0.00 sec) SQL> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx'); +---------------------------------------------------------+ | TRIM(BOTH 'x' FROM 'xxxbarxxx') | +---------------------------------------------------------+ | bar | +---------------------------------------------------------+ 1 row in set (0.00 sec) SQL> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz'); +---------------------------------------------------------+ | TRIM(TRAILING 'xyz' FROM 'barxxyz') | +---------------------------------------------------------+ | barx | +---------------------------------------------------------+ 1 row in set (0.00 sec)Hàm UCASE(str)
Hàm UCASE() là giống hàm UPPER().
Hàm UNHEX(str)
Thực hiện ngược lại với hàm HEX(str). Nghĩa là, nó thông dịch mỗi cặp chữ số thập lục phân trong tham số như thể một số trong những và quy đổi nó sang ký tự được màn biểu diễn bởi số đó. Các ký tự kết quả được trả về dưới dạng một chuỗi nhị phân.
SQL> SELECT UNHEX('4D7953514C'); +---------------------------------------------------------+ | UNHEX('4D7953514C') | +---------------------------------------------------------+ | SQL | +---------------------------------------------------------+ 1 row in set (0.00 sec)Các ký tự trong chuỗi tham số phải là những chữ số thập lục phân: '0' … '9', 'A' … 'Z', 'a … 'z'. Nếu hàm UNHEX() gặp bất kỳ chữ số không phải thập lục phân trong tham số, nó trả về NULL.
Hàm UPPER(str)
Trả về chuỗi str với tất cả ký tự đã được quy đổi thành chữ hoa.
SQL> SELECT UPPER('Allah-hus-samad'); +---------------------------------------------------------+ | UPPER('Allah-hus-samad') | +---------------------------------------------------------+ | ALLAH-HUS-SAMAD | +---------------------------------------------------------+ 1 row in set (0.00 sec) Tải thêm tài liệu liên quan đến nội dung bài viết Hàm này được sử dụng để nối chuỗi bên trong bất ký lệnh SQL nào