MySQL :: MySQL 5.6 リファレンスマニュアル

MySQL 5.6 リファレンスマニュアル / 関数と演算子 / 文字列関数

12.5 文字列関数

12.5.1 文字列比較関数
12.5.2 正規表現

表 12.7 文字列演算子

名前	説明
`ASCII()`	左端の文字の数値を返します
`BIN()`	数値のバイナリ表現を含む文字列を返します
`BIT_LENGTH()`	ビット単位で引数の長さを返します
`CHAR()`	渡された各整数の文字を返します
`CHAR_LENGTH()`	引数の文字数を返します
`CHARACTER_LENGTH()`	CHAR_LENGTH() のシノニムです
`CONCAT()`	連結された文字列を返します
`CONCAT_WS()`	連結されたものをセパレータ付きで返します
`ELT()`	インデックス番号位置の文字列を返します
`EXPORT_SET()`	値 bits 内の各ビットが設定されている場合は on 文字列を取得し、各ビットが設定されていない場合には off 文字列を取得するように、文字列を返します
`FIELD()`	後続の引数内で第 1 引数のインデックス (位置) を返します
`FIND_IN_SET()`	第 2 引数内で第 1 引数のインデックス位置を返します
`FORMAT()`	指定された小数点以下桁数に書式設定された数値を返します
`FROM_BASE64()` (導入 5.6.1)	base 64 文字列にデコードして結果を返します
`HEX()`	10 進値または文字列値の 16 進表現を返します
`INSERT()`	部分文字列を、指定された位置に指定された文字数だけ挿入します
`INSTR()`	部分文字列が最初に出現する位置のインデックスを返します
`LCASE()`	LOWER() のシノニムです
`LEFT()`	左端から指定された数の文字を返します
`LENGTH()`	文字列の長さをバイト単位で返します
`LIKE`	単純なパターン一致
`LOAD_FILE()`	指定されたファイルをロードします
`LOCATE()`	部分文字列が最初に出現する位置を返します
`LOWER()`	引数を小文字で返します
`LPAD()`	指定された文字列で左からパディングした文字列引数を返します
`LTRIM()`	先頭の空白を削除します
`MAKE_SET()`	bits セット内の対応するビットを持つ、カンマ区切り文字列のセットを返します
`MATCH`	全文検索を実行します
`MID()`	指定された位置から始まる部分文字列を返します
`NOT LIKE`	単純なパターン一致の否定
`NOT REGEXP`	REGEXP の否定
`OCT()`	数値の 8 進数表現を含む文字列を返します
`OCTET_LENGTH()`	LENGTH() のシノニムです
`ORD()`	引数の左端の文字の文字コードを返します
`POSITION()`	LOCATE() のシノニムです
`QUOTE()`	SQL ステートメント内で使用するために引数をエスケープします
`REGEXP`	正規表現を使用したパターン一致
`REPEAT()`	文字列を指定された回数だけ繰り返します
`REPLACE()`	指定された文字列の出現箇所を置き換えます
`REVERSE()`	文字列内の文字を逆順に並べ替えます
`RIGHT()`	右端から指定された数の文字を返します
`RLIKE`	REGEXP のシノニムです
`RPAD()`	指定された回数だけ文字列を追加します
`RTRIM()`	末尾の空白を削除します
`SOUNDEX()`	soundex 文字列を返します
`SOUNDS LIKE`	音声を比較します
`SPACE()`	指定された数の空白で構成される文字列を返します
`STRCMP()`	2 つの文字列を比較します
`SUBSTR()`	指定された部分文字列を返します
`SUBSTRING()`	指定された部分文字列を返します
`SUBSTRING_INDEX()`	文字列から、区切り文字が指定された回数出現する前の部分文字列を返します
`TO_BASE64()` (導入 5.6.1)	base 64 文字列に変換された引数を返します
`TRIM()`	先頭と末尾にある空白を削除します
`UCASE()`	UPPER() のシノニムです
`UNHEX()`	数値の 16 進数表現を含む文字列を返します
`UPPER()`	大文字に変換します
`WEIGHT_STRING()`	文字列の重み文字列を返します

文字列値の関数は、結果の長さが max_allowed_packet システム環境変数の値よりも長くなると、NULL を返します。セクション8.11.2「サーバーパラメータのチューニング」を参照してください。

文字列の位置を操作する関数では、最初の位置には数値 1 が付けられます。

長さの引数を取る関数では、整数以外の引数はもっとも近い整数に丸められます。

ASCII(str)

文字列 str の左端の文字の数値を返します。str が空の文字列である場合は、0 を返します。str が NULL である場合は NULL を返します。ASCII() は、8 ビット文字の場合に動作します。
```
mysql> SELECT ASCII('2');
        -> 50
mysql> SELECT ASCII(2);
        -> 50
mysql> SELECT ASCII('dx');
        -> 100
```
ORD() 関数も参照してください。
BIN(N)

