SQL - STRING FUNCTIONS

http://www.tuto rialspo int.co m/sql/sql-string -functio ns.htm Co pyrig ht © tuto rials po int.co m

SQL string functions are used primarily for string manipulation. T he following table details the important string
functions:

Name Desc ription

ASCII() Returns numeric value of left-most character

BIN() Returns a string representation of the arg ument

BIT _LENGT H() Returns leng th of arg ument in bits

CHAR_LENGT H() Returns number of characters in arg ument

CHAR() Returns the character for each integ er passed

CHARACT ER_LENGT H() A synonym for CHAR_LENGT H()

CONCAT _WS() Returns concatenate with separator

CONCAT () Returns concatenated string

CONV() Converts numbers between different number bases

ELT () Returns string at index number

EXPORT _SET () Returns a string such that for every bit set in the value bits, you g et an
on string and for every unset bit, you g et an off string

FIELD() Returns the index (position) of the first arg ument in the subsequent
arg uments

FIND_IN_SET () Returns the index position of the first arg ument within the second
arg ument

FORMAT () Returns a number formatted to specified number of decimal places

HEX() Returns a string representation of a hex value

INSERT () Inserts a substring at the specified position up to the specified number

of characters

INST R() Returns the index of the first occurrence of substring

LCASE() Synonym for LOWER()

LEFT () Returns the leftmost number of characters as specified

LENGT H() Returns the leng th of a string in bytes

LOAD_FILE() Loads the named file

LOCAT E() Returns the position of the first occurrence of substring

LOWER() Returns the arg ument in lowercase

LPAD() Returns the string arg ument, left-padded with the specified string

LT RIM() Removes leading spaces

 MAKE_SET () Returns a set of comma-separated string s that have the
corresponding bit in bits set

MID() Returns a substring starting from the specified position

OCT () Returns a string representation of the octal arg ument

OCT ET _LENGT H() A synonym for LENGT H()

ORD() If the leftmost character of the arg ument is a multi-byte character,

returns the code for that character

POSIT ION() A synonym for LOCAT E()

QUOT E() Escapes the arg ument for use in an SQL statement

REGEXP Pattern matching using reg ular expressions

REPEAT () Repeats a string the specified number of times

REPLACE() Replaces occurrences of a specified string

REVERSE() Reverses the characters in a string

RIGHT () Returns the specified rig htmost number of characters

RPAD() Appends string the specified number of times

RT RIM() Removes trailing spaces

SOUNDEX() Returns a soundex string

SOUNDS LIKE Compares sounds

SPACE() Returns a string of the specified number of spaces

ST RCMP() Compares two string s

SUBST RING_INDEX() Returns a substring from a string before the specified number of
occurrences of the delimiter

SUBST RING(), SUBST R() Returns the substring as specified

T RIM() Removes leading and trailing spaces

UCASE() Synonym for UPPER()

UNHEX() Converts each pair of hexadecimal dig its to a character

UPPER() Converts to uppercase

ASCII(str)
Returns the numeric value of the leftmost character of the string str. Returns 0 if str is the empty string . Returns
NULL if str is NULL. ASCII() works for characters with numeric values from 0 to 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)

BIN(N)
Returns a string representation of the binary value of N, where N is a long long (BIGINT ) number. T his is
equivalent to CONV(N,10,2). Returns NULL if N is NULL.

SQL> SELECT BIN(12);

+---------------------------------------------------------+
| BIN(12) |
+---------------------------------------------------------+
| 1100 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

BIT_LENGTH(str)
Returns the leng th of the string str in bits.

SQL> SELECT BIT_LENGTH('text');

+---------------------------------------------------------+
| BIT_LENGTH('text') |
+---------------------------------------------------------+
| 32 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CHAR(N,... [USING charset_name])

CHAR() interprets each arg ument N as an integ er and returns a string consisting of the characters g iven by the
code values of those integ ers. NULL values are skipped.

SQL> SELECT CHAR(77,121,83,81,'76');