N のバイナリ値の文字列表現を返します。N は longlong (BIGINT) 数字です。これは、CONV(N,10,2) と同等です。N が NULL である場合は NULL を返します。
```
mysql> SELECT BIN(12);
        -> '1100'
```
BIT_LENGTH(str)

文字列 str の長さをビット単位で返します。
```
mysql> SELECT BIT_LENGTH('text');
        -> 32
```

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

CHAR() は各 N 引数を整数として解釈し、それらの整数のコード値で指定された文字を構成している文字列を返します。NULL 値はスキップされます。

mysql> SELECT CHAR(77,121,83,81,'76');
        -> 'MySQL'
mysql> SELECT CHAR(77,77.3,'77.3');
        -> 'MMM'

255 よりも大きい CHAR() 引数は、複数の結果バイトに変換されます。たとえば、CHAR(256) は CHAR(1,0) に同等で、CHAR(256*256) は CHAR(1,0,0) に同等です。

mysql> SELECT HEX(CHAR(1,0)), HEX(CHAR(256));
+----------------+----------------+
| HEX(CHAR(1,0)) | HEX(CHAR(256)) |
+----------------+----------------+
| 0100           | 0100           |
+----------------+----------------+
mysql> SELECT HEX(CHAR(1,0,0)), HEX(CHAR(256*256));
+------------------+--------------------+
| HEX(CHAR(1,0,0)) | HEX(CHAR(256*256)) |
+------------------+--------------------+
| 010000           | 010000             |
+------------------+--------------------+

デフォルトでは、CHAR() はバイナリ文字列を返します。指定された文字セットで文字列を生成するには、オプションの USING 句を使用します。

mysql> SELECT CHARSET(CHAR(0x65)), CHARSET(CHAR(0x65 USING utf8));
+---------------------+--------------------------------+
| CHARSET(CHAR(0x65)) | CHARSET(CHAR(0x65 USING utf8)) |
+---------------------+--------------------------------+
| binary              | utf8                           |
+---------------------+--------------------------------+

USING が指定され、結果文字列が指定された文字セットで不正である場合は、警告が発行されます。また、厳密な SQL モードが有効になっている場合は、CHAR() からの結果は NULL になります。

CHAR_LENGTH(str)

文字で測定された文字列 str の長さを返します。マルチバイト文字は、単一の文字としてカウントされます。つまり、5 つの 2 バイト文字を含む文字列では、LENGTH() は 10 を返し、CHAR_LENGTH() は 5 を返します。
CHARACTER_LENGTH(str)

CHARACTER_LENGTH() は CHAR_LENGTH() のシノニムです。
CONCAT(str1,str2,...)

引数を連結することで生成される文字列を返します。1 つ以上の引数を持つ場合があります。すべての引数が非バイナリ文字列の場合は、結果も非バイナリ文字列になります。引数にバイナリ文字列が含まれる場合は、結果はバイナリ文字列になります。数値の引数は、同等の非バイナリ文字列形式に変換されます。

引数のいずれかかが NULL である場合、CONCAT() は NULL を返します。
```
mysql> SELECT CONCAT('My', 'S', 'QL');
        -> 'MySQL'
mysql> SELECT CONCAT('My', NULL, 'QL');
        -> NULL
mysql> SELECT CONCAT(14.3);
        -> '14.3'
```
引用符で囲まれた文字列では、文字列を並べて配置することで連結が実行されます。
```
mysql> SELECT 'My' 'S' 'QL';
        -> 'MySQL'
```
CONCAT_WS(separator,str1,str2,...)

CONCAT_WS() は Concatenate With Separator (区切り文字を使用した連結) を表し、CONCAT() の特殊な形式です。最初の引数は、残りの引数の区切り文字です。区切り文字は、連結される文字列の間に追加されます。区切り文字は、残りの引数と同様に文字列にすることができます。区切り文字が NULL の場合は、結果も NULL になります。
```
mysql> SELECT CONCAT_WS(',','First name','Second name','Last Name');
        -> 'First name,Second name,Last Name'
mysql> SELECT CONCAT_WS(',','First name',NULL,'Last Name');
        -> 'First name,Last Name'
```
CONCAT_WS() では、空の文字列がスキップされません。ただし、区切り文字引数のあとの NULL 値はすべてスキップされます。
ELT(N,str1,str2,str3,...)

ELT() は、文字列リストの N 番目の要素を返します。N = 1 の場合は str1、N = 2 の場合は str2 のように返します。N が 1 よりも小さいか、引数の数よりも大きい場合は、NULL を返します。ELT() は FIELD() の補数です。
```
mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
        -> 'ej'
mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo');
        -> 'foo'
```
EXPORT_SET(bits,on,off[,separator[,number_of_bits]])

値 bits 内で各ビットが設定されている場合には on 文字列を取得し、値内で各ビットが設定されていない場合には off 文字列を取得するように、文字列を返します。bits のビットは、右から左 (下位ビットから上位ビット) へと検証されます。文字列は、separator 文字列 (デフォルトはカンマ文字「,」) で区切られた結果に左から右へと追加されます。検証されるビット数は、number_of_bits で指定されます。指定されない場合のデフォルトは 64 です。number_of_bits が 64 よりも大きい場合は、警告なしで 64 に短縮されます。符号なし整数として処理されるため、値 −1 は実際には 64 と同じです。
```
mysql> SELECT EXPORT_SET(5,'Y','N',',',4);
        -> 'Y,N,Y,N'
mysql> SELECT EXPORT_SET(6,'1','0',',',10);
        -> '0,1,1,0,0,0,0,0,0,0'
```
FIELD(str,str1,str2,str3,...)

str1、str2、str3、... リスト内で str のインデックス (位置) を返します。str が見つからない場合は、0 を返します。

FIELD() へのすべての引数が文字列の場合は、すべての引数が文字列として比較されます。すべての引数が数値の場合は、数字として比較されます。それ以外の場合は、引数が倍精度として比較されます。

NULL ではどの値との等価比較にも失敗するため、str が NULL である場合は、戻り値が 0 になります。FIELD() は ELT() の補数です。
```
mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
        -> 2
mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');
        -> 0
```
FIND_IN_SET(str,strlist)

文字列 str が N 部分文字列で構成される文字列リスト strlist 内にある場合は、1 から N までの範囲内の値を返します。文字列リストは、「,」文字で区切られた部分文字列で構成された文字列です。最初の引数が定数文字列で、2 番目が SET 型のカラムの場合、FIND_IN_SET() 関数はビット演算を使用するために最適化されます。str が strlist 内にない場合、または strlist が空の文字列の場合は、0 を返します。引数のいずれかが NULL である場合は、NULL を返します。最初の引数にカンマ (「,」) 文字が含まれる場合は、この関数が正しく動作しません。
```
mysql> SELECT FIND_IN_SET('b','a,b,c,d');
        -> 2
```
FORMAT(X,D[,locale])

数値 X を '#,###,###.##' のような書式に変換し、小数点第 D 位に丸めて、その結果を文字列として返します。D が 0 の場合は、結果に小数点または小数部が含まれません。

オプションの 3 番目のパラメータを使用すると、結果数の小数点、3 桁の区切り文字、および区切り文字間のグループ化に使用されるロケールを指定できます。許可されるロケール値は、lc_time_names システム変数の有効な値と同じです (セクション10.7「MySQL Server のロケールサポート」を参照してください)。ロケールが指定されていない場合のデフォルトは、'en_US' です。
```
mysql> SELECT FORMAT(12332.123456, 4);
        -> '12,332.1235'
mysql> SELECT FORMAT(12332.1,4);
        -> '12,332.1000'
mysql> SELECT FORMAT(12332.2,0);
        -> '12,332'
mysql> SELECT FORMAT(12332.2,2,'de_DE');
        -> '12.332,20'
```
FROM_BASE64(str)

TO_BASE64() で使用される base-64 でエンコードされたルールでエンコードされた文字列が指定され、デコードされた結果をバイナリ文字列として返します。引数が NULL の場合または有効な base-64 文字列でない場合は、結果が NULL になります。ルールのエンコードおよびデコードについての詳細は、TO_BASE64() の説明を参照してください。

この関数は、MySQL 5.6.1 で追加されました。
```
mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
        -> 'JWJj', 'abc'
```
HEX(str), HEX(N)

文字列の引数 str では、HEX() は str の 16 進数文字列表現を返します。str 内の各文字の各バイトは、2 つの 16 進数字に変換されます。(したがって、マルチバイト文字は 2 桁よりも大きくなります。)この演算の逆は、UNHEX() 関数で実行されます。

数値の引数 N では、HEX() は、longlong (BIGINT) 数字として処理される N の 16 進数文字列表現を返します。これは、CONV(N,10.16) と同等です。この演算の逆は、CONV(HEX(N),16,10) で実行されます。
```
mysql> SELECT 0x616263, HEX('abc'), UNHEX(HEX('abc'));
        -> 'abc', 616263, 'abc'
mysql> SELECT HEX(255), CONV(HEX(255),16,10);
        -> 'FF', 255
```
INSERT(str,pos,len,newstr)

位置 pos で始まる部分文字列と、文字列 newstr で置換された len 文字長とともに、文字列 str を返します。pos が文字列の長さに収まらない場合は、元の文字列を返します。len が残りの文字列の長さに収まらない場合は、位置 pos からの残りの文字列を置換します。引数のいずれかが NULL である場合は、NULL を返します。
```
mysql> SELECT INSERT('Quadratic', 3, 4, 'What');
        -> 'QuWhattic'
mysql> SELECT INSERT('Quadratic', -1, 4, 'What');
        -> 'Quadratic'
mysql> SELECT INSERT('Quadratic', 3, 100, 'What');
        -> 'QuWhat'
```
この関数はマルチバイトセーフです。
INSTR(str,substr)