+---------------------------------------------------------+
| CHAR(77,121,83,81,'76') |
+---------------------------------------------------------+
| SQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CHAR_LENGTH(str)
Returns the leng th of the string str measured in characters. A multi-byte character counts as a sing le character.
T his means that for a string containing five two-byte characters, LENGT H() returns 10, whereas
CHAR_LENGT H() returns 5.

SQL> SELECT CHAR_LENGTH("text");

+---------------------------------------------------------+
| CHAR_LENGTH("text") |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CHARACTER_LENGTH(str)
CHARACT ER_LENGT H() is a synonym for CHAR_LENGT H().

CONCAT(str1,str2,...)
Returns the string that results from concatenating the arg uments. May have one or more arg uments. If all
arg uments are non-binary string s, the result is a non-binary string . If the arg uments include any binary string s,
the result is a binary string . A numeric arg ument is converted to its equivalent binary string form; if you want to
avoid that, you can use an explicit type cast, as in this example:

SQL> SELECT CONCAT('My', 'S', 'QL');

+---------------------------------------------------------+
| CONCAT('My', 'S', 'QL') |
+---------------------------------------------------------+
| SQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CONCAT_WS(separator,str1,str2,...)
CONCAT _WS() stands for Concatenate With Separator and is a special form of CONCAT (). T he first arg ument
is the separator for the rest of the arg uments. T he separator is added between the string s to be concatenated.
T he separator can be a string , as can the rest of the arg uments. If the separator is NULL, the result is 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)

CONV(N,from_base,to_base)
Converts numbers between different number bases. Returns a string representation of the number N,
converted from base from_base to to_base. Returns NULL if any arg ument is NULL. T he arg ument N is
interpreted as an integ er, but may be specified as an integ er or a string . T he minimum base is 2 and the maximum
base is 36. If to_base is a neg ative number, N is reg arded as a sig ned number. Otherwise, N is treated as
unsig ned. CONV() works with 64-bit precision.

SQL> SELECT CONV('a',16,2);

+---------------------------------------------------------+
| CONV('a',16,2) |
+---------------------------------------------------------+
| 1010 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ELT(N,str1,str2,str3,...)
Returns str1 if N = 1, str2 if N = 2, and so on. Returns NULL if N is less than 1 or g reater than the number of
arg uments. ELT () is the complement of FIELD().

SQL> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');

+---------------------------------------------------------+
| ELT(1, 'ej', 'Heja', 'hej', 'foo') |
+---------------------------------------------------------+
| ej |
+---------------------------------------------------------+
1 row in set (0.00 sec)

EXPORT_SET(bits,on,off[,separator[,number_of_bits]])
Returns a string such that for every bit set in the value bits, you g et an on string and for every bit not set in the
value, you g et an off string . Bits in bits are examined from rig ht to left (from low-order to hig h-order bits).
String s are added to the result from left to rig ht, separated by the separator string (the default being the comma
character .,.). T he number of bits examined is g iven by number_of_bits (defaults to 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)

FIELD(str,str1,str2,str3,...)
Returns the index (position starting with 1) of str in the str1, str2, str3, ... list. Returns 0 if str is not found.

SQL> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');

+---------------------------------------------------------+
| FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

FIND_IN_SET(str,strlist)
Returns a value in the rang e of 1 to N if the string str is in the string list strlist consisting of N substring s.

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)

FORMAT(X,D)
Formats the number X to a format like '#,###,###.##', rounded to D decimal places, and returns the result as a
string . If D is 0, the result has no decimal point or fractional part.

SQL> SELECT FORMAT(12332.123456, 4);

+---------------------------------------------------------+
| FORMAT(12332.123456, 4) |
+---------------------------------------------------------+
| 12,332.1235 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

HEX(N_or_S)
If N_or_S is a number, returns a string representation of the hexadecimal value of N, where N is a long long
(BIGINT ) number. T his is equivalent to CONV(N,10,16).

If N_or_S is a string , returns a hexadecimal string representation of N_or_S where each character in N_or_S is
converted to two hexadecimal dig its.

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)
INSERT(str,pos,len,newstr)
Returns the string str, with the substring beg inning at position pos and len characters long replaced by the string
newstr. Returns the orig inal string if pos is not within the leng th of the string . Replaces the rest of the string from
position pos if len is not within the leng th of the rest of the string . Returns NULL if any arg ument is NULL.