文字列 str 内で部分文字列 substr が最初に出現する位置を返します。これは、引数の順序が逆になる点を除いて、2 つの引数形式の LOCATE() と同じです。
```
mysql> SELECT INSTR('foobarbar', 'bar');
        -> 4
mysql> SELECT INSTR('xbar', 'foobar');
        -> 0
```
この関数はマルチバイトセーフであり、1 つ以上の引数がバイナリ文字列である場合にのみ大文字と小文字が区別されます。
LCASE(str)

LCASE() は LOWER() のシノニムです。
LEFT(str,len)

文字列 str から左端の len 文字を返し、引数が NULL である場合は NULL を返します。
```
mysql> SELECT LEFT('foobarbar', 5);
        -> 'fooba'
```
この関数はマルチバイトセーフです。
LENGTH(str)

バイトで測定された文字列 str の長さを返します。マルチバイト文字は、複数のバイトとしてカウントされます。つまり、5 つの 2 バイト文字を含む文字列では、LENGTH() は 10 を返し、CHAR_LENGTH() は 5 を返します。
```
mysql> SELECT LENGTH('text');
        -> 4
```
注記

Length() OpenGIS 空間関数は、MySQL では GLength() という名前です。
LOAD_FILE(file_name)

ファイルを読み取り、ファイルの内容を文字列として返します。この関数を使用するには、ファイルがサーバーホストに配置されている必要があり、ファイルへのフルパス名を指定し、FILE 権限を持つ必要があります。ファイルはすべてのユーザーから読み取り可能で、max_allowed_packet バイトよりも小さなサイズである必要があります。secure_file_priv システム変数が空でないディレクトリ名に設定されている場合は、そのディレクトリ内にロード対象のファイルが配置されている必要があります。

ファイルが存在しない場合、または上記の条件が満たされていないために、ファイルを読み取ることができない場合、この関数は NULL を返します。

character_set_filesystem システム変数では、リテラル文字列として指定されているファイル名の解釈が制御されます。
```
mysql> UPDATE t
            SET blob_col=LOAD_FILE('/tmp/picture')
            WHERE id=1;
```
LOCATE(substr,str), LOCATE(substr,str,pos)

1 番目の構文は、文字列 str 内で、部分文字列 substr が最初に出現する位置を返します。2 番目の構文は、文字列 str 内の位置 pos 以降で、部分文字列 substr が最初に出現する位置を返します。str 内に substr がない場合は、0 を返します。
```
mysql> SELECT LOCATE('bar', 'foobarbar');
        -> 4
mysql> SELECT LOCATE('xbar', 'foobar');
        -> 0
mysql> SELECT LOCATE('bar', 'foobarbar', 5);
        -> 7
```
この関数はマルチバイトセーフであり、1 つ以上の引数がバイナリ文字列である場合にのみ大文字と小文字が区別されます。
LOWER(str)

現在の文字セットのマッピングに従って、すべての文字が小文字に変更された文字列 str を返します。デフォルトは latin1 (cp1252 西ヨーロッパ言語) です。
```
mysql> SELECT LOWER('QUADRATICALLY');
        -> 'quadratically'
```
LOWER() (および UPPER()) をバイナリ文字列 (BINARY、VARBINARY、BLOB) に適用しても、何の効果もありません。大文字/小文字の変換を実行するには、バイナリ文字列を非バイナリ文字列に変換します。
```
mysql> SET @str = BINARY 'New York';
mysql> SELECT LOWER(@str), LOWER(CONVERT(@str USING latin1));
+-------------+-----------------------------------+
| LOWER(@str) | LOWER(CONVERT(@str USING latin1)) |
+-------------+-----------------------------------+
| New York    | new york                          |
+-------------+-----------------------------------+
```
Unicode 文字セットの場合、xxx_unicode_520_ci 照合順序およびそれらから派生した言語固有の照合順序では、LOWER() および UPPER() は Unicode 照合順序アルゴリズム (UCA) 5.2.0 に従って動作します。その他の Unicode 照合では、LOWER() および UPPER() は Unicode 照合アルゴリズム (UCA) 4.0.0 に従って動作します。セクション10.1.14.1「Unicode 文字セット」を参照してください。

この関数はマルチバイトセーフです。
LPAD(str,len,padstr)

len 文字の長さになるように文字列 padstr で左にパディングされた文字列 str を返します。str が len よりも長い場合は、戻り値は len 文字に短縮されます。
```
mysql> SELECT LPAD('hi',4,'??');
        -> '??hi'
mysql> SELECT LPAD('hi',1,'??');
        -> 'h'
```
LTRIM(str)

先頭の空白文字が削除された文字列 str を返します。
```
mysql> SELECT LTRIM('  barbar');
        -> 'barbar'
```
この関数はマルチバイトセーフです。
MAKE_SET(bits,str1,str2,...)

bits セット内の対応するビットを持つ文字列で構成されるセット値 (「,」文字で区切られた部分文字列を含む文字列) を返します。str1 はビット 0 に対応し、str2 はビット 1 に対応する、などとなります。str1、str2、... 内の NULL 値は結果に追加されません。
```
mysql> SELECT MAKE_SET(1,'a','b','c');
        -> 'a'
mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');
        -> 'hello,world'
mysql> SELECT MAKE_SET(1 | 4,'hello','nice',NULL,'world');
        -> 'hello'
mysql> SELECT MAKE_SET(0,'a','b','c');
        -> ''
```
MID(str,pos,len)

MID(str,pos,len) は、SUBSTRING(str,pos,len) のシノニムです。
OCT(N)

N の 8 進数の文字列表現を返します。N は longlong (BIGINT) 数字です。これは、CONV(N,10.8) と同等です。N が NULL である場合は NULL を返します。
```
mysql> SELECT OCT(12);
        -> '14'
```
OCTET_LENGTH(str)

OCTET_LENGTH() は LENGTH() のシノニムです。
ORD(str)

文字列 str の左端の文字がマルチバイト文字である場合は、その文字のコードを返します。コードは、次の計算式を使用して、その構成要素の数値から計算されます。
```
  (1st byte code)
+ (2nd byte code * 256)
+ (3rd byte code * 2562) ...
```
左端の文字がマルチバイト文字でない場合は、ORD() は ASCII() 関数と同じ値を返します。
```
mysql> SELECT ORD('2');
        -> 50
```
POSITION(substr IN str)

POSITION(substr IN str) は LOCATE(substr,str) のシノニムです。
QUOTE(str)