SQL> SELECT INSERT('Quadratic', 3, 4, 'What');

+---------------------------------------------------------+
| INSERT('Quadratic', 3, 4, 'What') |
+---------------------------------------------------------+
| QuWhattic |
+---------------------------------------------------------+
1 row in set (0.00 sec)

INSTR(str,substr)
Returns the position of the first occurrence of substring substr in string str. T his is the same as the two-arg ument
form of LOCAT E(), except that the order of the arg uments is reversed.

SQL> SELECT INSTR('foobarbar', 'bar');

+---------------------------------------------------------+
| INSTR('foobarbar', 'bar') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LCASE(str)
LCASE() is a synonym for LOWER().

LEFT(str,len)
Returns the leftmost len characters from the string str, or NULL if any arg ument is NULL.

SQL> SELECT LEFT('foobarbar', 5);

+---------------------------------------------------------+
| LEFT('foobarbar', 5) |
+---------------------------------------------------------+
| fooba |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LENGTH(str)
Returns the leng th of the string str, measured in bytes. A multi-byte character counts as multiple bytes. T his
means that for a string containing five two-byte characters, LENGT H() returns 10, whereas CHAR_LENGT H()
returns 5.

SQL> SELECT LENGTH('text');

+---------------------------------------------------------+
| LENGTH('text') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LOAD_FILE(file_name)
Reads the file and returns the file contents as a string . T o use this function, the file must be located on the server
host, you must specify the full pathname to the file, and you must have the FILE privileg e. T he file must be
readable by all and its size less than max_allowed_packet bytes.

If the file does not exist or cannot be read because one of the preceding conditions is not satisfied, the function
returns NULL.
As of SQL 5.0.19, the character_set_filesystem system variable controls interpretation of filenames that are
g iven as literal string s.

SQL> UPDATE table_test

-> SET blob_col=LOAD_FILE('/tmp/picture')
-> WHERE id=1;
...........................................................

LOCATE(substr,str), LOCATE(substr,str,pos)
T he first syntax returns the position of the first occurrence of substring substr in string str. T he second syntax
returns the position of the first occurrence of substring substr in string str, starting at position pos. Returns 0 if
substr is not in str.

SQL> SELECT LOCATE('bar', 'foobarbar');

+---------------------------------------------------------+
| LOCATE('bar', 'foobarbar') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LOWER(str)
Returns the string str with all characters chang ed to lowercase according to the current character set mapping .

SQL> SELECT LOWER('QUADRATICALLY');

+---------------------------------------------------------+
| LOWER('QUADRATICALLY') |
+---------------------------------------------------------+
| quadratically |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LPAD(str,len,padstr)
Returns the string str, left-padded with the string padstr to a leng th of len characters. If str is long er than len, the
return value is shortened to len characters.

SQL> SELECT LPAD('hi',4,'??');

+---------------------------------------------------------+
| LPAD('hi',4,'??') |
+---------------------------------------------------------+
| ??hi |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LTRIM(str)
Returns the string str with leading space characters removed.

SQL> SELECT LTRIM(' barbar');

+---------------------------------------------------------+
| LTRIM(' barbar') |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MAKE_SET(bits,str1,str2,...)
Returns a set value (a string containing substring s separated by .,. characters) consisting of the string s that have
the corresponding bit in bits set. str1 corresponds to bit 0, str2 to bit 1, and so on. NULL values in str1, str2, ...
are not appended to the result.
 SQL> SELECT MAKE_SET(1,'a','b','c');
+---------------------------------------------------------+
| MAKE_SET(1,'a','b','c') |
+---------------------------------------------------------+
| a |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MID(str,pos,len)
MID(str,pos,len) is a synonym for SUBST RING(str,pos,len).

OCT(N)
Returns a string representation of the octal value of N, where N is a long long (BIGINT ) number. T his is
equivalent to CONV(N,10,8). Returns NULL if N is NULL.

SQL> SELECT OCT(12);

+---------------------------------------------------------+
| OCT(12) |
+---------------------------------------------------------+
| 14 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

OCTET_LENGTH(str)
OCT ET _LENGT H() is a synonym for LENGT H().

ORD(str)
If the leftmost character of the string str is a multi-byte character, returns the code for that character, calculated
from the numeric values of its constituent bytes using this formula:

(1st byte code)

+ (2nd byte code . 256)
+ (3rd byte code . 2562) ...

If the leftmost character is not a multi-byte character, ORD() returns the same value as the ASCII() function.

SQL> SELECT ORD('2');

+---------------------------------------------------------+
| ORD('2') |
+---------------------------------------------------------+
| 50 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

POSITION(substr IN str)
POSIT ION(substr IN str) is a synonym for LOCAT E(substr,str).

QUOTE(str)
Quotes a string to produce a result that can be used as a properly escaped data value in an SQL statement. T he
string is returned enclosed by sing le quotes and with each instance of sing le quote ('), backslash ('\'), ASCII
NUL, and Control-Z preceded by a backslash. If the arg ument is NULL, the return value is the word 'NULL'
without enclosing sing le quotes.

SQL> SELECT QUOTE('Don\'t!');

+---------------------------------------------------------+
| QUOTE('Don\'t!') |
+---------------------------------------------------------+
| 'Don\'t!' |
+---------------------------------------------------------+
 1 row in set (0.00 sec)

NO T E: Please check if your installation has any bug with this function then don't use this function.

expr REGEXP pattern

T his function performs a pattern match of expr ag ainst pattern. Returns 1 if expr matches pat; otherwise it returns
0. If either expr or pat is NULL, the result is NULL. REGEXP is not case sensitive, except when used with
binary string s.

SQL> SELECT 'ABCDEF' REGEXP 'A%C%%';

+---------------------------------------------------------+
| 'ABCDEF' REGEXP 'A%C%%' |
+---------------------------------------------------------+
| 0 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Another example is:

SQL> SELECT 'ABCDE' REGEXP '.*';

+---------------------------------------------------------+
| 'ABCDE' REGEXP '.*' |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Let's see one more example:

SQL> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';

+---------------------------------------------------------+
| 'new*\n*line' REGEXP 'new\\*.\\*line' |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

REPEAT(str,count)
Returns a string consisting of the string str repeated count times. If count is less than 1, returns an empty string .
Returns NULL if str or count are NULL.

SQL> SELECT REPEAT('SQL', 3);

+---------------------------------------------------------+
| REPEAT('SQL', 3) |
+---------------------------------------------------------+
| SQLSQLSQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)

REPLACE(str,from_str,to_str)
Returns the string str with all occurrences of the string from_str replaced by the string to_str. REPLACE()
performs a case-sensitive match when searching for 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)

REVERSE(str)
Returns the string str with the order of the characters reversed.

SQL> SELECT REVERSE('abcd');

+---------------------------------------------------------+
| REVERSE('abcd') |
+---------------------------------------------------------+
| dcba |
+---------------------------------------------------------+
1 row in set (0.00 sec)

RIGHT(str,len)
Returns the rig htmost len characters from the string str, or NULL if any arg ument is NULL.

SQL> SELECT RIGHT('foobarbar', 4);

+---------------------------------------------------------+
| RIGHT('foobarbar', 4) |
+---------------------------------------------------------+
| rbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)

RPAD(str,len,padstr)
Returns the string str, rig ht-padded with the string padstr to a leng th of len characters. If str is long er than len,
the return value is shortened to len characters.

SQL> SELECT RPAD('hi',5,'?');

+---------------------------------------------------------+
| RPAD('hi',5,'?') |
+---------------------------------------------------------+
| hi??? |
+---------------------------------------------------------+
1 row in set (0.00 sec)

RTRIM(str)
Returns the string str with trailing space characters removed.

SQL> SELECT RTRIM('barbar ');