SQL ステートメントで、適切にエスケープされたデータ値として使用できる結果を生成する文字列を引用符で囲みます。一重引用符で囲まれ、バックスラッシュの後ろにバックスラッシュ (「\」)、一重引用符 (「'」)、ASCII NUL、および Control+Z の各インスタンスが続く文字列が返されます。引数が NULL の場合の戻り値は、一重引用符で囲まれていない単語「NULL」です。
```
mysql> SELECT QUOTE('Don\'t!');
        -> 'Don\'t!'
mysql> SELECT QUOTE(NULL);
        -> NULL
```
比較するために、セクション9.1.1「文字列リテラル」およびセクション23.7.7.54「mysql_real_escape_string()」で、リテラル文字列に対する引用ルールと C API 内の引用ルールを参照してください。
REPEAT(str,count)

count 回繰り返された文字列 str で構成される文字列を返します。count が 1 よりも小さい場合は、空の文字列を返します。str または count が NULL である場合は NULL を返します。
```
mysql> SELECT REPEAT('MySQL', 3);
        -> 'MySQLMySQLMySQL'
```
REPLACE(str,from_str,to_str)

文字列 from_str のすべての出現箇所が文字列 to_str で置換された、文字列 str を返します。REPLACE() は、from_str を検索する際に、大文字と小文字を区別した一致を実行します。
```
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
        -> 'WwWwWw.mysql.com'
```
この関数はマルチバイトセーフです。
REVERSE(str)

文字の順序が逆になった文字列 str を返します。
```
mysql> SELECT REVERSE('abc');
        -> 'cba'
```
この関数はマルチバイトセーフです。
RIGHT(str,len)

文字列 str から右端の len 文字を返し、引数が NULL である場合は NULL を返します。
```
mysql> SELECT RIGHT('foobarbar', 4);
        -> 'rbar'
```
この関数はマルチバイトセーフです。
RPAD(str,len,padstr)

len 文字の長さになるように文字列 padstr で右にパディングされた文字列 str を返します。str が len よりも長い場合は、戻り値は len 文字に短縮されます。
```
mysql> SELECT RPAD('hi',5,'?');
        -> 'hi???'
mysql> SELECT RPAD('hi',1,'?');
        -> 'h'
```
この関数はマルチバイトセーフです。
RTRIM(str)

末尾の空白文字が削除された文字列 str を返します。
```
mysql> SELECT RTRIM('barbar   ');
        -> 'barbar'
```
この関数はマルチバイトセーフです。
SOUNDEX(str)

str から soundex 文字列を返します。ほぼ同じ発音の 2 つの文字列は、同じ soundex 文字列を持つはずです。標準の soundex 文字列の長さは 4 文字ですが、SOUNDEX() 関数は任意の長さの文字列を返します。結果で SUBSTRING() を使用すると、標準の soundex 文字列を取得できます。str 内のアルファベット以外の文字はすべて無視されます。A から Z までの範囲外の国際アルファベット文字はすべて、母音として処理されます。

重要

SOUNDEX() の使用時には、次の制限に注意してください。
- 現在実装されているこの関数は、文字列の言語が英語である場合にのみ機能するように設計されています。その他の言語の文字列では、信頼できる結果が生成されない可能性があります。
- この関数では、文字列でマルチバイト文字セット (utf-8 など) が使用されている場合に、整合性のある結果が生成されることは保証されません。
  
  今後のリリースで、このような制限が解除されることを期待しています。詳細は、Bug #22638 を参照してください。
```
mysql> SELECT SOUNDEX('Hello');
        -> 'H400'
mysql> SELECT SOUNDEX('Quadratically');
        -> 'Q36324'
```
注記

この関数には、オリジナルの Soundex アルゴリズムが実装されています。より人気のある拡張バージョンではありません (この作成者も D. Knuth です)。相違点としては、元のバージョンではまず母音が破棄されてから複製が破棄されますが、拡張バージョンではまず複製が破棄されてから母音が破棄されます。
expr1 SOUNDS LIKE expr2

これは、SOUNDEX(expr1) = SOUNDEX(expr2) と同じです。
SPACE(N)

N 空白文字で構成される文字列を返します。
```
mysql> SELECT SPACE(6);
        -> '      '
```
SUBSTR(str,pos), SUBSTR(str FROM pos), SUBSTR(str,pos,len), SUBSTR(str FROM pos FOR len)

SUBSTR() は SUBSTRING() のシノニムです。
SUBSTRING(str,pos), SUBSTRING(str FROM pos), SUBSTRING(str,pos,len), SUBSTRING(str FROM pos FOR len)

len 引数を付けない形式では、位置 pos で始まる文字列 str からの部分文字列が返されます。len 引数を付けた形式では、位置 pos で始まる文字列 str からの部分文字列 len 文字長が返されます。FROM を使用する形式は、標準の SQL 構文です。また、pos に負の値を使用することもできます。その場合、部分文字列の先頭は文字列の先頭でなく、文字列の末尾からの pos 文字になります。この関数のどの形式でも、pos で負の値を使用できます。

すべての形式の SUBSTRING() で、部分文字列の抽出が開始される文字列内の最初の文字の位置が 1 とみなされます。
```
mysql> SELECT SUBSTRING('Quadratically',5);
        -> 'ratically'
mysql> SELECT SUBSTRING('foobarbar' FROM 4);
        -> 'barbar'
mysql> SELECT SUBSTRING('Quadratically',5,6);
        -> 'ratica'
mysql> SELECT SUBSTRING('Sakila', -3);
        -> 'ila'
mysql> SELECT SUBSTRING('Sakila', -5, 3);
        -> 'aki'
mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2);
        -> 'ki'
```
この関数はマルチバイトセーフです。

len が 1 よりも小さい場合は、結果が空の文字列になります。
SUBSTRING_INDEX(str,delim,count)

文字列 str から、区切り文字 delim が count 回出現する前の部分文字列を返します。count が正の値の場合は、(左から数えて) 最後の区切り文字の左側にあるすべてが返されます。count が負の値の場合は、(右から数えて) 最後の区切り文字の右側にあるすべてが返されます。SUBSTRING_INDEX() は、delim を検索する際に、大文字と小文字を区別した一致を実行します。
```
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
        -> 'www.mysql'
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);
        -> 'mysql.com'
```
この関数はマルチバイトセーフです。
TO_BASE64(str)

文字列の引数を base-64 でエンコードされた形式に変換し、その結果を接続文字セットと照合順序が含まれる文字列として返します。引数が文字列でない場合は、変換が実行される前に文字列に変換されます。引数が NULL である場合は、結果も NULL になります。FROM_BASE64() 関数を使用すると、base-64 でエンコードされた文字列をデコードできます。

この関数は、MySQL 5.6.1 で追加されました。
```
mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
        -> 'JWJj', 'abc'
```
さまざまな base-64 エンコードスキームが存在します。これらは、TO_BASE64() および FROM_BASE64() で使用されるエンコードおよびデコードのルールです。
- アルファベット値 62 のエンコードは '+' です。
- アルファベット値 63 のエンコードは '/' です。
- エンコードされた出力は、出力可能な 4 文字のグループで構成されます。入力データの各 3 バイトは、4 文字を使用してエンコードされます。最後のグループが不完全な場合は、長さが 4 になるまで '=' 文字でパディングされます。
- 長い出力を複数の行に分割するために、エンコードされた出力の各 76 文字の後ろに改行が追加されます。
- デコードでは改行、復帰改行、タブ、および空白が認識および無視されます。
TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM([remstr FROM] str)

すべての remstr プリフィクスまたはサフィクスが削除された文字列 str を返します。BOTH、LEADING、TRAILING のいずれの指定子も指定されない場合は、BOTH が指定されたとみなされます。remstr はオプションであり、指定されない場合は空白文字が削除されます。
```
mysql> SELECT TRIM('  bar   ');
        -> 'bar'
mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
        -> 'barxxx'
mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
        -> 'bar'
mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
        -> 'barx'
```
この関数はマルチバイトセーフです。
UCASE(str)

UCASE() は UPPER() のシノニムです。
UNHEX(str)

文字列の引数 str では、UNHEX(str) は引数の各文字ペアを 16 進数として解釈し、その数字で表されたバイトに変換します。戻り値はバイナリ文字列です。
```
mysql> SELECT UNHEX('4D7953514C');
        -> 'MySQL'
mysql> SELECT 0x4D7953514C;
        -> 'MySQL'
mysql> SELECT UNHEX(HEX('string'));
        -> 'string'
mysql> SELECT HEX(UNHEX('1267'));
        -> '1267'
```
引数文字列内の文字は、正当な 16 進数である必要があります: '0' .. '9'、'A' ..'F'、'a' .. 'f'。引数に 16 進以外の数字が含まれている場合は、結果が NULL になります。
```
mysql> SELECT UNHEX('GG');
+-------------+
| UNHEX('GG') |
+-------------+
| NULL        |
+-------------+
```
UNHEX() への引数が BINARY カラムである場合は、格納時に値に 0x00 バイトがパディングされますが、それらのバイトは取得時に削除されないため、結果が NULL になる可能性があります。たとえば、'41' は '41 ' として CHAR(3) カラムに格納され、(末尾にパディングされた空白文字が削除された) '41' として取得されるため、カラム値に対する UNHEX() では 'A' が返されます。反対に、'41' は '41\0' として BINARY(3) カラムに格納され、(末尾にパディングされた 0x00 バイトが削除されない) '41\0' として取得されます。'\0' は不正な 16 進数であるため、カラム値に対する UNHEX() では NULL が返されます。

数値の引数 N の場合、HEX(N) の逆は UNHEX() では実行されません。代わりに、CONV(HEX(N),16,10) を使用してください。HEX() の説明を参照してください。
UPPER(str)

現在の文字セットのマッピングに従って、すべての文字が大文字に変更された文字列 str を返します。デフォルトは latin1 (cp1252 西ヨーロッパ言語) です。
```
mysql> SELECT UPPER('Hej');
        -> 'HEJ'
```
UPPER() にも適用される情報については、LOWER() の説明を参照してください。これには、現在は機能が無効になっているバイナリ文字列 (BINARY、VARBINARY、BLOB) の大文字と小文字の変換を実行する方法に関する情報、および Unicode 文字セットの大文字と小文字の変換に関する情報が含まれていました。

この関数はマルチバイトセーフです。
WEIGHT_STRING(str [AS {CHAR|BINARY}(N)] [LEVEL levels] [flags])

levels: N [ASC|DESC|REVERSE] [, N [ASC|DESC|REVERSE]] ...

この関数は、入力文字列の重み文字列を返します。戻り値は、文字列のソートおよび比較の値を表すバイナリ文字列です。これらのプロパティーがあります。
- WEIGHT_STRING(str1) = WEIGHT_STRING(str2) の場合は、str1 = str2 です (str1 と str2 は等しいとみなされます)。
- WEIGHT_STRING(str1) < WEIGHT_STRING(str2) の場合は、str1 < str2 です (str1 は str2 の前にソートされます)。
WEIGHT_STRING() は、照合順序のテストおよびデバッグを行う際、特に新しい照合順序を追加する場合に使用できます。セクション10.4「文字セットへの照合順序の追加」を参照してください。

入力文字列 str は文字列式です。入力が非バイナリ (文字) 文字列 (CHAR、VARCHAR、TEXT 値など) である場合は、戻り値に文字列の照合順序重みが含まれます。入力がバイナリ (バイト) 文字列 (BINARY、VARBINARY、BLOB 値など) である場合は、戻り値は入力と同じです (バイナリ文字列のバイトごとの重みはバイト値です)。入力が NULL である場合は、WEIGHT_STRING() は NULL を返します。

例:
```
mysql> SET @s = _latin1 'AB' COLLATE latin1_swedish_ci;
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| AB   | 4142    | 4142                   |
+------+---------+------------------------+
```
```
mysql> SET @s = _latin1 'ab' COLLATE latin1_swedish_ci;
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| ab   | 6162    | 4142                   |
+------+---------+------------------------+
```
```
mysql> SET @s = CAST('AB' AS BINARY);
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| AB   | 4142    | 4142                   |
+------+---------+------------------------+
```
```
mysql> SET @s = CAST('ab' AS BINARY);
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| ab   | 6162    | 6162                   |
+------+---------+------------------------+
```
上記の例では、HEX() を使用して WEIGHT_STRING() の結果を表示しています。結果はバイナリ値であるため、結果に出力されない値が含まれるときに出力可能な形式で表示する際に、HEX() が特に役立ちます。
```
mysql> SET @s = CONVERT(0xC39F USING utf8) COLLATE utf8_czech_ci;
mysql> SELECT HEX(WEIGHT_STRING(@s));
+------------------------+
| HEX(WEIGHT_STRING(@s)) |
+------------------------+
| 0FEA0FEA               |
+------------------------+
```
非 NULL の戻り値では、長さが VARBINARY の最大長内である場合は、値のデータ型が VARBINARY であり、その他の場合はデータ型は BLOB です。

入力文字列を非バイナリまたはバイナリの文字列にキャストし、強制的に指定した長さになるように、AS 句が指定されている場合があります。
- AS CHAR(N) は、文字列を非バイナリ文字列にキャストし、N 文字の長さになるように空白文字で右側をパディングします。N は少なくとも 1 にする必要があります。N が入力文字列の長さよりも小さい場合は、文字列が N 文字まで切り捨てられます。切り捨てられても警告は発生しません。
- AS BINARY(N) は、文字列がバイナリ文字列にキャストされ、N が (文字単位ではなく) バイト単位で測定され、パディングで (空白文字でななく) 0x00 バイトが使用される点を除いて同様です。
```
mysql> SELECT HEX(WEIGHT_STRING('ab' AS CHAR(4)));
+-------------------------------------+
| HEX(WEIGHT_STRING('ab' AS CHAR(4))) |
+-------------------------------------+
| 41422020                            |
+-------------------------------------+
```
```
mysql> SELECT HEX(WEIGHT_STRING('ab' AS BINARY(4)));
+---------------------------------------+
| HEX(WEIGHT_STRING('ab' AS BINARY(4))) |
+---------------------------------------+
| 61620000                              |
+---------------------------------------+
```
戻り値に特定の照合順序レベルに合った重みが含まれるように指定するために、LEVEL 句が指定される場合があります。

カンマで区切られた 1 つ以上の整数のリストとして、またはダッシュで区切られた 2 つの整数の範囲として、LEVEL キーワードの後ろに levels 指定子が指定される場合があります。句読文字の前後の空白の有無は影響しません。

例:
```
LEVEL 1
LEVEL 2, 3, 5
LEVEL 1-3
```
1 よりも低いレベルは 1 として処理されます。入力文字列照合順序の最大値よりも高いレベルは、照合順序の最大値として処理されます。最大値は照合順序ごとに異なりますが、6 よりも大きい値にはなりません。

レベルのリストでは、レベルを小さい順に指定する必要があります。レベルの範囲では、2 番目の数字が 1 番目よりも小さい場合は、1 番目の数字として処理されます (たとえば、4-2 は 4-4 と同じになります)。

LEVEL 句が省略された場合は、MySQL では LEVEL 1 - max であるとみなされます。ここで、max は照合順序の最大レベルです。

LEVEL が (範囲構文ではなく) リスト構文を使用して指定されている場合は、レベルの数字のあとに次の修飾子を指定できます。
- ASC: 変更なしで重みを返します。これはデフォルトです。
- DESC: ビット反転された重みを返します (たとえば、0x78f0 DESC = 0x870f です)。
- REVERSE: 逆順で重み (つまり、最初の文字を最後に、最後の文字を最後にと、逆に並べた文字列の重み) を返します。
例:
```
mysql> SELECT HEX(WEIGHT_STRING(0x007fff LEVEL 1));
+--------------------------------------+
| HEX(WEIGHT_STRING(0x007fff LEVEL 1)) |
+--------------------------------------+
| 007FFF                               |
+--------------------------------------+
```
```
mysql> SELECT HEX(WEIGHT_STRING(0x007fff LEVEL 1 DESC));
+-------------------------------------------+
| HEX(WEIGHT_STRING(0x007fff LEVEL 1 DESC)) |
+-------------------------------------------+
| FF8000                                    |
+-------------------------------------------+
```
```
mysql> SELECT HEX(WEIGHT_STRING(0x007fff LEVEL 1 REVERSE));
+----------------------------------------------+
| HEX(WEIGHT_STRING(0x007fff LEVEL 1 REVERSE)) |
+----------------------------------------------+
| FF7F00                                       |
+----------------------------------------------+
```
```
mysql> SELECT HEX(WEIGHT_STRING(0x007fff LEVEL 1 DESC REVERSE));
+---------------------------------------------------+
| HEX(WEIGHT_STRING(0x007fff LEVEL 1 DESC REVERSE)) |
+---------------------------------------------------+
| 0080FF                                            |
+---------------------------------------------------+
```
現在、flags 句は使用されていません。

PREV HOME UP NEXT