+---------------------------------------------------------+
| RTRIM('barbar ') |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SOUNDEX(str)
Returns a soundex string from str. T wo string s that sound almost the same should have identical soundex
string s. A standard soundex string is four characters long , but the SOUNDEX() function returns an arbitrarily
long string . You can use SUBST RING() on the result to g et a standard soundex string . All non-alphabetic
characters in str are ig nored. All international alphabetic characters outside the A-Z rang e are treated as
vowels.

SQL> SELECT SOUNDEX('Hello');

+---------------------------------------------------------+
| SOUNDEX('Hello') |
+---------------------------------------------------------+
| H400 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

expr1 SOUNDS LIKE expr2

T his is the same as SOUNDEX(expr1) = SOUNDEX(expr2).

SPACE(N)
Returns a string consisting of N space characters.

SQL> SELECT SPACE(6);

+---------------------------------------------------------+
| SELECT SPACE(6) |
+---------------------------------------------------------+
| ' ' |
+---------------------------------------------------------+
1 row in set (0.00 sec)

STRCMP(str1, str2)
Compares two string s and returns 0 if both string s are equal, it returns -1 if the first arg ument is smaller than the
second according to the current sort order otherwise it returns 1.

SQL> SELECT STRCMP('MOHD', 'MOHD');

+---------------------------------------------------------+
| STRCMP('MOHD', 'MOHD') |
+---------------------------------------------------------+
| 0 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Another example is:

SQL> SELECT STRCMP('AMOHD', 'MOHD');

+---------------------------------------------------------+
| STRCMP('AMOHD', 'MOHD') |
+---------------------------------------------------------+
| -1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Let's see one more example:

SQL> SELECT STRCMP('MOHD', 'AMOHD');

+---------------------------------------------------------+
| STRCMP('MOHD', 'AMOHD') |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBSTRING(str,pos)
SUBSTRING(str FROM pos)
SUBSTRING(str,pos,len)
SUBSTRING(str FROM pos FOR len)
T he forms without a len arg ument return a substring from string str starting at position pos. T he forms with a len
arg ument return a substring len characters long from string str, starting at position pos. T he forms that use
FROM are standard SQL syntax. It is also possible to use a neg ative value for pos. In this case, the beg inning of
the substring is pos characters from the end of the string , rather than the beg inning . A neg ative value may be
used for pos in any of the forms of this function.

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)

SUBSTRING_INDEX(str,delim,count)
Returns the substring from string str before count occurrences of the delimiter delim. If count is positive,
everything to the left of the final delimiter (counting from the left) is returned. If count is neg ative, everything to
the rig ht of the final delimiter (counting from the rig ht) is returned. SUBST RING_INDEX() performs a case-
sensitive match when searching for delim.

SQL> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);

+---------------------------------------------------------+
| SUBSTRING_INDEX('www.mysql.com', '.', 2) |
+---------------------------------------------------------+
| www.mysql |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str)

TRIM([remstr FROM] str)
Returns the string str with all remstr prefixes or suffixes removed. If none of the specifiers BOT H, LEADING,
or T RAILING is g iven, BOT H is assumed. remstr is optional and, if not specified, spaces are removed.

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)

UCASE(str)
UCASE() is a synonym for UPPER().

UNHEX(str)
Performs the inverse operation of HEX(str). T hat is, it interprets each pair of hexadecimal dig its in the arg ument
as a number and converts it to the character represented by the number. T he resulting characters are returned
as a binary string .

SQL> SELECT UNHEX('4D7953514C');

+---------------------------------------------------------+
| UNHEX('4D7953514C') |
+---------------------------------------------------------+
| SQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)

T he characters in the arg ument string must be leg al hexadecimal dig its: '0' .. '9', 'A' .. 'F', 'a' .. 'f'. If UNHEX()
encounters any non-hexadecimal dig its in the arg ument, it returns NULL.

UPPER(str)
Returns the string str with all characters chang ed to uppercase according to the current character set mapping .

SQL> SELECT UPPER('Allah-hus-samad');

+---------------------------------------------------------+
| UPPER('Allah-hus-samad') |
+---------------------------------------------------------+
| ALLAH-HUS-SAMAD |
+---------------------------------------------------------+
1 row in set (0.00 sec)