第11章関数と演算子/アダルトレンタルサーバーのサパネットワークス

第11章関数と演算子
前のページ?	?	?次のページ

第11章関数と演算子

式は SQL 文のいくつかのポイントで使用するできます。例えば、SELECT 文の ORDER BY 句や HAVING 句、SELECT 文、DELETE 文、UPDATE 文の WHERE 句、または SET 文で使用することができます。式は、リテラル値やカラム値、NULL 、組み込み関数、ストアドファンクション、ユーザ定義の関数、そして演算子で書くことができます。この章は、MySQL で式を書くことができる関数と演算子を説明します。ストアドファンクションおよびユーザ定義の関数の書き方は、章?17. ストアドプロシージャとファンクション と項25.3. 「Adding New Functions to MySQL」にあります。サーバが、異なる関数の引用をどう解釈するかについてのルールは、項8.2.4. 「構文解析と解像度のファンクション名」を参照してください。

NULL を含む式は、その関数または演算子の資料で特別に説明されていない限り、常に NULL 値を生成します。

注記 :デフォルトでは、関数名とそれに続く丸括弧 (()) の間にはスペースを入れないことになっています。これは、MySQL パーサが、関数呼び出しと、関数と同じ名前を持つテーブルまたはカラムの参照を区別するのに役立ちます。しかし、関数インスウの周りにスペースを入れることは許可されています。

MySQL サーバが関数名の後のスペースを受け入れることは、--sql-mode=IGNORE_SPACE オプションで開始することで分かります。( 項4.2.6. 「SQL モード」参照 ) 各クライアントプログラムは、mysql_real_connect() に CLIENT_IGNORE_SPACE オプションを使用することによって、この動作を指定することができます。どちらの場合でも、すべての関数名は予約語になります。

簡略化のため、この章で挙げられるほとんどの例は、省略形で mysql プログラムからの出力を記載しています。例は以下のようには表示されず :

mysql> SELECT MOD(29,9);
+-----------+
| mod(29,9) |
+-----------+
|         2 |
+-----------+
1 rows in set (0.00 sec)

このようなフォーマットで記されます :

mysql> SELECT MOD(29,9);
        -> 2

注意

この章には多くの情報が含まれているため、特定の関数や演算子の情報を探すのは容易ではありません。情報の検索をより簡単にするため、各関数および演算子へのアンカーがこのマニュアルには加えられています。この資料の HTML バージョンでは、目的の関数がどの HTML ページに掲載されているかが分かれば、直接その関数へナビゲートすることができます。これは、#function_function-name を URL に追加することで可能になります。例えば、この資料のオンラインバージョンで DATE_FORMAT 関数の情報を探す場合は、日付時刻関数についての説明があるページに行き ( http://dev.mysql.com/doc/refman/5.1/en/date-and-time-functions.html ) 、ウェブブラウザのアドレスバーのアドレスに #function_date-format を加えます。これで、DATE_FORMAT 関数に直接飛ぶことができます。資料を単一ページバージョンでダウンロードした場合は、単に適切なアンカーの引用を追加してください。これと同様の方法で、適切な URL に #operator_operator-name を加えることによって、特定の演算子に飛ぶことも可能です。

11.1. 演算子

11.1.1. 演算子の優先順位
11.1.2. 式評価でのタイプ変換
11.1.3. 比較関数と演算子
11.1.4. 論理演算子

11.1.1. 演算子の優先順位

演算子の優先順位は、次の表で優先順位の低いものから高いものへと示されています。同じ行に並んで記載されている演算子は、優先順位が同じものです。

:=
||, OR, XOR
&&, AND
NOT
BETWEEN, CASE, WHEN, THEN, ELSE
=, <=>, >=, >, <=, <, <>, !=, IS, LIKE, REGEXP, IN
|
&
<<, >>
-, +
*, /, DIV, %, MOD
^
- (unary minus), ~ (unary bit inversion)
!
BINARY, COLLATE

注記 :HIGH_NOT_PRECEDENCE SQL モードが有効になっていると、NOT の優先順位は ! 演算子と同じになります。項4.2.6. 「SQL モード」をご参照ください。

演算子の優先順位は、式の項の評価の順序を決定します。この順位とグループを明示的に上書きするには、丸括弧 (()) を使用します。例 :

mysql> SELECT 1+2*3;
        -> 7
mysql> SELECT (1+2)*3;
        -> 9

11.1.2. 式評価でのタイプ変換

演算子が異なるタイプのオペランドと共に使用される場合、オペランドを適合化するため、タイプ変換が起こります。変換のあるものは、暗黙的に発生します。例えば MySQL は、必要に応じて数字を自動的にストリングに変換、またはその逆を行います。

mysql> SELECT 1+'1';
        -> 2
mysql> SELECT CONCAT(2,' test');
        -> '2 test'

また、明示的な変換を行うことも可能です。数字を明示的にストリングに変換したい場合は、CAST() または CONCAT() 関数を使用してください ( CAST() を推奨 ) :

mysql> SELECT 38.8, CAST(38.8 AS CHAR);
        -> 38.8, '38.8'
mysql> SELECT 38.8, CONCAT(38.8);
        -> 38.8, '38.8'

次のルールは、比較の演算に対してどのように変換が行われるかを示しています :

一方か両方の引数が NULL の場合、比較の結果は、NULL-safe <=> 等値比較演算子以外は、NULL になります。NULL <=> NULL の場合、結果は true です。
比較の演算の両方の引数がストリングの場合、それらはストリングとして比較されます。
両方の引数が整数の場合、それらは整数として比較されます。
16 進値が数字として比較されない場合は、バイナリストリングとして扱われます。
引数の一方が TIMESTAMP または DATETIME カラムで、他の引数が定数の場合、定数は比較が行われる前に、タイムスタンプに変換されます。これは、ODBC により適合させるためです。これは IN() への引数には適用されませんのでご注意ください！　念のため、比較の際は常に完全な日付時刻、日付、または時刻ストリングを使用してください。
他のすべてのケースでは、引数は浮動少数点 ( 実 ) 数として比較されます。

次の例は、比較の演算の、ストリングから数字への変換を表したものです :

mysql> SELECT 1 > '6x';
        -> 0
mysql> SELECT 7 > '6x';
        -> 1
mysql> SELECT 0 > 'x6';
        -> 0
mysql> SELECT 0 = 'x6';
        -> 1

ストリングカラムを数字と比較する際、MySQL は、カラムのインデックスを使用して値を迅速に検索することができませんので注意してください。str_col がインデックスの付いたストリングカラムである場合は、そのインデックスを、次のステートメントで検索を行う時に使用することはできません :

SELECT * FROM tbl_name WHERE str_col=1;

その理由は、'1' 、' 1' 、または '1a' のように、値 1 に変換されうるストリングが数多くあるためです。

浮動小数点数 ( または浮動小数点数に変換される値 ) を使用する比較は、それらの数字は不正確であるため、概算になります。そのため、一貫性のない結果が導き出される場合があります :

mysql> SELECT '18015376320243458' = 18015376320243458;
        -> 1
mysql> SELECT '18015376320243459' = 18015376320243459;
        -> 0

そのような結果が発生しうるのは、53 ビットの精度しか持たない浮動小数点巣に値が変換され、丸めの対象になるためです :

mysql> SELECT '18015376320243459'+0.0;
        -> 1.8015376320243e+16

そのうえ、ストリングから浮動小数点への変換と、整数から浮動小数点への変換は、同様に起こらない場合もあります。整数は CPU によって浮動小数点に変換される可能性があり、対してストリングは、浮動小数点の掛け算を含む比較中の数字によって変換された数字であるためです。

表記されている結果はシステムによって異なり、コンピュータアーキテクチャやコンパイラのバージョン、または最適化のレベルなどの要素に影響される場合もあります。それらの問題を避ける方法のひとつとして、CAST() を使用すると、値が暗黙的に浮動小数点数に変換されなくなります :

mysql> SELECT CAST('18015376320243459' AS UNSIGNED) = 18015376320243459;
        -> 1

浮動小数点の比較についての詳細は、項B.1.5.8. 「Problems with Floating-Point Comparisons」をご覧ください。

11.1.3. 比較関数と演算子

比較の演算の結果は、1 ( TRUE ) 、0 ( FALSE ) 、または NULL の値になります。これらの演算は、数字とストリングの両方に適応します。必要に応じて、ストリングは数字に、数字はストリングに自動的に変換されます。

このセクションの関数のうちには、1 ( TRUE ) 、0 ( FALSE ) 、または NULL 以外の値を戻すものもあります。LEAST() および GREATEST() などがその例です。しかし、それらが戻す値は、項11.1.2. 「式評価でのタイプ変換」で説明されているルールによって行われた比較の演算に基づいています。

比較のために値を特定のタイプに変換するには、CAST() 関数を使用することができます。ストリング値は、CONVERT() を使用して、異なる文字セットに変換することが可能です。項11.8. 「キャスト関数と演算子」を参照してください。

デフォルトによって、文字比較は大文字小文字の区別の必要はなく、現在の文字セットを使用します。デフォルトは latin1 ( cp1252 West European ) で、English でも正常に作用します。

=

等しい :

mysql> SELECT 1 = 0;
        -> 0
mysql> SELECT '0' = 0;
        -> 1
mysql> SELECT '0.0' = 0;
        -> 1
mysql> SELECT '0.01' = 0;
        -> 0
mysql> SELECT '.01' = 0.01;
        -> 1

<=>
NULL - 安全等価。この演算は、= 演算子のように、等価比較を行いますが、両方のオペランドが NULL であれば、NULL でなく 1 を戻し、一方のオペランドが NULL の場合は、NULL でなく 0 を戻します。
```
mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
 -> 1, 1, 0
mysql> SELECT 1 = 1, NULL = NULL, 1 = NULL;
 -> 1, NULL, NULL
```

<>, !=

等しくない :

mysql> SELECT '.01' <> '0.01';
        -> 1
mysql> SELECT .01 <> '0.01';
        -> 0
mysql> SELECT 'zapp' <> 'zappp';
        -> 1

<=
より少ないか等しい :
```
mysql> SELECT 0.1 <= 2;
 -> 1
```
<
より少ない :
```
mysql> SELECT 2 < 2;
 -> 0
```
>=
より多いか等しい :
```
mysql> SELECT 2 >= 2;
        -> 1
```
>
より多い :
```
mysql> SELECT 2 > 2;
        -> 0
```

IS boolean_value, IS NOT boolean_value

boolean_value が TRUE か FALSE 、または UNKNOWN になり得る、ブーリアン値に対して値をテストします。

mysql> SELECT 1 IS TRUE, 0 IS FALSE, NULL IS UNKNOWN;
        -> 1, 1, 1
mysql> SELECT 1 IS NOT UNKNOWN, 0 IS NOT UNKNOWN, NULL IS NOT UNKNOWN;
        -> 1, 1, 0

IS NULL 、IS NOT NULL
値が NULL であるか否かをテストします。
```
mysql> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;
        -> 0, 0, 1
mysql> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
        -> 1, 1, 0
```
ODBC プログラムとうまく適合させるため、IS NULL を使用する場合、MySQL は次の追加機能をサポートします :
- 一番最近の AUTO_INCREMENT 値を含む行を、その値を生成した直後に、次のフォームのステートメントを発行することによって検索することができます :
```
SELECT * FROM tbl_name WHERE auto_col IS NULL
```
  この動作は、SQL_AUTO_IS_NULL=0 を設定すると無効になります。項12.5.3. 「SET 構文」を参照してください。
- NOT NULL として宣言された DATE および DATETIME カラムでは、次のようなステートメントを使用することで、特殊な日付 '0000-00-00' を検索することができます :
```
SELECT * FROM tbl_name WHERE date_column IS NULL
```
  ODBC は '0000-00-00' をサポートしていないため、ODBC アプリケーションのあるものの作動にこれが必要になります。
expr BETWEEN min AND max
expr が min より多いか等しく、expr が max より少ないか等しい場合、BETWEEN は 1 を戻し、それ以外では 0 を戻します。すべての引数が同じタイプの場合は、これは式 (min <= expr AND expr <= max) と等価になります。もしくは、項11.1.2. 「式評価でのタイプ変換」にあるルールによってタイプ変換が実施されますが、３つすべての引数に適用されます。
```
mysql> SELECT 1 BETWEEN 2 AND 3;
 -> 0
mysql> SELECT 'b' BETWEEN 'a' AND 'c';
 -> 1
mysql> SELECT 2 BETWEEN 2 AND '3';
 -> 1
mysql> SELECT 2 BETWEEN 2 AND 'x-3';
 -> 0
```
BETWEEN を日付値または時刻値と使用する場合に最善の結果を得るには、値を所望のデータタイプに明示的に変換するため、CAST() を使用します。例 : DATETIME をふたつの DATE 値と比較する場合、DATE 値を DATETIME 値に変換します。'2001-1-1' のようなストリング定数を、DATE との比較で使用する場合、ストリングを DATE にキャストします。
expr NOT BETWEEN min AND max
これは、NOT (expr BETWEEN min AND max) と同様です。

COALESCE(value,...)

リストの最初の非 NULL 値を戻すか、非 NULL 値がない場合は NULL を戻します。

mysql> SELECT COALESCE(NULL,1);
        -> 1
mysql> SELECT COALESCE(NULL,NULL,NULL);
        -> NULL

GREATEST(value1,value2,...)
引数ふたつ以上では、最大の ( 最大値の ) 引数を戻します。それらの引数は、LEAST() に対するものと同じルールで比較されます。
```
mysql> SELECT GREATEST(2,0);
        -> 2
mysql> SELECT GREATEST(34.0,3.0,5.0,767.0);
        -> 767.0
mysql> SELECT GREATEST('B','A','C');
        -> 'C'
```
引数のどれかが NULL である場合、GREATEST() は NULL を戻します。
expr IN (value,...)
expr が、IN リストのどれかの値と等しい場合は 1 を戻し、それ以外では 0 を戻します。すべての値が定数の場合、expr のタイプに基づいて評価し、分類します。その際の項目の検索は、バイナリ検索を使って行われます。これはつまり、IN は、IN 値のリストがすべて定数で構成されている場合、非常に速いということです。もしくは、項11.1.2. 「式評価でのタイプ変換」にあるルールによってタイプ変換が実施されますが、すべての引数に適用されます。
```
mysql> SELECT 2 IN (0,3,5,7);
        -> 0
mysql> SELECT 'wefwf' IN ('wee','wefwf','weg');
        -> 1
```
引用符で括られた値 ( ストリングなど ) と括られていない値 ( 数字など ) の比較ルールは異なるため、IN リストの引用符で括られた値と、括られていない値を決して混同しないでください。タイプの混同は、上記の理由により、結果の矛盾の原因になることがあります。例えば、IN 式を次のようには書かないでください :
```
SELECT val1 FROM tbl1 WHERE val1 IN (1,2,'a');
```
正しい書き方はこのようになります :
```
SELECT val1 FROM tbl1 WHERE val1 IN ('1','2','a');
```
IN リストの値の数は、max_allowed_packet 値によってのみ制限されます。
SQL の標準に準拠するため、IN は、左側の式が NULL である場合だけでなく、リストに一致するものがない場合、また、リストの式のひとつが NULL である場合にも、NULL を戻します。
IN() 構文は、ある種の副問い合わせを書くのにも使用できます。項12.2.8.3. 「ANY、IN、そして SOME を持つサブクエリ」を参照してください。
expr NOT IN (value,...)
これは、NOT (expr IN (value,...)) と同様です。
ISNULL(expr)
expr が NULL の場合、ISNULL() は 1 を戻し、それ以外では 0 を戻します。
```
mysql> SELECT ISNULL(1+1);
        -> 0
mysql> SELECT ISNULL(1/0);
        -> 1
```
= の代わりに、ISNULL() を使って、値が NULL であるかテストすることができます。( = で値を NULL と比較すると、常に false が生じます。)
ISNULL() 関数は IS NULL 比較演算子と、いくつかの特殊な動作を共有します。IS NULL の解説を参照してください。
INTERVAL(N,N1,N2,N3,...)
N < N1 の場合は 0 を、N < N2 の場合は 1 を戻す、というように続き、また N が NULL の場合は -1 を戻します。すべての引数は整数として扱われます。この関数の N1 < N2 < N3 < ... < Nn が正しく作動することは必須条件です。これは、バイナリ検索が使用されていることが理由です ( 高速 ) 。
```
mysql> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);
 -> 3
mysql> SELECT INTERVAL(10, 1, 10, 100, 1000);
 -> 2
mysql> SELECT INTERVAL(22, 23, 30, 44, 200);
 -> 0
```
LEAST(value1,value2,...)
引数ふたつ以上では、最小の ( 最小値の ) 引数を戻します。引数は次のルールを使用して比較されます :
- 戻り値が INTEGER 文脈で使用されている場合、またはすべての引数が整数値である場合、それらは整数として比較されます。
- 戻り値が REAL 文脈で使用されている場合、またはすべての引数が実数値である場合、それらは実数として比較されます。
- 引数のいずれかが大文字小文字の区別のあるストリングである場合、引数は大文字小文字の区別のあるストリングとして比較されます。
- 他のすべてのケースでは、引数は大文字小文字の区別のあるストリングとして比較されます。
引数のどれかが NULL である場合、LEAST() は NULL を戻します。
```
mysql> SELECT LEAST(2,0);
        -> 0
mysql> SELECT LEAST(34.0,3.0,5.0,767.0);
        -> 3.0
mysql> SELECT LEAST('B','A','C');
        -> 'A'
```
上記の変換ルールは、いくつかの境界例では異常な結果を引き起こす場合がありますのでご注意ください :
```
mysql> SELECT CAST(LEAST(3600, 9223372036854775808.0) as SIGNED);
        -> -9223372036854775808
```
これは、MySQL が 9223372036854775808.09223372036854775808.0 を整数の文脈で読み取ることが原因で起こります。整数表記は値を保持するのに十分ではないので、符号付整数にラップします。

11.1.4. 論理演算子

SQL では、すべての論理演算子は TRUE 、FALSE 、または NULL に評価されます ( UNKNOWN ) 。MySQL では、これらは 1 ( TRUE ) 、0 ( FALSE ) 、そして NULL として実行されます。サーバのあるものは TRUE にゼロ以外のすべての値を戻す場合があるものの、このほとんどは各種の SQL データベースサーバにとって通常のことです。

NOT, !
NOT 演算。オペランドが 0 の場合は 1 に、オペランドがゼロ以外の場合は 0 に評価し、そして NOT NULL は NULL を戻します。
```
mysql> SELECT NOT 10;
        -> 0
mysql> SELECT NOT 0;
        -> 1
mysql> SELECT NOT NULL;
        -> NULL
mysql> SELECT ! (1+1);
        -> 0
mysql> SELECT ! 1+1;
        -> 1
```
最後の例は、式の評価を (!1)+1 と同様に行うため、1 を生成します。

AND, &&

AND 演算。すべてオペランドがゼロ以外で非 NULL の場合は 1 に、ひとつ以上のオペランドが 0 の場合は 0 に評価し、それ以外は NULL を戻します。

mysql> SELECT 1 && 1;
        -> 1
mysql> SELECT 1 && 0;
        -> 0
mysql> SELECT 1 && NULL;
        -> NULL
mysql> SELECT 0 && NULL;
        -> 0
mysql> SELECT NULL && 0;
        -> 0

OR, ||
OR 演算。両方のオペランドが非 NULL である時、オペランドのどれかがゼロ以外である場合は結果は 1 、その他は 0 になります。ひとつが NULL オペランドであれば、他のオペランドがゼロ以外である場合の結果は 1 、その他は NULL になります。両方のオペランドが NULL であれば、結果は NULL になります。
```
mysql> SELECT 1 || 1;
        -> 1
mysql> SELECT 1 || 0;
        -> 1
mysql> SELECT 0 || 0;
        -> 0
mysql> SELECT 0 || NULL;
        -> NULL
mysql> SELECT 1 || NULL;
        -> 1
```
XOR
XOR 演算。オペランドのどちらかが NULL である場合は NULL を戻します。非 NULL のオペランドの場合は、ゼロ以外のオペランドの数が奇数であれば 1 に評価し、それ以外は 0 を戻します。
```
mysql> SELECT 1 XOR 1;
        -> 0
mysql> SELECT 1 XOR 0;
        -> 1
mysql> SELECT 1 XOR NULL;
        -> NULL
mysql> SELECT 1 XOR 1 XOR 1;
        -> 1
```
a XOR b は、数学的に (a AND (NOT b)) OR ((NOT a) and b) に等価です。

11.2. 制御フロー関数

CASE value WHEN [compare_value] THEN result [WHEN [compare_value] THEN result ...] [ELSE result] END
CASE WHEN [condition] THEN result [WHEN [condition] THEN result ...] [ELSE result] END
最初の例は、value=compare_value に result を戻します。２番目は true である最初の条件に結果を戻します。一致する結果値がない場合は、ELSE のあとの結果が戻され、ELSE パートがない場合は、NULL が戻されます。
```
mysql> SELECT CASE 1 WHEN 1 THEN 'one'
    ->     WHEN 2 THEN 'two' ELSE 'more' END;
        -> 'one'
mysql> SELECT CASE WHEN 1>0 THEN 'true' ELSE 'false' END;
        -> 'true'
mysql> SELECT CASE BINARY 'B'
    ->     WHEN 'a' THEN 1 WHEN 'b' THEN 2 END;
        -> NULL
```
CASE 式のデフォルトの戻り値タイプは、すべての戻り値の適合集合体タイプですが、使用される文脈にもよります。ストリング文脈で使用される場合は、結果はストリングとして戻されます。数値文脈で使用される場合は、結果は 10 進値、実数値、または整数値として戻されます。
注記 :ここで示されている CASE 式の構文は、ストアドルーチン内で使用する場合、項17.2.10.2. 「CASEステートメント」で説明されている、CASE 文とはやや異なります。CASE 文は ELSE NULL 句を持つことができず、END でなく、END CASE で終了します。

IF(expr1,expr2,expr3)

expr1 が TRUE である場合は ( expr1 <> 0 および expr1 <> NULL ) 、IF() は expr2 を戻します。それ以外では、expr3 を戻します。IF() は、使用されている文脈によって、数値値もしくはストリング値を戻します。

mysql> SELECT IF(1>2,2,3);
        -> 3
mysql> SELECT IF(1<2,'yes','no');
        -> 'yes'
mysql> SELECT IF(STRCMP('test','test1'),'no','yes');
        -> 'no'

expr2 または expr3 のうちのひとつが、明示的に NULL である場合は、IF() 関数の結果タイプは、非 NULL 式のタイプになります。

expr1 は整数値として評価されます。つまり、浮動小数点値、またはストリング値をテストしている場合は、比較演算を使用して行うべきということになります。

mysql> SELECT IF(0.1,1,0);
        -> 0
mysql> SELECT IF(0.1<>0,1,0);
        -> 1

ここの最初の例では、IF(0.1) は、IF(0) のテストの結果として 0.1 が整数値に変換されるため、0 を戻します。これは不測の結果であるかもしれません。2 番目の例では、比較テストは、オリジナルの浮動小数点値がゼロ以外であるかテストします。比較の結果は整数として使用されます。

デフォルトの IF() の戻り値タイプは ( 一時テーブルに保管される時に重要な場合あり ) 、次のように計算されます :

式	戻り値
`expr2` または `expr3` はストリングを戻す	ストリング
`expr2` または `expr3` は浮動小数点値を戻す	浮動小数点
`expr2` または `expr3` は整数を戻す	整数

expr2 と expr3 の両方がストリングで、どちらかのストリングが大文字小文字の区別をする場合、結果は大文字子目の区別があります。

注記 :IF 文もあり、それはここで説明されている IF() 関数とは異なります。項17.2.10.1. 「IF ステートメント」を参照してください。

IFNULL(expr1,expr2)
expr1 が NULL でない場合、IFNULL() は expr1 を戻し、それ以外では expr2 を戻します。IFNULL() は、使用されている文脈によって、数値値もしくはストリング値を戻します。
```
mysql> SELECT IFNULL(1,0);
        -> 1
mysql> SELECT IFNULL(NULL,10);
        -> 10
mysql> SELECT IFNULL(1/0,10);
        -> 10
mysql> SELECT IFNULL(1/0,'yes');
        -> 'yes'
```
IFNULL(expr1,expr2) のデフォルトの結果値は、STRING 、REAL 、または INTEGER の順に、ふたつの式のより「一般的」なものです。式や MySQL が一時テーブルの IFNULL() によって戻された値を内部に蓄積しなければいけない場所に基づくテーブルの大文字小文字を考慮してください :
```
mysql> CREATE TABLE tmp SELECT IFNULL(1,'test') AS test;
mysql> DESCRIBE tmp;
+-------+---------+------+-----+---------+-------+
| Field | Type    | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| test  | char(4) |      |     |         |       |
+-------+---------+------+-----+---------+-------+
```
この例では、test カラムのタイプは CHAR(4) です。
NULLIF(expr1,expr2)
expr1 = expr2 が true の場合は NULL を返し、それ以外は expr1 を返します。これは、CASE WHEN expr1 = expr2 THEN NULL ELSE expr1 END と同様です。
```
mysql> SELECT NULLIF(1,1);
        -> NULL
mysql> SELECT NULLIF(1,2);
        -> 1
```
MySQL は、引数が等しくない場合、expr1 を 2 度評価しますのでご注意ください。

11.3. 文字列関数

11.3.1. 文字列比較関数
11.3.2. 正規表現

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

ストリングの位置を演算する関数では、最初の位置は 1 と数値付けられます。

ASCII(str)
ストリング str の左側の文字の数値を戻します。str が空のストリングである場合は、0 を戻します。str が NULL である場合は NULL を戻します。ASCII() は、0 から 255 の数値を持つ文字に使用できます。
```
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 の長さを戻します。マルチバイト文字は、1 文字として数えられます。つまり、2 バイトの文字を 5 つ含むストリングには、CHAR_LENGTH() は 5 を戻すところを、LENGTH() は 10 を戻します。
CHARACTER_LENGTH(str)
CHARACTER_LENGTH() is a synonym for CHAR_LENGTH().
CONCAT(str1,str2,...)
引数を連結した結果であるストリングを戻します。ひとつ以上の引数を持つ場合があります。すべての引数が非バイナリストリングである場合、結果は非バイナリストリングになります。引数がひとつでもバイナリストリングを含む場合は、結果はバイナリストリングになります。数値の引数はそれに等しいバイナリストリング形態に変換されます。それを避けたい場合は、次の例のように、明示的なタイプキャストを使用することができます :
```
SELECT CONCAT(CAST(int_col AS CHAR), char_col);
```
引数のどれかが NULL である場合、CONCAT() は NULL を戻します。
```
mysql> SELECT CONCAT('My', 'S', 'QL');
        -> 'MySQL'
mysql> SELECT CONCAT('My', NULL, 'QL');
        -> NULL
mysql> SELECT CONCAT(14.3);
        -> '14.3'
```
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 値はすべてとばします。
CONV(N,from_base,to_base)
異なる基数間の数値を変換します。基数 rom_base から基数 to_base に変換された、数値 N の文字列表現を戻します。引数のどれかが NULL である場合は NULL を戻します。引数 N は整数として解釈されますが、整数またはストリングとして特定される場合があります。最小限の基数は 2 で、最大の基数は 36 です。to_base が負数である場合は、N は符号付き数として登録されます。それ以外では、N は符号なしとして扱われます。CONV() は 64 ビット精度で動作します。
```
mysql> SELECT CONV('a',16,2);
        -> '1010'
mysql> SELECT CONV('6E',18,8);
        -> '172'
mysql> SELECT CONV(-17,10,-18);
        -> '-H'
mysql> SELECT CONV(10+'10'+'10'+0xa,10,10);
        -> '40'
```
ELT(N,str1,str2,str3,...)
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 ) 。
```
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() へのすべての引数がストリングの場合、すべての引数はストリングとして比較されます。すべての引数が数値の場合、それらは数値として比較されます。それ以外は、引数は double として比較されます。
str が NULL である場合、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)
数字 X を '#,###,###.##' のようにフォーマットし、D 少数位まで丸め、その結果をストリングとして戻します。D が 0 の場合、結果は小数点または小数部を持ちません。
```
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'
```
HEX(N_or_S)
N_or_S が数字の場合、N の 16 進値の文字列表現を戻します。N は longlong ( BIGINT ) 数です。これは、CONV(N,10,16) に等価になります。
N_or_S がストリングの場合は、N_or_S の各文字が二桁の 16 進数に変換される、N_or_S の 16 進数字列表現を戻します。
```
mysql> SELECT HEX(255);
        -> 'FF'
mysql> SELECT 0x616263;
        -> 'abc'
mysql> SELECT HEX('abc');
        -> 616263
```
INSERT(str,pos,len,newstr)
ストリング str を、位置 pos で始まるサブストリングと、ストリング newstr に置換された len 文字長と共に戻します。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 の最初の発生の位置を戻します。これは、LOCATE() の引数がふたつのフォームの、引数の順番が逆になったものとと同じですが、
```
mysql> SELECT INSTR('foobarbar', 'bar');
        -> 4
mysql> SELECT INSTR('xbar', 'foobar');
        -> 0
```
この関数はマルチバイトでも安全で、少なくともひとつの引数がバイナリストリングである場合は、大文字小文字の区別が必須です。
LCASE(str)
LCASE() is a synonym for LOWER().
LEFT(str,len)
ストリング str からの左側の len 文字を戻し、引数が NULL である場合は NULL を戻します。
```
mysql> SELECT LEFT('foobarbar', 5);
        -> 'fooba'
```
LENGTH(str)
バイトで測られたストリング str の長さを戻します。マルチバイト文字は、複数バイトとして数えられます。つまり、2 バイトの文字を 5 つ含むストリングには、CHAR_LENGTH() は 5 を戻すところを、LENGTH() は 10 を戻します。
```
mysql> SELECT LENGTH('text');
        -> 4
```
LOAD_FILE(file_name)
ファイルを読み取り、その内容をストリングとして戻します。この関数を使用するには、ファイルがサーバホストに置かれていなければならないのと、ファイルへのフルパス名を特定し、FILE 権限を持つ必要があります。ファイルはあらゆる点で読取可能でなければならず、max_allowed_packet バイトより小さなサイズである必要があります。
ファイルが存在しない場合、または、上記の条件が満たされておらず、読取が不可能な場合、この関数は NULL を戻します。
MySQL 5.1.6 からは、character_set_filesystem システム環境変数が、リテラルストリングとして与えられたファイル名の解釈をコントロールします。
```
mysql> UPDATE t
            SET blob_col=LOAD_FILE('/tmp/picture')
            WHERE id=1;
```
LOCATE(substr,str), LOCATE(substr,str,pos)
最初の構文は、ストリング str 内のサブストリング substr の最初の発生の位置を戻します。2 番目の構文は、位置 pos で始まるストリング str 内のサブストリング substr の最初の発生の位置を戻します。str 内に substr がない場合は 0 を戻します。
```
mysql> SELECT LOCATE('bar', 'foobarbar');
        -> 4
mysql> SELECT LOCATE('xbar', 'foobar');
        -> 0
mysql> SELECT LOCATE('bar', 'foobarbar', 5);
        -> 7
```
この関数はマルチバイトでも安全で、少なくともひとつの引数がバイナリストリングである場合は、大文字小文字の区別が必須です。
LOWER(str)
現在の文字セットのマッピングに基づいてすべての文字が小文字に変更されたストリング str を戻します。デフォルトは latin1 ( cp1252 West European ) です。
```
mysql> SELECT LOWER('QUADRATICALLY');
        -> 'quadratically'
```
この関数はマルチバイトでも安全です。
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,100.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 × 256²) ...
```
左端の文字がマルチバイト文字でない場合は、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
```
REPEAT(str,count)
count 回繰り返されたストリング str で構成されるストリングを戻します。count が 1 より小さい場合は、空のストリングを戻します。str もしくは count が NULL である場合は NULL を戻します。
```
mysql> SELECT REPEAT('MySQL', 3);
        -> 'MySQLMySQLMySQL'
```
REPLACE(str,from_str,to_str)
ストリング to_str によって置換されたストリング from_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 ストリングを戻します。サウンドがほぼ同じなふたつのストリングは、同等の soundex ストリングを持っています。標準の soundex ストリングは長さ 4 文字ですが、SOUNDEX() 関数は任意の長さのストリングを戻します。標準の soundex ストリングを得るには、結果に SUBSTRING() を使用することができます。str 内のすべての非アルファベット文字は無視されます。A から Z 以外のすべての国際アルファベット文字は、母音として扱われます。
重要点 : SOUNDEX() を使用する場合は、次の制限に留意してください :
- 現在実装されているこの関数は、英語言語のみとの作動が意図されています。多言語でのストリングは、正確な結果を生成できない場合があります。
- この関数は、utf-8 を含むマルチバイト文字セットを使用するストリングでは、一貫性のある結果を提供する保証はありません。
  今後のリリースでは、これらの制限をなくせるよう努力しています。詳細は Bug#22638 をご覧ください。
```
mysql> SELECT SOUNDEX('Hello');
        -> 'H400'
mysql> SELECT SOUNDEX('Quadratically');
        -> 'Q36324'
```
注記 :この関数は、もっと一般的な拡張版ではなく、元来の Soundex アルゴリズムを実装しています。その相違点としては、元来のバージョンは最初に母音を破棄してから、複製を捨てますが、拡張版ではまず複製を破棄し、それから母音を捨てます。
expr1 SOUNDS LIKE expr2
これは、SOUNDEX(expr1) = SOUNDEX(expr2) と同様です。
SPACE(N)
N スペース文字で構成されるストリングを戻します。
```
mysql> SELECT SPACE(6);
        -> '      '
```
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 に使用することもできます。
```
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 以下の場合、結果は空のストリングになります。
SUBSTR() は SUBSTRING() のシノニムです。
SUBSTRING_INDEX(str,delim,count)
デリミッタ delim の count 発生前に、ストリング str を戻します。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'
```
この関数はマルチバイトでも安全です。
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)
HEX(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'. UNHEX() が引数内で非 16 進数に遭遇する場合は NULL を戻します :
```
mysql> SELECT UNHEX('GG');
+-------------+
| UNHEX('GG') |
+-------------+
| NULL        | 
+-------------+
```
NULL という結果は、UNHEX() への引数が BINARY カラムである場合、値が保存される時に 0x00 バイトでパッドされるために起こりますが、これらのバイトは検索でストリップされません。例えば、'aa' は 'aa?' として CHAR(3) カラムに保存され、'aa' ( トレーリングパッドスペースがストリップされた状態 ) として検索されます。それにより、カラム値の UNHEX() は A' を戻します。それに対し、'aa' は BINARY(3) カラムに 'aa\0' として保存され、'aa\0' ( トレーリングパッド 0x00 バイトがストリップされていない常態で ) として検索されます。'\0' は正当な 16 進数ではないので、カラム値の UNHEX() は NULL を戻します。
UPPER(str)
現在の文字セットのマッピングに基づいてすべての文字が大文字に変更されたストリング str を戻します。デフォルトは latin1 ( cp1252 West European ) です。
```
mysql> SELECT UPPER('Hej');
        -> 'HEJ'
```
この関数はマルチバイトでも安全です。

11.3.1. 文字列比較関数

文字列関数がバイナリストリングを引数として与えられている場合、結果ストリングもバイナリストリングとなります。ストリングに変換された数字は、バイナリストリングとして扱われます。これは比較にのみ影響を及ぼします。

通常、文字列比較の式に大文字小文字の区別のあるものがある場合、その比較は大文字小文字の区別のある様式で行われます。

expr LIKE pat [ESCAPE 'escape_char']
SQL の簡単な正規の比較式を使用してのパターンマッチング。1 ( TRUE ) または 0 ( FALSE ) を戻します。expr もしくは pat のどちらかが NULL である場合、結果は NULL になります。
パターンはリテラルストリングである必要があります。例えば、文字列式、またはテーブルカラムとして指定するのでもかまいません。
SQL 標準に当たり、LIKE は文字ごとにマッチングを行うので、= 比較演算子とは異なる結果を生成することができます。
```
mysql> SELECT 'a' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'a' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'a' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'a' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+
```
LIKE では、次のふたつのワイルドカード文字をパターンで使用することができます :
文字説明
% 0 からあらゆる数の文字でもマッチする。
_ ひとつの文字を明確にマッチする。
```
mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1
```
ワイルドカード文字のリテラルインスタンスをテストするには、エスケープ文字で優先させます。ESCAPE 文字を指定しない場合は、‘\’ が仮定されます。
ストリング 説明
\% ‘%’ 文字をひとつマッチする。
\_ ‘_’ 文字をひとつマッチする。
```
mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1
```
異なるエスケープ文字を指定するには、ESCAPE 句を使用します :
```
mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1
```
エスケープシーケンスは空か、1 文字長である必要があります。MySQL 5.1.2 からは、NO_BACKSLASH_ESCAPES SQL モードを有効にすると、シーケンスを空にすることはできません。
次のふたつのステートメントは、オペランドのひとつがバイナリストリングでない限り、文字列比較は大文字小文字の区別をしないことを示しています :
```
mysql> SELECT 'abc' LIKE 'ABC';
        -> 1
mysql> SELECT 'abc' LIKE BINARY 'ABC';
        -> 0
```
MySQL では、LIKE を数値式で使用することができます。( 標準の SQL LIKE のエクステンションです ) 。
```
mysql> SELECT 10 LIKE '1%';
        -> 1
```
注記 :MySQL は C エスケープ構文をストリングで使用するため ( 例えば、‘\n’ で改行文字を表現 ) 、LIKE ストリングで使用する ‘\’ はすべて二重にする必要があります。例えば、‘\n’ を検索するには、‘\\n’ と指定します。‘\’ の検索には、‘\\\\’ と指定します。これは、バックスラッシュがパーサによってストリップされ、そしてパターンのマッチが実行された時にもストリップされるため、ひとつのバックスラッシュを残してマッチさせるためです。( 例外 :パターンストリングの最後では、バックスラッシュは ‘\\’ と指定できます。ストリングの末尾では、エスケープの後に連なるものがないため、バックスラッシュはそのもので独立することができます ) 。
expr NOT LIKE pat [ESCAPE 'escape_char']
これは、NOT (expr LIKE pat [ESCAPE 'escape_char']) と同様です。
注意
NULL を含むカラムとの NOT LIKE 比較を伴う Aggregate クエリは、予想外の結果を生成します。例として、次の表とデータを参考にしてください :
```
CREATE TABLE foo (bar VARCHAR(10));

INSERT INTO foo VALUES (NULL), (NULL);
```
クエリ SELECT COUNT(*) FROM foo WHERE bar LIKE '%baz%'; は 0 を戻します。SELECT COUNT(*) FROM foo WHERE bar LIKE '%baz%'; は 2 を戻すと思われがちです。しかし、この場合は異なります : 2 番目のクエリは 0 を戻します。これは、NULL NOT LIKE expr が、expr の値に関わりなく、常に NULL を戻すためです。NULL を伴う aggregate クエリと、NOT RLIKE または NOT REGEXP を使用する比較でも同様です。このような場合、次のように、OR ( AND ではなく ) を使用して、NOT NULL を明示的にテストする必要があります :
```
SELECT COUNT(*) FROM foo WHERE bar NOT LIKE '%baz%' OR bar IS NULL;
```
expr NOT REGEXP pat, expr NOT RLIKE pat
これは、NOT (expr REGEXP pat) と同様です。
expr REGEXP pat, expr RLIKE pat
パターン pat に対して、ストリングの式 expr のパターン照合を行います。このパターンは拡張正規表現にもなりえます。正規表現の構文については、項11.3.2. 「正規表現」で説明されています。expr が pat と一致する場合は 1 を戻し、それ以外では 0 を戻します。expr もしくは pat のどちらかが NULL である場合、結果は NULL になります。RLIKE は、mSQL との互換性のために用意された、REGEXP のシノニムです。
パターンはリテラルストリングである必要があります。例えば、文字列式、またはテーブルカラムとして指定するのでもかまいません。
注記 :MySQL は C エスケープ構文をストリングで使用するため ( 例えば、‘\n’ で改行文字を表現 ) 、REGEXP ストリングで使用する ‘\’ はすべて二重にする必要があります。
REGEXP は、バイナリストリングと使用する場合以外では、大文字小文字の区別をしません。
```
mysql> SELECT 'Monty!' REGEXP 'm%y%%';
        -> 0
mysql> SELECT 'Monty!' REGEXP '.*';
        -> 1
mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
        -> 1
mysql> SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A';
        -> 1  0
mysql> SELECT 'a' REGEXP '^[a-d]';
        -> 1
```
REGEXP および RLIKE は、文字のタイプを決定する際に、現行の文字セットを使用します。デフォルトは latin1 ( cp1252 West European ) です。注意 : これらの演算子はマルチバイトでは安全ではありません。
STRCMP(expr1,expr2)
STRCMP() は、ストリングが同じであれば 0 を戻し、現行のソート順において最初の引数が 2 番目のものより小さい場合は -1 、そしてそれ以外では 1 を戻します。
```
mysql> SELECT STRCMP('text', 'text2');
        -> -1
mysql> SELECT STRCMP('text2', 'text');
        -> 1
mysql> SELECT STRCMP('text', 'text');
        -> 0
```
STRCMP() は、比較が行われる際、現行の文字セットを使用します。これによって、デフォルトの比較挙動では、ひとつか双方のオペランドがバイナリストリングでない限り、大文字小文字の区別がなくなります。

11.3.2. 正規表現

正規表現は、複雑な検索でパターンを特定する協力な方法です。

MySQL はヘンリー・スペンサーの正規表現の実装を使用します。これは、POSIX 1003.2. との適合性を目指したものです。付録?E. Credits をご覧ください。MySQL は、SQL 文での、REGEXP 演算子とのパターン照会演算をサポートするため、拡張バージョンを使用します。Pattern Matching および項11.3.1. 「文字列比較関数」を参照してください。

このセクションでは、MySQL で REGEXP 演算に使用される特殊な文字や構文の概要や例を記載します。ヘンリー・スペンサーの regex(7) マニュアルページにあるような詳細は網羅していません。このマニュアルページは MySQL のソース配布物の、regex ディレクトリ下の regex.7 ファイルに含まれています。

正規表現はストリングのセットを示します。最も簡単な正規表現は、特殊な文字を使用していないものです。例えば、正規表現 hello は hello のみにマッチします。

重要な正規表現は特定の特殊構文を使用し、ひとつ以上のストリングとマッチするようにします。例えば、正規表現 hello|word は、ストリング hello またはストリング word とマッチします。

さらに複雑な例としては、正規表現 B[an]*s は、ストリング Bananas 、Baaaaas 、Bs のいずれとでもマッチし、また、他の B で始まるストリング、s で終わるストリング、ひとつでも a または n 文字を間に含むストリングとも一致します。

REGEXP 演算子の正規表現は、次の特殊文字および構文のいずれかを使用する場合があります :

^

ストリングの頭にマッチ。

mysql> SELECT 'fo\nfo' REGEXP '^fo$';                   -> 0
mysql> SELECT 'fofo' REGEXP '^fo';                      -> 1

$

ストリングの最後にマッチ。

mysql> SELECT 'fo\no' REGEXP '^fo\no$';                 -> 1
mysql> SELECT 'fo\no' REGEXP '^fo$';                    -> 0

.

あらゆる文字とマッチ ( 改行復帰および通常改行を含む ) 。

mysql> SELECT 'fofo' REGEXP '^f.*$';                    -> 1
mysql> SELECT 'fo\r\nfo' REGEXP '^f.*$';                -> 1

a*

ゼロ以上の a 文字のあらゆるシークエンスにマッチ。

mysql> SELECT 'Ban' REGEXP '^Ba*n';                     -> 1
mysql> SELECT 'Baaan' REGEXP '^Ba*n';                   -> 1
mysql> SELECT 'Bn' REGEXP '^Ba*n';                      -> 1

a+

1 以上の a 文字のあらゆるシークエンスにマッチ。

mysql> SELECT 'Ban' REGEXP '^Ba+n';                     -> 1
mysql> SELECT 'Bn' REGEXP '^Ba+n';                      -> 0

a?

ゼロ、または 1 以上の a 文字とマッチ。

mysql> SELECT 'Bn' REGEXP '^Ba?n';                      -> 1
mysql> SELECT 'Ban' REGEXP '^Ba?n';                     -> 1
mysql> SELECT 'Baan' REGEXP '^Ba?n';                    -> 0

de|abc

シークエンス de または abc のどちらかをマッチ。

mysql> SELECT 'pi' REGEXP 'pi|apa';                     -> 1
mysql> SELECT 'axe' REGEXP 'pi|apa';                    -> 0
mysql> SELECT 'apa' REGEXP 'pi|apa';                    -> 1
mysql> SELECT 'apa' REGEXP '^(pi|apa)$';                -> 1
mysql> SELECT 'pi' REGEXP '^(pi|apa)$';                 -> 1
mysql> SELECT 'pix' REGEXP '^(pi|apa)$';                -> 0

(abc)*

シークエンス abc のゼロ以上のインスタンスをマッチ。

mysql> SELECT 'pi' REGEXP '^(pi)*$';                    -> 1
mysql> SELECT 'pip' REGEXP '^(pi)*$';                   -> 0
mysql> SELECT 'pipi' REGEXP '^(pi)*$';                  -> 1

{1}, {2,3}
{n} または {m,n} 表記は、パターンの前のアトム ( または「piece」 ) の発生の多くにマッチする正規表現の、より一般的な書き方を提供します。m および n は整数です。
- a*
  a{0,} として書くことができます.
- a+
  a{1,} として書くことができます.
- a?
  a{0,1} として書くことができます.
より正確を期するため、a{n} は a の n インスタンスに完全にマッチします。a{n,} は n か、a のより多くのインスタンスにマッチします。a{m,n} は a の n インスタンスを介して m に包括的にマッチします。
m および n は、0 から RE_DUP_MAX ( デフォルトは 255 ) の範囲に包括的に含まれなければなりません。m および n の両方が与えられてる場合は、m は、n と均等か、それより少なくなければなりません。
```
mysql> SELECT 'abcde' REGEXP 'a[bcd]{2}e';              -> 0
mysql> SELECT 'abcde' REGEXP 'a[bcd]{3}e';              -> 1
mysql> SELECT 'abcde' REGEXP 'a[bcd]{1,10}e';           -> 1
```
[a-dX], [^a-dX]
a 、b 、c 、d 、または X である ( ^ が使用されている場合はそれ以外の ) 文字とはすべてマッチします。ふたつの文字の間の - 文字は、最初の文字からふたつ目の文字までのすべての文字とマッチする範囲を形成します。例えば、[0-9] はすべての 10 進数とマッチします。リテラル ] 文字を含むには、左大括弧 [ のすぐ後に続ける必要があるます。リテラル - 文字を含むには、最初または最後に書き込んでください。[] 組の内側の、定義された特殊な意味を持たない文字はすべて、それ自体としかマッチしません。
```
mysql> SELECT 'aXbc' REGEXP '[a-dXYZ]';                 -> 1
mysql> SELECT 'aXbc' REGEXP '^[a-dXYZ]$';               -> 0
mysql> SELECT 'aXbc' REGEXP '^[a-dXYZ]+$';              -> 1
mysql> SELECT 'aXbc' REGEXP '^[^a-dXYZ]+$';             -> 0
mysql> SELECT 'gheis' REGEXP '^[^a-dXYZ]+$';            -> 1
mysql> SELECT 'gheisa' REGEXP '^[^a-dXYZ]+$';           -> 0
```
[.characters.]
括弧式 ( [ と ] で書かれたもの ) に囲まれた中で、照合要素である文字のシークエンスをマッチします。characters は単一の文字、または newline のような文字の名称です。文字の名称の完全なリストは、regexp/cname.h ファイルに含まれています。
```
mysql> SELECT '~' REGEXP '[[.~.]]';                     -> 1
mysql> SELECT '~' REGEXP '[[.tilde.]]';                 -> 1
```
[=character_class=]
括弧式 ( [ と ] で書かれたもの ) に囲まれた中で、[=character_class=] は等価クラスを表します。これは、それ自体を含む、同じ照合値を持つすべての文字にマッチします。例えば、o および (+) が等価クラスのメンバーである場合は、[[=o=]] 、[[=(+)=]] 、そして [o(+)] はすべて同義です。等価クラスを範囲の週末点として使用できない場合もあります。

[:character_class:]

括弧式 ( [ と ] で書かれたもの ) に囲まれた中で、[:character_class:] は、そのクラスに属するすべての文字とマッチする文字クラスを表します。次のテーブルは標準のクラス名のリストです。これらの名称は、ctype(3) マニュアルページで定義されている文字クラスを参照しています。特定のロケールが他のクラス名を提供する場合もあります。文字クラスを範囲の週末点として使用できないこともあります。

`alnum`	英数文字
`alpha`	アルファベット文字
`blank`	空白文字
`cntrl`	制御文字
`digit`	数字文字
`graph`	図形文字
`lower`	小文字アルファベット文字
`print`	図形またはスペース文字
`punct`	句読点文字
`space`	スペース、タブ、改行、および改行復帰
`upper`	大文字アルファベット文字
`xdigit`	16 進数文字

mysql> SELECT 'justalnums' REGEXP '[[:alnum:]]+';       -> 1
mysql> SELECT '!!' REGEXP '[[:alnum:]]+';               -> 0

[[:<:]], [[:>:]]
これらのマーカは語境界を参考にしています。これらは語の最初と最後それぞれにマッチします。単語とはその前後に別の単語文字が存在しない、単語文字のシーケンスと定義されています。単語文字とは、alnum クラス、またはアンダースコア ( _ ) での英数文字のことです。
```
mysql> SELECT 'a word a' REGEXP '[[:<:]]word[[:>:]]'; -> 1
mysql> SELECT 'a xword a' REGEXP '[[:<:]]word[[:>:]]'; -> 0
```

正規表現の特殊文字のリテラルインスタンスを使用するには、ふたつのバックスラッシュ ( \ ) 文字を頭につけます。MySQL パーサはふたつのバックスラッシュのうちのひとつを解釈し、正規表現ライブラリがもう一方を解釈します。例えば、特殊 + 文字を含むストリング 1+2 とマッチするには、以下の正規表現のうち、最後のものだけが正解になります :

mysql> SELECT '1+2' REGEXP '1+2';                       -> 0
mysql> SELECT '1+2' REGEXP '1\+2';                      -> 0
mysql> SELECT '1+2' REGEXP '1\\+2';                     -> 1

11.4. 数字関数

11.4.1. 算術演算子
11.4.2. 数学関数

11.4.1. 算術演算子

通常の算術演算子を利用することができます。結果の制度は次のルールに従って判断されます :

- 、+ 、および * の場合、両方の引数が整数であれば、結果はBIGINT ( 64 ビット ) の精度で計算されますのでご注意ください。
引数のひとつが符号のない整数であり、もう一方の引数も整数である場合は、結果は符号なしの整数になります。
+ 、- 、/ 、* 、% オペランドのいずれかが実数またはストリング値であれば、結果の精度は最大精度を持つ引数の精度になります。
乗算および除算では、ふたつの高精度値を使用する場合の結果の精度は、最初の引数の精度と、div_precision_increment グローバル変数の値を足したものになります。例えば、式 5.05 / 0.0014 は小数点以下 6 桁の精度 ( 3607.142857 ) を持ちます。

これらのルールは各演算に適用され、入れ子算は各コンポーネントの精度を示唆します。したがって、(14620 / 9432456) / (24250 / 9432456) はまず (0.0014) / (0.0026) に解析され、最終的に結果は小数点以下 8 桁 ( 0.57692308 ) になります。

これらの適用ルールと方法のため、計算のコンポーネントとサブコンポーネントが適切なレベルの精度を用いるよう注意してください。詳細は項11.8. 「キャスト関数と演算子」を参照してください。

+
加算 :
```
mysql> SELECT 3+5;
        -> 8
```
-
減算 :
```
mysql> SELECT 3-5;
        -> -2
```
-
単項マイナス。この演算子は引数の符号を変更します。
```
mysql> SELECT - 2;
        -> -2
```
注記 :この演算子が BIGINT と使用される場合は、戻り値も BIGINT になります。そのため、?2⁶³ の値を持つ可能性のある整数に ? を使用するのは避けてください。

*

乗算 :

mysql> SELECT 3*5;
        -> 15
mysql> SELECT 18014398509481984*18014398509481984.0;
        -> 324518553658426726783156020576256.0
mysql> SELECT 18014398509481984*18014398509481984;
        -> 0

整数の乗算の結果は BIGINT 計算の 64 ビット範囲を越えるため、最後の式の結果は正しくありません。( 項10.2. 「数値タイプ」参照 )

/
除算 :
```
mysql> SELECT 3/5;
        -> 0.60
```
ゼロによる除算は NULL の結果を生成します :
```
mysql> SELECT 102/(1-1);
        -> NULL
```
結果が整数に返還される状況下では、除算は BIGINT 算術でのみ計算されます。
DIV
整数除算。FLOOR() に類似していますが、BIGINT 値でも安全です。
```
mysql> SELECT 5 DIV 2;
        -> 2
```
N % M
モジュロ演算。M によって除算された N の余りを戻します。詳細は、項11.4.2. 「数学関数」の MOD() に関する説明をご覧ください。

11.4.2. 数学関数

すべての数学関数は、エラーのイベントで NULL を戻します。

ABS(X)
X の絶対値を戻します。
```
mysql> SELECT ABS(2);
        -> 2
mysql> SELECT ABS(-32);
        -> 32
```
この関数は、BIGINT 値とも安全に使用できます。
ACOS(X)
X のアークコサインを戻します。これは、コサインが X であるものの値です。X が -1 から 1 の範囲にない場合は NULL を戻します。
```
mysql> SELECT ACOS(1);
        -> 0
mysql> SELECT ACOS(1.0001);
        -> NULL
mysql> SELECT ACOS(0);
        -> 1.5707963267949
```

ASIN(X)

X のアークサインを戻します。これは、サインが X であるものの値です。X が -1 から 1 の範囲にない場合は NULL を戻します。

mysql> SELECT ASIN(0.2);
        -> 0.20135792079033
mysql> SELECT ASIN('foo');

+-------------+
| ASIN('foo') |
+-------------+
|           0 |
+-------------+
1 row in set, 1 warning (0.00 sec)

mysql> SHOW WARNINGS;
+---------+------+-----------------------------------------+
| Level   | Code | Message                                 |
+---------+------+-----------------------------------------+
| Warning | 1292 | Truncated incorrect DOUBLE value: 'foo' |
+---------+------+-----------------------------------------+

ATAN(X)
X のアークタンジェントを戻します。これは、タンジェントが X であるものの値です。
```
mysql> SELECT ATAN(2);
        -> 1.1071487177941
mysql> SELECT ATAN(-2);
        -> -1.1071487177941
```
ATAN(Y,X), ATAN2(Y,X)
ふたつの変数 X および Y のアークタンジェントを戻します。これは、両方の引数の符号が結果の象限の判定に使用される以外は、Y / X のアークタンジェントの計算に類似しています。
```
mysql> SELECT ATAN(-2,2);
        -> -0.78539816339745
mysql> SELECT ATAN2(PI(),0);
        -> 1.5707963267949
```
CEILING(X), CEIL(X)
X よりは大きな整数値のうち、最小のものを戻します。
```
mysql> SELECT CEILING(1.23);
        -> 2
mysql> SELECT CEIL(-1.23);
        -> -1
```
これらのふたつの関数は同義です。戻り値は BIGINT に変換されますのでご注意ください。
COS(X)
X のコサインを戻します。X はラジアンで与えられています。
```
mysql> SELECT COS(PI());
        -> -1
```

COT(X)

X のコタンジェントを戻します。

mysql> SELECT COT(12);
        -> -1.5726734063977
mysql> SELECT COT(0);
        -> NULL

CRC32(expr)
巡回符合検査値を算定し、32 ビットの符号のない値を戻します。引数が NULL である場合、結果は NULL になります。引数はストリングになると想定され、そしてストリングでない場合でも、 ( 可能であれば ) ストリングとして扱われます。
```
mysql> SELECT CRC32('MySQL');
        -> 3259397556
mysql> SELECT CRC32('mysql');
        -> 2501908538
```

DEGREES(X)

ラジアンからティグリーに変換された引数 X を戻します。

mysql> SELECT DEGREES(PI());
        -> 180
mysql> SELECT DEGREES(PI() / 2);
        -> 90

EXP(X)

e ( 自然対数の底 ) の X 乗の値を戻します。

mysql> SELECT EXP(2);
        -> 7.3890560989307
mysql> SELECT EXP(-2);
        -> 0.13533528323661
mysql> SELECT EXP(0);
        -> 1

FLOOR(X)
X よりは小さな整数値のうち、最大のものを戻します。
```
mysql> SELECT FLOOR(1.23);
        -> 1
mysql> SELECT FLOOR(-1.23);
        -> -2
```
戻り値は BIGINT に変換されますのでご注意ください。
FORMAT(X,D)
数字 X を '#,###,###.##' のようにフォーマットし、D 少数位まで丸め、その結果をストリングとして戻します。詳細は、項11.3. 「文字列関数」をご覧ください。
LN(X)
X の自然対数を戻します。これは、X の底 e の対数です。
```
mysql> SELECT LN(2);
        -> 0.69314718055995
mysql> SELECT LN(-2);
        -> NULL
```
この関数は LOG(X) と同義です。
LOG(X), LOG(B,X)
ひとつのパラメータで呼び出される場合、この関数は X の自然対数を戻します。
```
mysql> SELECT LOG(2);
        -> 0.69314718055995
mysql> SELECT LOG(-2);
        -> NULL
```
ふたつのパラメータで呼び出される場合、この関数は任意のベース B に対して X の自然対数を戻します。
```
mysql> SELECT LOG(2,65536);
        -> 16
mysql> SELECT LOG(10,100);
        -> 2
```
LOG(B,X) は LOG(X) / LOG(B) に等価です。
LOG2(X)
X のベース 2 の対数を戻します。
```
mysql> SELECT LOG2(65536);
        -> 16
mysql> SELECT LOG2(-100);
        -> NULL
```
LOG2() は、保存のために数字が何ビットを必要とするか調べるのに便利です。この関数は式 LOG(X) / LOG(2) と同義です。

LOG10(X)

X のベース 10 の対数を戻します。

mysql> SELECT LOG10(2);
        -> 0.30102999566398
mysql> SELECT LOG10(100);
        -> 2
mysql> SELECT LOG10(-100);
        -> NULL

LOG10(X) は LOG(10,X) と等価です。

MOD(N,M), N % M, N MOD M
モジュロ演算。M によって除算された N の余りを戻します。
```
mysql> SELECT MOD(234, 10);
        -> 4
mysql> SELECT 253 % 7;
        -> 1
mysql> SELECT MOD(29,9);
        -> 2
mysql> SELECT 29 MOD 9;
        -> 2
```
この関数は、BIGINT 値とも安全に使用できます。
MOD() はまた、小数部を持つ値にも利用でき、除算の後に正確な余りを戻します。
```
mysql> SELECT MOD(34.5,3);
        -> 1.5
```
MOD(N,0) は NULL を戻します。
PI()
π ( pi ) の値を戻します。表示されるデフォルトの少数点以下の桁数は 7 ですが、MySQL は内部的に全倍精度値を使用します。
```
mysql> SELECT PI();
        -> 3.141593
mysql> SELECT PI()+0.000000000000000000;
        -> 3.141592653589793116
```

POW(X,Y), POWER(X,Y)

X の Y 乗の値を戻します。

mysql> SELECT POW(2,2);
        -> 4
mysql> SELECT POW(2,-2);
        -> 0.25

RADIANS(X)
ディグリーからラジアンに変換された引数 X を戻します。( π ラジアンは 100 ディグリーと等価です ) 。
```
mysql> SELECT RADIANS(90);
        -> 1.5707963267949
```
RAND(), RAND(N)
0 <= v < 1.0 の範囲にあるランダムな浮動小数点値 v を戻します。定数整数引数 N が指定されている場合は、カラム値の反復可能なシークエンスを生成するシード値として使用されます。
```
mysql> SELECT RAND();
 -> 0.9233482386203
mysql> SELECT RAND(20);
 -> 0.15888261251047
mysql> SELECT RAND(20);
 -> 0.15888261251047
mysql> SELECT RAND();
 -> 0.63553050033332
mysql> SELECT RAND();
 -> 0.70100469486881
mysql> SELECT RAND(20);
 -> 0.15888261251047
```
定数イニシャライザを使用すれば、シードは実行の前の、ステートメントがコンパイルされる際に一度初期化されます。MySQL 5.1.16 からは、非定数イニシャライザ ( カラム名など ) が引数として使用される場合は、シードは RAND() の各呼び出しの値で初期化されます。( これは、等価の引数値に対しては、RAND() は毎回同じ値を戻すということを示しています ) 。MySQL 5.1.3 から 5.1.15 では、非定数引数は許可されていません。それ以前では、非定数引数の使用の効果は未定義になっています。
i <= R < j の範囲のランダムな整数 R を取得するには、式 FLOOR(i + RAND() * (j ? i) を使用します。例えば、7 <= R < 12 の範囲にあるランダムな整数を得るには、次のステートメントを使うことができます :
```
SELECT FLOOR(7 + (RAND() * 5));
```
ORDER BY はカラムを複数回評価するため、ORDER BY 句内で RAND() 値を持つカラムを使用することはできません。しかし、次のように行を順不同に摘出することは可能です :
```
mysql> SELECT * FROM tbl_name ORDER BY RAND();
```
LIMIT と結合された ORDER BY RAND() は、行のセットからランダムなサンプルを選ぶ場合に便利です :
```
mysql> SELECT * FROM table1, table2 WHERE a=b AND c<d -> ORDER BY RAND() LIMIT 1000;
```
WHERE 句内の RAND() は、WHERE が実行されるたびに再評価されますのでご注意ください。
RAND() は完璧なランダム発生器というわけではありませんが、同じ MySQL バージョンのプラットフォーム間においてポータブルな ad hoc ランダム数を生成する最も速い方法です。
ROUND(X), ROUND(X,D)
引数 X を D 小数点に丸めます。丸めアルゴリズムは X のデータタイプに基づきます。D は特別に指定されない限り、デフォルトにより 0 になります。D は時に負数で、値 X の小数点左側の D 桁がゼロになる原因になる場合があります。
```
mysql> SELECT ROUND(-1.23);
        -> -1
mysql> SELECT ROUND(-1.58);
        -> -2
mysql> SELECT ROUND(1.58);
        -> 2
mysql> SELECT ROUND(1.298, 1);
        -> 1.3
mysql> SELECT ROUND(1.298, 0);
        -> 1
mysql> SELECT ROUND(23.298, -1);
        -> 20
```
出力型は最初の引数 ( 整数、重複、または 10 進数と想定 ) と同じタイプです。つまり、整数引数では、結果は整数 ( 小数点なし ) になるということになります。
ROUND() は、最初の引数が 10 進値である時、高精度値引数に対して精度算数ライブラリを使用します :
- 高精度値数に対して、ROUND() は「四捨五入」ルールを行使します : .5 以上の小数部を持つ値は、正数である場合は次の整数に切り上げられ、負数である場合は切り下げられます。( つまりゼロから切り遠ざけられる ) 。0.5 未満の小数部を持つ値は、正数である場合は次の整数に切り下げられ、負数である場合は切り上げられます。
- 近似数値では、結果は C ライブラリによります。多くのシステムはで、これはつまり ROUND() は " 最も近い偶数に丸める " ルールを使用しているということになります : なんらかの小数部を持つ値は最も近い偶数の整数に丸められます。
次の例は高精度値と近似値で、丸め方がどう異なるかを示しています :
```
mysql> SELECT ROUND(2.5), ROUND(25E-1);
+------------+--------------+
| ROUND(2.5) | ROUND(25E-1) |
+------------+--------------+
| 3          |            2 |
+------------+--------------+
```
詳細は章?22. 精密計算 をご覧ください。

SIGN(X)

X が負数か、ゼロか、または正数かによって、引数の符号を -1 、0 、もしくは 1 として戻します。

mysql> SELECT SIGN(-32);
        -> -1
mysql> SELECT SIGN(0);
        -> 0
mysql> SELECT SIGN(234);
        -> 1

SIN(X)

X のサインを戻します。X はラジアンで与えられています。

mysql> SELECT SIN(PI());
        -> 1.2246063538224e-16
mysql> SELECT ROUND(SIN(PI()));
        -> 0

SQRT(X)

非負数 X の平方根を戻します。

mysql> SELECT SQRT(4);
        -> 2
mysql> SELECT SQRT(20);
        -> 4.4721359549996
mysql> SELECT SQRT(-16);
        -> NULL

TAN(X)

X のタンジェントを戻します。X はラジアンで与えられています。

mysql> SELECT TAN(PI());
        -> -1.2246063538224e-16
mysql> SELECT TAN(PI()+1);
        -> 1.5574077246549

TRUNCATE(X,D)

D 小数点を切り捨てて、数字 X を戻します。D が 0 の場合、結果は小数点または小数部を持ちません。D は時に負数で、値 X の小数点左側の D 桁がゼロになる原因になる場合があります。

mysql> SELECT TRUNCATE(1.223,1);
        -> 1.2
mysql> SELECT TRUNCATE(1.999,1);
        -> 1.9
mysql> SELECT TRUNCATE(1.999,0);
        -> 1
mysql> SELECT TRUNCATE(-1.999,1);
        -> -1.9
mysql> SELECT TRUNCATE(122,-2);
       -> 100
mysql> SELECT TRUNCATE(10.28*100,0);
       -> 1028

すべての数字はゼロに向かって丸められます。

11.5. 日付時刻関数

このセクションでは、時間値の処理に使用できる関数について説明します。各日付日時タイプが持つ値の範囲の説明と、値が指定されている場合の有効なフォーマットの説明は項10.3. 「日付と時刻タイプ」をご覧ください。

日付関数の使用例です。次のクエリはすべての行を、過去 30 日以内の date_col で選択します :

mysql> SELECT something FROM tbl_name
    -> WHERE DATE_SUB(CURDATE(),INTERVAL 30 DAY) <= date_col;

またこのクエリは、将来欺く日付で行を選択しますのでご注意ください。

日付値を受け入れる関数は通常、日付時刻値を受け入れ、時刻の部分を無視します。そして時刻値を受け入れる関数は通常、日付時刻値を受け入れ、日付の部分を無視します。

現在の日付または時刻をそれぞれ戻す関数は、クエリ実行の開始時点で、各クエリにつき一度だけ評価されます。つまり、単一クエリ内での、NOW() などの関数の複数の参照は、常に同じ結果を生成します ( 我々の目的に関しては、単一クエリはストアドルーチンまたはトリガ、およびそのルーチン / トリガによって呼び出されたサブルーチンへの呼び出しも含みます ) 。またこの法則は、CURDATE() 、CURTIME() 、UTC_DATE() 、UTC_TIME() 、UTC_TIMESTAMP() 、およびそれらのシノニムにも適合します。

CURRENT_TIMESTAMP() 、CURRENT_TIME() 、CURRENT_DATE() 、そして FROM_UNIXTIME() 関数は、time_zone 接続の現行時間帯での値を戻し、それらはシステム環境変数の値として利用できます。また、UNIX_TIMESTAMP() は、その引数が現行時間帯での日付時刻値であると想定します。詳細は項4.10.8. 「MySQL サーバのタイムゾーンサポート」を参照してください。

日付関数のあるものは、その他とは異なり、「zero」日付、または '2001-11-00' のような不完全な日付とも使用できます。日付の一部を摘出する関数は通常、不完全な日付でも問題ありません。例 :

mysql> SELECT DAYOFMONTH('2001-11-00'), MONTH('2005-00-00');
        -> 0, 0

他の関数は完全な日付を必要とし、日付が不完全な場合は NULL を戻します。これらには日付演算を行う関数、または日付の一部をマップし名前にする関数が含まれます。例 :

mysql> SELECT DATE_ADD('2006-05-00',INTERVAL 1 DAY);
        -> NULL
mysql> SELECT DAYNAME('2006-05-00');
        -> NULL

ADDDATE(date,INTERVAL expr unit), ADDDATE(expr,days)
2 番目の引数の INTERVAL フォームで呼び出される際、ADDDATE() は DATE_ADD() のシノニムになります。関連する関数 SUBDATE() は DATE_SUB() のシノニムです。INTERVAL unit 引数の詳細については、DATE_ADD() のディスカッションをご覧ください。
```
mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
        -> '1998-02-02'
mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
        -> '1998-02-02'
```
2 番目の引数の days フォームで呼び出される場合、MySQL はそれを expr に加えるために、整数の日数として扱います。
```
mysql> SELECT ADDDATE('1998-01-02', 31);
        -> '1998-02-02'
```

ADDTIME(expr1,expr2)

ADDTIME() は、expr2 を expr1 に加え、その結果を戻します。expr1 は時刻式、または日付時刻式で、expr2 は時刻式です。

mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999',
    ->                '1 1:1:1.000002');
        -> '1998-01-02 01:01:01.000001'
mysql> SELECT ADDTIME('01:00:00.999999', '02:00:00.999998');
        -> '03:00:01.999997'

CONVERT_TZ(dt,from_tz,to_tz)
CONVERT_TZ() は、日付時刻値 dt を、from_tz が指定する時間帯から、to_tz が指定する時間帯に変換し、結果の値を戻します。時間帯は、項4.10.8. 「MySQL サーバのタイムゾーンサポート」で説明されているように指定されています。引数が無効な場合、この関数は NULL を戻します。
値が、from_tz から UTC に変換される際に TIMESTAMP でサポートされている範囲から外れた場合、変換は行われません。TIMESTAMP の範囲は項10.1.2. 「データと時刻タイプの概要」に記載されています。
```
mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
        -> '2004-01-01 13:00:00'
mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
        -> '2004-01-01 22:00:00'
```
注記 :'MET' または 'Europe/Moscow' などの、名前付きの時間帯を使用するには、時間帯テーブルが正確に設定されている必要があります。手順については項4.10.8. 「MySQL サーバのタイムゾーンサポート」をご覧ください。
他のテーブルが LOCK TABLES でロックされている間に CONVERT_TZ() を使用したい場合は、mysql.time_zone_name テーブルもロックする必要があります。
CURDATE()
関数がストリングで使用されているか、もしくは数値コンテキストで使用されているかによって、現在の日付を 'YYYY-MM-DD' または YYYYMMDD フォーマットの値で戻します。
```
mysql> SELECT CURDATE();
        -> '1997-12-15'
mysql> SELECT CURDATE() + 0;
        -> 19971215
```
CURRENT_DATE, CURRENT_DATE()
CURRENT_DATE および CURRENT_DATE() は CURDATE() のシノニムです。
CURTIME()
関数がストリングで使用されているか、もしくは数値コンテキストで使用されているかによって、現在の時刻を 'HH:MM:SS' または HHMMSS フォーマットの値で戻します。値は現在の時間帯で表現されています。
```
mysql> SELECT CURTIME();
        -> '23:50:26'
mysql> SELECT CURTIME() + 0;
        -> 235026
```
CURRENT_TIME, CURRENT_TIME()
CURRENT_TIME および CURRENT_TIME() は CURTIME() のシノニムです。
CURRENT_TIMESTAMP, CURRENT_TIMESTAMP()
CURRENT_TIMESTAMP および CURRENT_TIMESTAMP() は NOW() のシノニムです。
DATE(expr)
日付、または日付時刻式 expr の日付部分を摘出します。
```
mysql> SELECT DATE('2003-12-31 01:02:03');
        -> '2003-12-31'
```
DATEDIFF(expr1,expr2)
DATEDIFF() は、ひとつの日付から他の日付への日数の値として表現された expr1 ? expr2 を戻します。expr1 および expr2 は日付または日付と時刻の表現です。値の日付部分のみが計算に使用されます。
```
mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
        -> 1
mysql> SELECT DATEDIFF('1997-11-30 23:59:59','1997-12-31');
        -> -31
```

DATE_ADD(date,INTERVAL expr unit), DATE_SUB(date,INTERVAL expr unit)

これらの関数は日付演算を行います。date は、開始日を指定する DATETIME または DATE 値です。 expr は開始日に追加、または開始日から引かれる区間値を指定する表現です。expr はストリングで、負のインターバルの場合は ‘-’ で始まることがあります。unit は、表現が解釈されるべきユニットを示すキーワードです。

INTERVAL キーワードおよび unit 指定子は、大文字小文字の区別をしません。

次の表は、各 unit 値に対して予想される expr 引数のフォームを示したものです。

`unit` 値	予想される `expr` フォーマット
`MICROSECOND`	`MICROSECONDS`
`SECOND`	`SECONDS`
`MINUTE`	`MINUTES`
`HOUR`	`HOURS`
`DAY`	`DAYS`
`WEEK`	`WEEKS`
`MONTH`	`MONTHS`
`QUARTER`	`QUARTERS`
`YEAR`	`YEARS`
`SECOND_MICROSECOND`	`'SECONDS.MICROSECONDS'`
`MINUTE_MICROSECOND`	`'MINUTES.MICROSECONDS'`
`MINUTE_SECOND`	`'MINUTES:SECONDS'`
`HOUR_MICROSECOND`	`'HOURS.MICROSECONDS'`
`HOUR_SECOND`	`'HOURS:MINUTES:SECONDS'`
`HOUR_MINUTE`	`'HOURS:MINUTES'`
`DAY_MICROSECOND`	`'DAYS.MICROSECONDS'`
`DAY_SECOND`	`'DAYS HOURS:MINUTES:SECONDS'`
`DAY_MINUTE`	`'DAYS HOURS:MINUTES'`
`DAY_HOUR`	`'DAYS HOURS'`
`YEAR_MONTH`	`'YEARS-MONTHS'`

MySQL は、expr フォーマットにおいてはいかなる句読区切り記号の使用も許容します。上記の表の区切り記号は提案にすぎません。date 引数が DATE 値であり、行う計算が YEAR 、MONTH 、および DAY 部のみ ( 時刻部分はなし ) を含む場合は、結果は DATE 値になります。他の場合は、結果は DATETIME 値になります。

また、日付演算は、INTERVAL を + または - 演算子と共に使用しても行うことができます :

date + INTERVAL expr unit
date - INTERVAL expr unit

INTERVAL expr unit は、一方の表現が日付か日付時刻値であれば、どちら側の + 演算子でも使用できます。- 演算子に関しては、INTERVAL expr unit は、インターバルから日付や日付日時値を摘出しても意味がないため、右側でのみ使用できます。

mysql> SELECT '1997-12-31 23:59:59' + INTERVAL 1 SECOND;
        -> '1998-01-01 00:00:00'
mysql> SELECT INTERVAL 1 DAY + '1997-12-31';
        -> '1998-01-01'
mysql> SELECT '1998-01-01' - INTERVAL 1 SECOND;
        -> '1997-12-31 23:59:59'
mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
    ->                 INTERVAL 1 SECOND);
        -> '1998-01-01 00:00:00'
mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
    ->                 INTERVAL 1 DAY);
        -> '1998-01-01 23:59:59'
mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
    ->                 INTERVAL '1:1' MINUTE_SECOND);
        -> '1998-01-01 00:01:00'
mysql> SELECT DATE_SUB('1998-01-01 00:00:00',
    ->                 INTERVAL '1 1:1:1' DAY_SECOND);
        -> '1997-12-30 22:58:59'
mysql> SELECT DATE_ADD('1998-01-01 00:00:00',
    ->                 INTERVAL '-1 10' DAY_HOUR);
        -> '1997-12-30 14:00:00'
mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
        -> '1997-12-02'
mysql> SELECT DATE_ADD('1992-12-31 23:59:59.000002',
    ->            INTERVAL '1.999999' SECOND_MICROSECOND);
        -> '1993-01-01 00:00:01.000001'

短すぎる区間値を指定した場合 ( unit キーワードから予想されるすべての区間部分は含みません ) 、MySQL は区間値の一番左の部分が放置されているものと想定します。例えば、DAY_SECOND の unit を指定した場合、expr の値は日にち、時間、分、秒の部分を持つものと想定されます。'1:10' のような値を指定すると、MySQL は日にちと時間の部分が抜けており、値は分と秒を示しているものと想定します。つまり、'1:10' DAY_SECOND は、'1:10' MINUTE_SECOND と同等に解釈されます。これは、MySQL が TIME 値を、時刻ではなく経過時間として解釈するやり方に相似しています。

時間部分を含むなにかを日付値に追加、または日付値から摘出する場合、結果は自動的に日付時刻値に変換されます :

mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 DAY);
        -> '1999-01-02'
mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);
        -> '1999-01-01 01:00:00'

MONTH 、YEAR_MONTH 、または YEAR を加え、結果の日付が新しい月の最大日数より大きな日を持つ場合、その日は新しい月の最大日数に調整されます。

mysql> SELECT DATE_ADD('1998-01-30', INTERVAL 1 MONTH);
        -> '1998-02-28'

日付算術演算には完全な日付が必須であり、'2006-07-00' のような不完全な日付や、誤った形の日付では正常に作動しません :

mysql> SELECT DATE_ADD('2006-07-00', INTERVAL 1 DAY);
        -> NULL
mysql> SELECT '2005-03-32' + INTERVAL 1 MONTH;
        -> NULL

DATE_FORMAT(date,format)

date 値を format ストリングに基づいてフォーマットします。

次の指定子は format ストリングで使用されていることもあります。‘%’ 文字は、書式指定子の前に必要なものです。

指定子	解説
`%a`	簡略曜日名 (`Sun`..`Sat`)
`%b`	簡略月名 (`Jan`..`Dec`)
`%c`	月、数字 (`0`..`12`)
`%D`	英語の接尾辞を持つ日にち (`0th`, `1st`, `2nd`, `3rd`, …)
`%d`	日にち、数字 (`00`..`31`)
`%e`	日にち、数字 (`0`..`31`)
`%f`	マイクロ秒 (`000000`..`999999`)
`%H`	時間 (`00`..`23`)
`%h`	時間 (`01`..`12`)
`%I`	時間 (`01`..`12`)
`%i`	分、数字 (`00`..`59`)
`%j`	通日 (`001`..`366`)
`%k`	時間 (`0`..`23`)
`%l`	時間 (`1`..`12`)
`%M`	月名 (`January`..`December`)
`%m`	月、数字 (`00`..`12`)
`%p`	`AM` または `PM`
`%r`	時間、12 時間単位 (`hh:mm:ss` に `AM` または `PM` が続く )
`%S`	秒 (`00`..`59`)
`%s`	秒 (`00`..`59`)
`%T`	時間、24 時間単位 (`hh:mm:ss`)
`%U`	週 (`00`..`53`) 、週の開始は日曜日
`%u`	週 (`00`..`53`)、週の開始は月曜日
`%V`	週 (`01`..`53`) 、週の開始は日曜日で、`%X` と使用
`%v`	週 (`01`..`53`) 、週の開始は月曜日で、`%x` と使用
`%W`	曜日名 (`Sunday`..`Saturday`)
`%w`	曜日 (`0`=Sunday..`6`=Saturday)
`%X`	年間の週、週の始まりは日曜日、週、数字、4 桁 ; `%V` と使用
`%x`	年間の週、週の始まりは月曜日、数字、4 桁、`%v` と使用
`%Y`	年、数字、4 桁
`%y`	年、数字 ( 2 桁 )
`%%`	リテラル ‘`%`’ 文字
`%x`	`x` 、上記にないすべての ‘`x`’

MySQL は '2004-00-00' のような不完全な日付の格納を許可するため、月と日にちの指定子の範囲は 0 から始まります。

MySQL 5.1.12 から、日にちおよび月の名称に使用される言語と、省略後は、lc_time_names システム環境変数 ( 項4.10.9. 「MySQL サーバのローケルサポート」 ) の値によって管理されます。

MySQL 5.1.15 からは、DATE_FORMAT() は文字セットを持つストリングと、character_set_connection および collation_connection によって提示された照合を戻し、非 ASCII 文字を含む月と曜日の名前を戻せるようになりました。5.1.15 の前は、戻り値はバイナリストリングでした。

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
        -> 'Saturday October 1997'
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%H:%i:%s');
        -> '22:23:00'
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',
                          '%D %y %a %d %m %b %j');
        -> '4th 97 Sat 04 10 Oct 277'
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',
                          '%H %k %I %r %T %S %w');
        -> '22 22 10 10:23:00 PM 22:23:00 00 6'
mysql> SELECT DATE_FORMAT('1999-01-01', '%X %V');
        -> '1998 52'
mysql> SELECT DATE_FORMAT('2006-06-00', '%d');
        -> '00'

DATE_SUB(date,INTERVAL expr unit)
DATE_ADD() 参照。
DAY(date)
DAY() は DAYOFMONTH( のシノニムです。
DAYNAME(date)
date に対して曜日の名前を戻します。MySQL 5.1.12 からは、名前に使用される言語は、lc_time_names システム環境変数 ( 項4.10.9. 「MySQL サーバのローケルサポート」 ) の値によって管理されます。
```
mysql> SELECT DAYNAME('1998-02-05');
        -> 'Thursday'
```
DAYOFMONTH(date)
0 から 31 の範囲内の日にちを、date に対して戻します。
```
mysql> SELECT DAYOFMONTH('1998-02-03');
        -> 3
```
DAYOFWEEK(date)
date ( 1 = Sunday 、2 = Monday 、… 、7 = Saturday ) に対する曜日のインデックスを戻します。これらのインデックス値は、ODBC 標準に対応しています。
```
mysql> SELECT DAYOFWEEK('1998-02-03');
        -> 3
```
DAYOFYEAR(date)
1 から 366 の範囲内の通日を、date に対して戻します。
```
mysql> SELECT DAYOFYEAR('1998-02-03');
        -> 34
```

EXTRACT(unit FROM date)

EXTRACT() 関数は、DATE_ADD() または DATE_SUB() と同様の装置指定子を使用しますが、データ演算を行うのではなく、データから一部を摘出します。

mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');
       -> 1999
mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');
       -> 199907
mysql> SELECT EXTRACT(DAY_MINUTE FROM '1999-07-02 01:02:03');
       -> 20102
mysql> SELECT EXTRACT(MICROSECOND
    ->                FROM '2003-01-02 10:30:00.000123');
        -> 123

FROM_DAYS(N)
日数 N を得て、DATE 値を戻します。
```
mysql> SELECT FROM_DAYS(729669);
        -> '1997-10-07'
```
FROM_DAYS() を古い日付で注意深く使用します。グレゴリオ暦 ( 1582 ) の出現を優先する値と共に使用することが目的ではありません。詳細は項11.6. 「MySQL が使用するカレンダーは ?」を参照してください。
FROM_UNIXTIME(unix_timestamp), FROM_UNIXTIME(unix_timestamp,format)
unix_timestamp 引数の表現を、関数がストリングで使用されたか、または数字のコンテキストで使用されたかによって、'YYYY-MM-DD HH:MM:SS' または YYYYMMDDHHMMSS のフォーマットで値として戻します。値は現在の時間帯で表現されます。unix_timestamp は、UNIX_TIMESTAMP() 関数によって生成されるような内部タイムスタンプ値です。
format が与えられていれば、DATE_FORMAT() 関数のエントリで挙げられているのと同じ方法で使用される format ストリングに基づいて、結果はフォーマットされます。
```
mysql> SELECT FROM_UNIXTIME(875996580);
        -> '1997-10-04 22:23:00'
mysql> SELECT FROM_UNIXTIME(875996580) + 0;
        -> 19971004222300
mysql> SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),
    ->                      '%Y %D %M %h:%i:%s %x');
        -> '2003 6th August 06:22:58 2003'
```
注記 :UNIX_TIMESTAMP() および FROM_UNIXTIME() を使って TIMESTAMP 値と Unix タイムスタンプ値間を変換する場合、マッピングは双方向に対して 1 対 1 ではないので、変換は高損失になります。詳細は UNIX_TIMESTAMP() 関数の説明をご覧ください。

GET_FORMAT(DATE|TIME|DATETIME, 'EUR'|'USA'|'JIS'|'ISO'|'INTERNAL')

フォーマットストリングを戻します。この関数は、DATE_FORMAT() と STR_TO_DATE() 関数の組み合わせで使用すると便利です。

1 番目と 2 番目の引数に対する有効な値は、複数の可能なフォーマットストリングで結果が生じます ( 使用される指定子については、DATE_FORMAT() 関数の説明にあるテーブルをご覧ください ) 。ISO フォーマットは ISO 8601 ではなく、ISO 9075 を参照しています。

関数呼び出し	結果
`GET_FORMAT(DATE,'USA')`	`'%m.%d.%Y'`
`GET_FORMAT(DATE,'JIS')`	`'%Y-%m-%d'`
`GET_FORMAT(DATE,'ISO')`	`'%Y-%m-%d'`
`GET_FORMAT(DATE,'EUR')`	`'%d.%m.%Y'`
`GET_FORMAT(DATE,'INTERNAL')`	`'%Y%m%d'`
`GET_FORMAT(DATETIME,'USA')`	`'%Y-%m-%d %H.%i.%s'`
`GET_FORMAT(DATETIME,'JIS')`	`'%Y-%m-%d %H:%i:%s'`
`GET_FORMAT(DATETIME,'ISO')`	`'%Y-%m-%d %H:%i:%s'`
`GET_FORMAT(DATETIME,'EUR')`	`'%Y-%m-%d %H.%i.%s'`
`GET_FORMAT(DATETIME,'INTERNAL')`	`'%Y%m%d%H%i%s'`
`GET_FORMAT(TIME,'USA')`	`'%h:%i:%s %p'`
`GET_FORMAT(TIME,'JIS')`	`'%H:%i:%s'`
`GET_FORMAT(TIME,'ISO')`	`'%H:%i:%s'`
`GET_FORMAT(TIME,'EUR')`	`'%H.%i.%s'`
`GET_FORMAT(TIME,'INTERNAL')`	`'%H%i%s'`

TIMESTAMP は、GET_FORMAT() への最初の引数としても使用でき、その場合、関数は DATETIME に対してと同じ値を戻します。

mysql> SELECT DATE_FORMAT('2003-10-03',GET_FORMAT(DATE,'EUR'));
        -> '03.10.2003'
mysql> SELECT STR_TO_DATE('10.31.2003',GET_FORMAT(DATE,'USA'));
        -> '2003-10-31'

HOUR(time)
time の正時 ( hour ) を戻します。戻り値の範囲は、時刻値の 0 から 23 です。ただし、TIME 値の範囲は実際にはもっと大きいため、HOUR は 23 以上の値を戻すことができます。
```
mysql> SELECT HOUR('10:05:03');
        -> 10
mysql> SELECT HOUR('272:59:59');
        -> 272
```

LAST_DAY(date)

日付または日付時刻を取り、月の最後の日の換算値を戻します。引数が無効である場合は NULL を戻します。

mysql> SELECT LAST_DAY('2003-02-05');
        -> '2003-02-28'
mysql> SELECT LAST_DAY('2004-02-05');
        -> '2004-02-29'
mysql> SELECT LAST_DAY('2004-01-01 01:01:01');
        -> '2004-01-31'
mysql> SELECT LAST_DAY('2003-03-32');
        -> NULL

LOCALTIME, LOCALTIME()
LOCALTIME および LOCALTIME() は NOW() のシノニムです。
LOCALTIMESTAMP, LOCALTIMESTAMP()
LOCALTIMESTAMP および LOCALTIMESTAMP() は NOW() のシノニムです。

MAKEDATE(year,dayofyear)

日付、提示された年、そして通日の値を戻します。dayofyear は 0 より大きくなければならず、さもなければ結果は NULL になります。

mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
        -> '2001-01-31', '2001-02-01'
mysql> SELECT MAKEDATE(2001,365), MAKEDATE(2004,365);
        -> '2001-12-31', '2004-12-30'
mysql> SELECT MAKEDATE(2001,0);
        -> NULL

MAKETIME(hour,minute,second)
hour 、minute 、および second 引数から計算された時間値を戻します。
```
mysql> SELECT MAKETIME(12,15,30);
        -> '12:15:30'
```

MICROSECOND(expr)

時間または日付時刻式 expr からのマイクロ秒を、0 から 999999 までの範囲の数値として戻します。

mysql> SELECT MICROSECOND('12:00:00.123456');
        -> 123456
mysql> SELECT MICROSECOND('1997-12-31 23:59:59.000010');
        -> 10

MINUTE(time)
0 から 59 の範囲内で、time の分数を戻します。
```
mysql> SELECT MINUTE('98-02-03 10:05:03');
        -> 5
```
MONTH(date)
0 から 12 の範囲内で、date の月を戻します。
```
mysql> SELECT MONTH('1998-02-03');
        -> 2
```
MONTHNAME(date)
date の月の完全名を戻します。MySQL 5.1.12 からは、名前に使用される言語は、lc_time_names システム環境変数 ( 項4.10.9. 「MySQL サーバのローケルサポート」 ) の値によって管理されます。
```
mysql> SELECT MONTHNAME('1998-02-05');
        -> 'February'
```

NOW()

関数がストリングで使用されているか、もしくは数値コンテキストで使用されているかによって、現在の日付を 'YYYY-MM-DD HH:MM:SS' または YYYYMMDDHHMMSS フォーマットの値で戻します。値は現在の時間帯で表現されています。

mysql> SELECT NOW();
        -> '1997-12-15 23:50:26'
mysql> SELECT NOW() + 0;
        -> 19971215235026

NOW() は、ステートメントが実行を開始する時間を示す定数時間を戻します。( ストアドルーチンまたはトリガ内で、NOW() はルーチンまたはトリガ文が実行を開始する時間を戻します。)これは、正確な実行時間を戻す SYSDATE() の動作によって異なります。

mysql> SELECT NOW(), SLEEP(2), NOW();
+---------------------+----------+---------------------+
| NOW()               | SLEEP(2) | NOW()               |
+---------------------+----------+---------------------+
| 2006-04-12 13:47:36 |        0 | 2006-04-12 13:47:36 |
+---------------------+----------+---------------------+

mysql> SELECT SYSDATE(), SLEEP(2), SYSDATE();
+---------------------+----------+---------------------+
| SYSDATE()           | SLEEP(2) | SYSDATE()           |
+---------------------+----------+---------------------+
| 2006-04-12 13:47:44 |        0 | 2006-04-12 13:47:46 |
+---------------------+----------+---------------------+

ふたつの関数の違いに関する詳細は、SYSDATE() の説明をご覧ください。

PERIOD_ADD(P,N)
N 月を、期間 P に加えます ( フォーマットは YYMM または YYYYMM ) 。フォーマット YYYYMM で値を戻します。期間引数 P は日付値ではありません のでご注意ください。
```
mysql> SELECT PERIOD_ADD(9801,2);
        -> 199803
```
PERIOD_DIFF(P1,P2)
期間 P1 と P2 間の月の数を戻します。P1 および P2 は、YYMM または YYYYMM のフォーマットになります。期間引数 P1 および P2 は日付値ではありませんのでご注意ください。
```
mysql> SELECT PERIOD_DIFF(9802,199703);
        -> 11
```
QUARTER(date)
date の四半期を 1 から 4 の範囲内で戻します。
```
mysql> SELECT QUARTER('98-04-01');
        -> 2
```
SECOND(time)
0 から 59 の範囲内で、time の秒数を戻します。
```
mysql> SELECT SECOND('10:05:03');
        -> 3
```
SEC_TO_TIME(seconds)
関数がストリングで使用されているか、もしくは数値コンテキストで使用されているかによって、正時、分、秒に変換された seconds 引数を、'HH:MM:SS' または HHMMSS のフォーマットの値で戻します。
```
mysql> SELECT SEC_TO_TIME(2378);
        -> '00:39:38'
mysql> SELECT SEC_TO_TIME(2378) + 0;
        -> 3938
```
STR_TO_DATE(str,format)
これは DATE_FORMAT() 関数の反転です。ストリング str とフォーマットストリング format を受取ります。STR_TO_DATE() は、フォーマットストリングが日付と時間の両方の部分を含む場合は DATETIME 値を戻し、ストリングが日付または時間の部分の一方のみを含む場合は DATE もしくは TIME 値を戻します。
str に含まれる日付、時刻、または日付時刻値は、format で示されるフォーマットで提供してください。format で使用できる指定子については、DATE_FORMAT() 関数の説明を参照してください。str が不当な日付、時刻、または日付時刻値を含む場合は、STR_TO_DATE() は NULL を戻します。また、不当な値は警告を生成します。
日付値の部分を確認する範囲は、項10.3.1. 「DATETIME、DATE、そして TIMESTAMP タイプ」で説明されている通りです。つまり、例えば、「zero」日付、または部分の値が 0 の日付は、SQL モードが特にそれらを禁止する設定になっていない限り、使用が許可されます。
```
mysql> SELECT STR_TO_DATE('00/00/0000', '%m/%d/%Y');
        -> '0000-00-00'
mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');
        -> '2004-04-31'
```
注記 :年と週のコンビネーションは、週が月の境界を越えた場合、年と月を一意的に識別できないため、フォーマット "%X%V" を使用して、年 - 週ストリングを日付に変換することはできません。年 - 週を日付に変換するには、曜日も同じく指定するべきです :
```
mysql> SELECT STR_TO_DATE('200442 Monday', '%X%V %W');
        -> '2004-10-18'
```
SUBDATE(date,INTERVAL expr unit), SUBDATE(expr,days)
2 番目の引数の INTERVAL フォームで呼び出される際、SUBDATE() は DATE_SUB() のシノニムになります。INTERVAL unit 引数の詳細については、DATE_ADD() のディスカッションをご覧ください。
```
mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
        -> '1997-12-02'
mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
        -> '1997-12-02'
```
2 番目のフォームは、days に整数値を使用することを許可します。そのような場合は、日付または日付時刻式 expr から日数が減算されると解釈されます。
```
mysql> SELECT SUBDATE('1998-01-02 12:00:00', 31);
        -> '1997-12-02 12:00:00'
```

SUBTIME(expr1,expr2)

SUBTIME() は、expr1 と同じフォーマットで値として表現された expr1 ? expr2 を戻します。expr1 は時刻または日付時刻式であり、expr2 時刻表現です。

mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');
        -> '1997-12-30 22:58:58.999997'
mysql> SELECT SUBTIME('01:00:00.999999', '02:00:00.999998');
        -> '-00:59:59.999999'

SYSDATE()
関数がストリングで使用されているか、もしくは数値コンテキストで使用されているかによって、現在の日付を 'YYYY-MM-DD HH:MM:SS' または YYYYMMDDHHMMSS フォーマットの値で戻します。
SYSDATE() は、それが実行された時間を戻します。これは NOW() の動作によって異なり、ステートメントが実行を開始する時間を示す定数時間を戻します。( ストアドルーチンまたはトリガ内で、NOW() はルーチンまたはトリガ文が実行を開始する時間を戻します。)
```
mysql> SELECT NOW(), SLEEP(2), NOW();
+---------------------+----------+---------------------+
| NOW()               | SLEEP(2) | NOW()               |
+---------------------+----------+---------------------+
| 2006-04-12 13:47:36 |        0 | 2006-04-12 13:47:36 |
+---------------------+----------+---------------------+

mysql> SELECT SYSDATE(), SLEEP(2), SYSDATE();
+---------------------+----------+---------------------+
| SYSDATE()           | SLEEP(2) | SYSDATE()           |
+---------------------+----------+---------------------+
| 2006-04-12 13:47:44 |        0 | 2006-04-12 13:47:46 |
+---------------------+----------+---------------------+
```
そのほか、 SET TIMESTAMP 文は NOW() によって戻された値に影響を及ぼしますが、SYSDATE() によって戻された値には影響しません。つまり、バイナリログのタイムスタンプ設定は、SYSDATE() の呼び出しには効果をもたらさないということになります。
SYSDATE() は同じステートメントの中でも、異なる値を戻すことができ、また SET TIMESTAMP に影響を受けないため、これは非決定性であり、従ってステートメントに基づくバイナリロギングが使用されている場合、複製は安全でないということになります。これが問題になる場合は、行ベースのロギングを使用するか、または --sysdate-is-now オプションでサーバを起動して、SYSDATE() が NOW() のエイリアスになるようにしてください。

TIME(expr)

時刻、または日付時刻式 expr の時刻部分を摘出し、ストリングとして戻します。

mysql> SELECT TIME('2003-12-31 01:02:03');
        -> '01:02:03'
mysql> SELECT TIME('2003-12-31 01:02:03.000123');
        -> '01:02:03.000123'

TIMEDIFF(expr1,expr2)

TIMEDIFF() は時刻値として表現された expr1 ? expr2 を戻します。expr1 および expr2 は時刻、または日付時刻式ですが、双方とも同じタイプであることが重要です。

mysql> SELECT TIMEDIFF('2000:01:01 00:00:00',
    ->                 '2000:01:01 00:00:00.000001');
        -> '-00:00:00.000001'
mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',
    ->                 '1997-12-30 01:01:01.000002');
        -> '46:58:57.999999'

TIMESTAMP(expr), TIMESTAMP(expr1,expr2)
単一引数では、この関数は日付または日付時刻式 expr を日付時刻値として戻します。ふたつの引数では、時刻式 expr2 を日付、または日付時刻式 expr1 に加え、結果を日付時刻値として戻します。
```
mysql> SELECT TIMESTAMP('2003-12-31');
        -> '2003-12-31 00:00:00'
mysql> SELECT TIMESTAMP('2003-12-31 12:00:00','12:00:00');
        -> '2004-01-01 00:00:00'
```
TIMESTAMPADD(unit,interval,datetime_expr)
整数式 interval を、日付または日付時刻式 datetime_expr に加えます。interval のユニットは、次の値のひとつである unit 引数によって提示されます : FRAC_SECOND 、SECOND 、MINUTE 、HOUR 、DAY 、WEEK 、MONTH 、QUARTER 、または YEAR 。
unit 値は、記載されているキーワードのどれかを使用するか、または SQL_TSI_ のプリフィックスでの指定が可能です。例えば、DAY と SQL_TSI_DAY は両方とも正当です。
```
mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
        -> '2003-01-02 00:01:00'
mysql> SELECT TIMESTAMPADD(WEEK,1,'2003-01-02');
        -> '2003-01-09'
```
TIMESTAMPDIFF(unit,datetime_expr1,datetime_expr2)
日付または日付時刻式 datetime_expr1 および datetime_expr2 間の整数の差を戻します。結果のユニットは、unit 引数によって提示されます。unit の正当な値は、TIMESTAMPADD() 関数の説明で挙げられているものと同じです。
```
mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
        -> 3
mysql> SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01');
        -> -1
```
TIME_FORMAT(time,format)
これは DATE_FORMAT() 関数のように使用されますが、format ストリングは時間、分、秒のみのための書式指定子を含む場合があります。他の指定子は NULL 値か 0 を生成します。
time 値が 23 より大きな時間部を含む場合、%H および %k 時間書式指定子が 0..23 の通常の範囲より大きな値を生成します。他の時間書式指定子は、時間値モジュロ 12 を作成します。
```
mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
        -> '100 100 04 04 4'
```

TIME_TO_SEC(time)

秒に変換された time 引数を戻します。

mysql> SELECT TIME_TO_SEC('22:23:00');
        -> 80580
mysql> SELECT TIME_TO_SEC('00:39:38');
        -> 2378

TO_DAYS(date)
日付 date をもって、日数 ( 0 年からの日数 ) を戻します。
```
mysql> SELECT TO_DAYS(950501);
        -> 728779
mysql> SELECT TO_DAYS('1997-10-07');
        -> 729669
```
TO_DAYS() は、カレンダーが変更された際に失われた日を考慮しないので、グレゴリオ暦 ( 1582 ) の出現を優先される値と使用する目的はありません。1582　より前の日付 ( または他のロケールでの後の年 ) に関しては、この関数からの結果は信頼できません。詳細は項11.6. 「MySQL が使用するカレンダーは ?」をご覧ください。
MySQL は項10.3. 「日付と時刻タイプ」のルールを使用して、日付の 2 桁の年の値を 4 桁のフォームに変換することに留意してください。例えば、'1997-10-07' と '97-10-07' は同一の日付と考えられます :
```
mysql> SELECT TO_DAYS('1997-10-07'), TO_DAYS('97-10-07');
        -> 729669, 729669
```
UNIX_TIMESTAMP(), UNIX_TIMESTAMP(date)
引数なしで呼び出された場合、Unix タイムスタンプ ( '1970-01-01 00:00:00' UTC 以来の秒数 ) を符号なしの整数として戻します。UNIX_TIMESTAMP() が date 引数で呼び出された場合は、'1970-01-01 00:00:00' UTC 以後の秒として引数の値が戻されます。date は、DATE ストリング、DATETIME ストリング、TIMESTAMP 、またはフォーマット YYMMDD もしくは YYYYMMDD 内のナンバーである場合があります。サーバは date を現在の時間帯の値として解釈し、UTC の内部値に変換します。クライアントは、項4.10.8. 「MySQL サーバのタイムゾーンサポート」で説明されているように、独自の時間帯を設定することができます。
```
mysql> SELECT UNIX_TIMESTAMP();
        -> 882226357
mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
        -> 875996580
```
UNIX_TIMESTAMP が TIMESTAMP カラムに使用される際、関数は明示的な「string-to-Unix-timestamp」の変換なしに、内部タイムスタンプ値を直接戻します。UNIX_TIMESTAMP() に範囲外の日付を渡すと、0 が戻されます。
注記 :UNIX_TIMESTAMP() および FROM_UNIXTIME() を使って TIMESTAMP 値と Unix タイムスタンプ値間を変換する場合、マッピングは双方向に対して 1 対 1 ではないので、変換は高損失になります。例えば、現地時間帯の変更に対する変換のため、ふたつの UNIX_TIMESTAMP() がふたつの TIMESTAMP 値を、同じ Unix タイムスタンプ値にマップすることが考えられます。FROM_UNIXTIME() はその値を、本来の TIMESTAMP 値のひとつのみにマップをして返します。次が CET 時間帯で TIMESTAMP 値を使用した例です :
```
mysql> SELECT UNIX_TIMESTAMP('2005-03-27 03:00:00');
+---------------------------------------+
| UNIX_TIMESTAMP('2005-03-27 03:00:00') |
+---------------------------------------+
|                            1111885200 |
+---------------------------------------+
mysql> SELECT UNIX_TIMESTAMP('2005-03-27 02:00:00');
+---------------------------------------+
| UNIX_TIMESTAMP('2005-03-27 02:00:00') |
+---------------------------------------+
|                            1111885200 |
+---------------------------------------+
mysql> SELECT FROM_UNIXTIME(1111885200);
+---------------------------+
| FROM_UNIXTIME(1111885200) |
+---------------------------+
| 2005-03-27 03:00:00       |
+---------------------------+
```
UNIX_TIMESTAMP() カラムを減算するには、結果を符号付きの整数にキャストする方法もあります。詳細は項11.8. 「キャスト関数と演算子」を参照してください。
UTC_DATE, UTC_DATE()
関数がストリングで使用されているか、もしくは数値コンテキストで使用されているかによって、現在の UTC 日付を 'YYYY-MM-DD' または YYYYMMDD フォーマットの値で戻します。
```
mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
        -> '2003-08-14', 20030814
```
UTC_TIME, UTC_TIME()
関数がストリングで使用されているか、もしくは数値コンテキストで使用されているかによって、現在の UTC 時刻を 'HH:MM:SS' または HHMMSS フォーマットの値で戻します。
```
mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
        -> '18:07:53', 180753
```
UTC_TIMESTAMP, UTC_TIMESTAMP()
関数がストリングで使用されているか、もしくは数値コンテキストで使用されているかによって、現在の UTC 日付を 'YYYY-MM-DD HH:MM:SS' または YYYYMMDDHHMMSS フォーマットの値で戻します。
```
mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
        -> '2003-08-14 18:08:04', 20030814180804
```

WEEK(date[,mode])

この関数は date に週の数を戻します。WEEK() の、引数がふたつのフォームによって、週が日曜で始まるか、月曜で始まるか、また、戻り値の範囲は 0 から 53 か、1 から 53 かを指定することが可能です。mode 引数が省略された場合は、default_week_format システム環境変数の値が使用されます。詳細は項4.2.3. 「システム変数」を参照してください。

次のテーブルは、mode 引数がどのように作用するかを示したものです。

?	開始日	?	?
モード	曜日	範囲	Week 1 は下記の最初の週…
0	日曜日	0-53	この年の日曜日
1	月曜日	0-53	この年は 3 日以上
2	日曜日	1-53	この年は日曜日
3	月曜日	1-53	この年は 3 日以上
4	日曜日	0-53	この年は 3 日以上
5	月曜日	0-53	この年は月曜日
6	日曜日	1-53	この年は 3 日以上
7	月曜日	1-53	この年は月曜日

mysql> SELECT WEEK('1998-02-20');
        -> 7
mysql> SELECT WEEK('1998-02-20',0);
        -> 7
mysql> SELECT WEEK('1998-02-20',1);
        -> 8
mysql> SELECT WEEK('1998-12-31',1);
        -> 53

日付が先年の最後の週に該当する場合、2 、3 、6 、または 7 をオプションの mode 引数として使用しなければ、MySQL は 0 を戻すので注意してください :

mysql> SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0);
        -> 2000, 0

与えられた日付が 1999 年の 52 週目に発生するため、MySQL は WEEK() 関数に 52 を戻すべきだという意見もあります。しかし当社では、関数が「与えらた年の週の」を戻すべきだと考え、0 を戻しています。これにより、日付から日にち部分を摘出する他の関数と併用する際に、WEEK() 関数をより信頼して使用できるようになっています。

結果において、与えられた日付の週の最初の日を含む年の評価をしたい場合は、0 、2 、5 、または 7 を、オプションの mode 引数として使用してください。

mysql> SELECT WEEK('2000-01-01',2);
        -> 52

その替わりとして、YEARWEEK() 関数を使用することもできます :

mysql> SELECT YEARWEEK('2000-01-01');
        -> 199952
mysql> SELECT MID(YEARWEEK('2000-01-01'),5,2);
        -> '52'

WEEKDAY(date)
date ( 0 = Monday 、1 = Tuesday 、… 、… 6 = Sunday ) の曜日のインデックスを戻します。
```
mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
        -> 1
mysql> SELECT WEEKDAY('1997-11-05');
        -> 2
```
WEEKOFYEAR(date)
1 から 53 の範囲で、日付の暦週を返します。WEEKOFYEAR() は WEEK(date,3) に等価な互換性の関数です。
```
mysql> SELECT WEEKOFYEAR('1998-02-20');
        -> 8
```
YEAR(date)
0 から 9999 の範囲、または「zero」日付には 0 で、date の年を戻します。
```
mysql> SELECT YEAR('98-02-03');
        -> 1998
```
YEARWEEK(date), YEARWEEK(date,mode)
日付の年と週を戻します。mode 引数は、WEEK() への mode 引数とまったく同様に作用します。結果の年は、日付引数の年によって、年の最初の週と、最後の週で異なる場合があります。
```
mysql> SELECT YEARWEEK('1987-01-01');
        -> 198653
```
週の数は、WEEK() が提示された年のコンテキストの週を戻す場合、WEEK() 関数がオプションの引数 0 または 1 に戻すもの ( 0 ) よって異なります。

11.6. MySQL が使用するカレンダーは ?

MySQL は、proleptic Gregorian calendar として知られる暦を使用しています。

ユリウス暦からグレゴリオ暦に改めたすべての国では、その変移の際に少なくとも 10 日の日数を減らさなければなりませんでした。この仕組みを理解するには、初めてユリウス暦からグレゴリオ暦への変更が行われた1582 年の 10 月を考慮に入れてください :

月曜日	火曜日	水曜日	木曜日	金曜日	土曜日	日曜日
1	2	3	4	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30	31

10 月 4 日から 10 月 15 日の間には日付がありません。この不連続性を カットオーバ と呼びます。カットオーバの前がユリウス暦で、カットオーバに続く日付はすべてグレゴリオ暦です。カットオーバの途中の日付は存在しません。

まだ実際には使用されていなかった間のカレンダーは proleptic と呼ばれています。従って、最初から常にグレゴリオ暦が使用されており、カットオーバが起こることもなかったと仮定した暦が proleptic Gregorian calendar ということになります。これが MySQL の使用する暦であり、標準 SQL の必須となっています。このため、MySQL DATE または DATETIME 値として格納されたカットオーバ前の日付は、その違いを補正する調整が必要です。カットオーバが起こった時期が国によって異なるのも重要な点で、その時期が後であるほど、失われる日数は多いことになります。例えば、イギリスでは 1752 年にカットオーバが起こり、9 月 2 日の水曜日の翌日が、9 月 14 日の木曜日でした。ロシアは 1918 年までユリウス暦を使用し、変更の際に 13 日を失いました。世に言う「十月革命」は、グレゴリオ暦では 11 月に起こったものです。

11.7. 全文検索関数

11.7.1. ブール全文検索
11.7.2. クエリ拡張を伴う全文検索
11.7.3. 全文ストップワード
11.7.4. 全文制限
11.7.5. 微調整 MySQL 全文検索

MATCH (col1,col2,...) AGAINST (expr [search_modifier])

search_modifier:
  {
       IN BOOLEAN MODE
     | IN NATURAL LANGUAGE MODE
     | IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION
     | WITH QUERY EXPANSION
  }

MySQL は全文インデックスおよび検索をサポートします :

MySQL の全文インデックスは、タイプ FULLTEXT のインデックスです。
全文インデックスは MyISAM テーブルとのみ使用されており、CHAR 、VARCHAR 、または TEXT カラムのためにだけ作成されます。
FULLTEXT インデックスの定義は、テーブルを作成する時に、CREATE TABLE 文で提示することができるほか、ALTER TABLE または CREATE INDEX を使用して後で付け加えることも可能です。
大きなデータセットに関しては、FULLTEXT インデックスを持たないテーブルにロードし、その後でインデックスを作成するほうが、すでに FULLTEXT インデックスを持つテーブルにロードするよりも断然速く読み込めます。

全文検索は MATCH() ... AGAINST シンタックスを用いて行われます。MATCH() は、検索用にカラムに名称をつける、カンマで区切られたリストを使用します。AGAINST は検索するストリングと、実行する検索のタイプを示すオプションの修飾子を利用します。検索ストリングは、変数やカラム名ではなく、リテラルストリングでなければなりません。全文検索には３種類あります :

ブール検索は、特別なクエリ言語のルールを使用した検索ストリングを解釈します。ストリングは検索の対象になる言葉を含みます。また、単語は整合行で提示または不提示にされなければならない、もしくは、通常より高く、または低く加重するべき、等の条件を指定する演算子も含むことができます。「some」や「then」のような一般的な単語はストップワードで、検索ストリングにあってもマッチしません。IN BOOLEAN MODE 修飾子はブール検索を特定します。詳細は項11.7.1. 「ブール全文検索」をご覧ください。
自然言語の検索は、検索ストリングを人間の自然な言語でのフレーズ ( フリーテキストのフレーズ ) として解釈します。これには特別な演算子はありません。ストップワードリストは適用されます。また、行の 50% 以上にある言葉は常用語と判断され、検出はされません。全文検索は、IN NATURAL LANGUAGE MODE 修飾子が与えられている、または修飾子がまったくない場合は、自然言語検索になります。
クエリ拡張検索は、自然言語検索が改変されたものです。自然言語検索を行うには、検索ストリングが使用されます。そして、検索によって返された最も関連性の強い行からの言葉が検索ストリングに加えられ、再度検索されます。クエリは 2 度目の検索からの行を戻します。IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION または WITH QUERY EXPANSION 修飾子は、クエリ拡張検索を特定します。詳細は項11.7.2. 「クエリ拡張を伴う全文検索」をご覧ください。

IN NATURAL LANGUAGE MODE および IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION 修飾子は、MySQL 5.1.7 から追加されました。

全文検索の制約は、項11.7.4. 「全文制限」に挙げられています。

mysql> CREATE TABLE articles (
    ->   id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,
    ->   title VARCHAR(200),
    ->   body TEXT,
    ->   FULLTEXT (title,body)
    -> );
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO articles (title,body) VALUES
    -> ('MySQL Tutorial','DBMS stands for DataBase ...'),
    -> ('How To Use MySQL Well','After you went through a ...'),
    -> ('Optimizing MySQL','In this tutorial we will show ...'),
    -> ('1001 MySQL Tricks','1. Never run mysqld as root. 2. ...'),
    -> ('MySQL vs. YourSQL','In the following database comparison ...'),
    -> ('MySQL Security','When configured properly, MySQL ...');
Query OK, 6 rows affected (0.00 sec)
Records: 6  Duplicates: 0  Warnings: 0

mysql> SELECT * FROM articles
    -> WHERE MATCH (title,body)
    -> AGAINST ('database' IN NATURAL LANGUAGE MODE);
+----+-------------------+------------------------------------------+
| id | title             | body                                     |
+----+-------------------+------------------------------------------+
|  5 | MySQL vs. YourSQL | In the following database comparison ... |
|  1 | MySQL Tutorial    | DBMS stands for DataBase ...             |
+----+-------------------+------------------------------------------+
2 rows in set (0.00 sec)

MATCH() 関数は、テキストコレクション に対するストリングを自然言語検索します。コレクションは、FULLTEXT インデックスを含む、ひとつ以上のカラムのセットです。検索ストリングは、AGAINST() への引数として与えられます。テーブルの各行に対し、検索ストリングと、MATCH() リストで名付けられたカラムの行内のテキスト間の類似性を測り、MATCH() が関連性のある値を戻します。

デフォルトでは、検索は大文字小文字の区別のある方法で行われます。しかし、バイナリ照合を用いて、インデックスのつけられたカラムに対し、大文字小文字の区別のある古テキスト検索を行うことができます。例えば、latin1 文字セットを使用するカラムに、全文検索のために大文字小文字の区別をするよう、latin1_bin の照合を割り当てることができます。

以前に挙げた例のように、MATCH() が WHERE 句で使用されるとき、返された行はまず、最高レベルの関連性があるとした上で自動的に保管されます。関連値は、負でない浮動小数点数です。ゼロレリバンスとは、類似性がまったくないという意味です。レリバンスは、行の単語の数、行の一意性のある単語の数、コレクション内の単語の合計数、そして特定の単語を含む資料 ( 行 ) の数に基づいて計算されます。

単に検出を数えるには、次のクエリを使用してください :

mysql> SELECT COUNT(*) FROM articles
    -> WHERE MATCH (title,body)
    -> AGAINST ('database' IN NATURAL LANGUAGE MODE);
+----------+
| COUNT(*) |
+----------+
|        2 | 
+----------+
1 row in set (0.00 sec)

しかし、次のようにクエリを書き換えたほうが手軽な場合もあります :

mysql> SELECT
    -> COUNT(IF(MATCH (title,body) AGAINST ('database' IN NATURAL LANGUAGE MODE), 1, NULL))
    -> AS count
    -> FROM articles;
+-------+
| count |
+-------+
|     2 | 
+-------+
1 row in set (0.03 sec)

最初のクエリは関連性の大きさによって結果をソートし、2 番目のクエリではそれを行いません。しかし、2 番目のクエリは 1 番目が行わない、テーブル全体のスキャンをします。1 番目は数行のマッチしか検出されなければ時間はかかりませんが、そうでなくとも 2 番目は、どちらにしても多くの行を読むので素早く終わります。

自然言語の全文検索では、MATCH() 関数で名付けられたカラムが、テーブルの FULLTEXT インデックスのどれかに含まれるカラムと同じでなければなりません。先行のクエリに関しては、MATCH() 関数で名付けられたカラム ( title and body ) は、article テーブルの FULLTEXT インデックスの定義で名付けられたものと同じです。title と body を別々に検索したい場合は、各カラムに別々の FULLTEXT インデックスを作成する必要があります。

また、ブール検索もしくはクエリ拡張との検索を行うことも可能です。これらの検索タイプは項11.7.1. 「ブール全文検索」と項11.7.2. 「クエリ拡張を伴う全文検索」で説明されています。

インデックスを用いた全文検索は、インデックスが複数のテーブルをまたぐことはできないため、MATCH() 句の単一テーブルからのカラムにしか名前が付けられません。ブール検索はインデックスがなくても行えます ( ただしスピードは落ちる ) 。その場合、複数のテーブルからのカラムを名付けることは可能です。

先行の例は、関連性が減少する順序に行が戻される MATCH() 関数の使い方を簡単に説明したものでした。次の例は関連値を明示的に引き出す方法です。SELECT が WHERE 句も ORDER BY 句も含んでいないため、行は順序付けられていません :

mysql> SELECT id, MATCH (title,body)
    -> AGAINST ('Tutorial' IN NATURAL LANGUAGE MODE) AS score
    -> FROM articles;
+----+------------------+
| id | score            |
+----+------------------+
|  1 | 0.65545833110809 |
|  2 |                0 |
|  3 | 0.66266459226608 |
|  4 |                0 |
|  5 |                0 |
|  6 |                0 |
+----+------------------+
6 rows in set (0.00 sec)

次の例はさらに複雑なものです。クエリは関連値を戻し、また、関連性が減少する順序に行をソートします。この結果を得るため、MATCH() を 2 度指定してください : 一度は SELECT リスト、そしてもう一度は WHERE 句で指定します。MySQL の最適化プログラムが、ふたつの MATCH() 呼び出しがまったく同じもので、全文検索コードを一度だけ実行されることに気付くため、これによって追加のオーバーヘッドが起こることはありません。

mysql> SELECT id, body, MATCH (title,body) AGAINST
    -> ('Security implications of running MySQL as root'
    -> IN NATURAL LANGUAGE MODE) AS score
    -> FROM articles WHERE MATCH (title,body) AGAINST
    -> ('Security implications of running MySQL as root'
    -> IN NATURAL LANGUAGE MODE);
+----+-------------------------------------+-----------------+
| id | body                                | score           |
+----+-------------------------------------+-----------------+
|  4 | 1. Never run mysqld as root. 2. ... | 1.5219271183014 |
|  6 | When configured properly, MySQL ... | 1.3114095926285 |
+----+-------------------------------------+-----------------+
2 rows in set (0.00 sec)

MySQL FULLTEXT の実装は、true 語文字 (文字、数字、および線文字 ) のすべてのシークエンスを言葉みなします。そのシークエンスはまた、アポストロフィ ( ‘'’ ) も含むことができますが、1 行にひとつのみです。つまり、aaa'bbb は一語とみなされますが、aaa''bbb は二語の扱いです。単語の頭または終わりのアポストロフィは、FULLTEXT パーサが取ってしまうので、'aaa'bbb' ならば aaa'bbb になります。

FULLTEXT パーサは特定の区切り文字を見て、語の頭と最後を定義します。その例には、‘?’ ( スペース ) , ‘,’ ( カンマ ) , そして ‘.’ ( ピリオド ) があります。単語が非区切り文字 ( 例えば中国語 ) で区切られている場合は、FULLTEXT パーサは単語の最初と最後を定義することができません。単語や、インデックスのついた他の表現をそのような言語で FULLTEXT インデックスに加えるには、事前に処理して ‘"’ などの任意の区切り文字で区切る必要があります。

MySQL 5.1 では、組み込まれた全文パーサを置き換えるプラグインを書くことができます。詳細は、項25.2. 「The MySQL Plugin Interface」を参照してください。例えば、パーサプラグンのソースコードについては、MySQL のソース配布物の plugin/fulltext ディレクトリをご覧ください。

単語のあるものは、全文検索では無視されます :

短すぎる単語は無視されます。全文検索で検出される言葉で最も短いものは 4 文字です。
ストップワードリストにある言葉は無視されます。ストップワードは「the」や「some」などの常用語で、語義の値はゼロとされています。すでに組み込まれているストップワードのリストがありますが、ユーザ定義リストで書き換えることができます。

デフォルトのストップワードリストは項11.7.3. 「全文ストップワード」で挙げられています。デフォルトの最短の単語の長さとストップワードリストは、項11.7.5. 「微調整 MySQL 全文検索」で説明されているように変更することができます。

コレクションとクエリの中のすべての正しい言葉は、コレクションまたはクエリでの重要性によって加重されています。従って、多くの資料に登場する言葉は、このコレクションでは語義の値が低いので、比重が低く ( あるものはゼロ ) なっています。逆に、稀な言葉は高く重みづけがされます。言葉の比重は、行の関連性を計算するために組み合わせて応用されます。

このような技術は、コレクションが大きいほど効果的に作用します ( 実際、そうなるように綿密に調整されています ) 。ごく小さなテーブルでは、言葉の分配が語義の値を適切に反映しないため、この形式においては時に不可解な結果が出ることがあります。例えば、「MySQL」という言葉は既出の articles テーブルのすべての行に含まれていますが、この単語で検索しても結果は出ません :

mysql> SELECT * FROM articles
    -> WHERE MATCH (title,body)
    -> AGAINST ('MySQL' IN NATURAL LANGUAGE MODE);
Empty set (0.00 sec)

「MySQL」という言葉は少なくとも 50 % の行で提示されているため、検索結果は空になります。このように、この言葉は効果的にストップワードとして扱われます。大きなデータセットでは、これは最も望ましい動作です : 自然言語のクエリは、1GB テーブルの毎 2 行目は戻さないようになっています。小さなデータセットにとっては、これはあまり望ましい動作ではありません。

テーブルの行の半分にマッチする言葉は、関連のある資料を見つけるのに適しません。事実、関連のないものも大量に検出されるでしょう。これはインターネットのサーチエンジンでの検索と同じ論理です。このため、この言葉を含む行は、この特定のデータセットにおいて 語義の値が低く定められています。あるデータセットでは、提示された単語が 50% の境界値を越えても、他のデータセットではまた異なります。

50% の境界値は、全文検索を行うとその重要性が明らかになります : テーブルを作成し、テキストの 1 行または 2 行のみをインサートしてみると、テキストのすべての単語は少なくとも 50% の行に存在することが分かります。そのため、検出結果は検出されません。少なくとも 3 行以上をインサートするようにしてください。50% の制限を避ける必要がある場合は、ブール検索をお試しください。詳細は項11.7.1. 「ブール全文検索」をご覧ください。

11.7.1. ブール全文検索

MySQL は IN BOOLEAN MODE 修飾子を使用して、ブール全文検索を行うことができます。

mysql> SELECT * FROM articles WHERE MATCH (title,body)
    -> AGAINST ('+MySQL -YourSQL' IN BOOLEAN MODE);
+----+-----------------------+-------------------------------------+
| id | title                 | body                                |
+----+-----------------------+-------------------------------------+
|  1 | MySQL Tutorial        | DBMS stands for DataBase ...        |
|  2 | How To Use MySQL Well | After you went through a ...        |
|  3 | Optimizing MySQL      | In this tutorial we will show ...   |
|  4 | 1001 MySQL Tricks     | 1. Never run mysqld as root. 2. ... |
|  6 | MySQL Security        | When configured properly, MySQL ... |
+----+-----------------------+-------------------------------------+

+ および - 演算子は、その言葉が含まれるものを検索するか、含まれないものを検索するかを示します。従って、このクエリは「MySQL」という単語を含むすべての行を引き出しますが、「YourSQL」という単語は 含まれません 。

ブール全文検索は以下の特徴を持っています :

50% の境界値を用いません。
行を自動的に関連性の降順にソートすることはありません。先行のクエリの結果からもこれが分かります : 最高の関連性を持つ行は、「MySQL」を 2 度含んでいるものですが、最初でなく最後に挙げられています。
FULLTEXT インデックスなしでも実行が可能ですが、その方法での検索は速度が極めて遅くなります。
全文パラメータの最小および最大の単語の長さの適用。
ストップワードリストは適用されます。

ブール全文検索の機能は次の演算子をサポートします :

+
頭にプラス記号が付くのは、その言葉が戻される各行に必ず含まれていなければならないことを示します。
-
頭にマイナス記号が付くのは、その言葉が戻される行のいずれにも絶対に含まれるべきでないことを示します。
注記 :- 演算子は、本来なら他の検索語によって検出される行を除外するためだけのものです。従って、- によって優先された検索語のみを含むブールモードの検索は、空の結果を返します。「除外された検索語を含むものをのぞいたすべての行」が返されるわけではありません。
( 演算子なし )
デフォルトにより ( + も - も指定されていない場合 ) 、その単語は任意になりますが、その語を含む行は上位に順位づけられます。これは、IN BOOLEAN MODE 修飾子なしの MATCH() ... AGAINST() の動作を模倣しています。
> <
このふたつの演算子は、行にかけられた関連値への、単語の寄与度を変更します。> 演算子は寄与度を高め、< は低めます。以下のリストに続く例を参照してください。
( )
丸括弧は単語を部分式にグループ分けします。丸括弧でまとめられたグループは入れ子になります。
~
頭につくチルダ ( 波型記号 ) は否定演算子になり、行の関連性への単語の貢献が否定的になります。これは「noise」単語をマークするのに便利です。そのような単語を含む行は、他よりも低く順位づけられますが、- 演算子のように除外されることはありません。
*
アスタリスク ( 星印 ) は前方一致 ( またはワイルドカード ) 演算子として機能します。他の演算子とは異なり、単語に付加して影響をあたえます。* の演算子を単語の前につければマッチします。
"
二重引用符 ( ‘"’ ) でフレーズを囲むと、そのフレーズそのもの を持つ行のみにマッチします。フレーズを単語に分ける全文エンジンは、FULLTEXT インデックスで、その単語を検索します。非言語文字は正確にマッチする必要があります : フレーズ検索は、そのフレーズとまったく同じ単語を同じ並びで含むマッチのみを必要とします。例えば、"test phrase" は "test, phrase" とマッチします。
フレーズの単語がインデックスにある単語とマッチしない場合は、結果は空になります。例として、すべての単語がストップワードであったり、インデックスつき単語の必須の文字数に満たない場合などは、結果が空になります。

次の例はブール全文演算子を使用する検索ストリングを、いくつかデモンストレートしたものです :

'apple banana'
ふたつの単語のうち、すくなくともひとつを含む行を検出。
'+apple +juice'
両方の語を含む行を検出。
'+apple macintosh'
単語「apple」を含む行を検出し、さらに「macintosh」を含んでいる場合は行を高く順位づける。
'+apple -macintosh'
単語「apple」を含み、「macintosh」を含まない行を検出。
'+apple ~macintosh'
単語「apple」を含む行を検出するが、行が単語「macintosh」も含む場合は、含まないものよりも行を低く順位づける。これは、「macintosh」が含まれると完全に除外される '+apple -macintosh' の検索より「柔らかい」。
'+apple +(>turnover <strudel)'
「apple」と「turnover」、もしくは「apple」と「strudel」 ( 順序は不問 ) を含む行を検出するが、「apple turnover」を「apple strudel」より高く順序づける。
'apple*'
単語「apple」、「apples」、「applesauce」、または「applet」を含む行を検出。
'"some words"'
「some words」とまったく同じフレーズを含む行を検出 ( 例えば、「some words of wisdom」を含む行は該当するが、「some noise words」は該当しない ) 。フレーズを囲む ‘"’ 文字は、フレーズを区切る演算子であることに注意。それらは検索ストリングそのものを囲む引用符ではない。

11.7.2. クエリ拡張を伴う全文検索

全文検索はクエリの拡張をサポートします ( 特にその変異型の「ブラインドクエリ拡張」 ) 。これは一般的に、検索フレーズが短すぎる時に役に立ちます。フレーズが短いのは主に、ユーザに曖昧な知識しかなく、全文検索エンジンの暗示検索能力に頼る場合ですが、全文検索エンジンではその能力が不十分です。例えばユーザが「database」で検索する場合は、「MySQL」、「Oracle」、「DB2」、そして「RDBMS」を指していると考えられ、これらのフレーズはすべて「databases」とマッチし戻されます。これが暗示検索能力です。

ブラインドクエリ拡張 ( 自動関連フィードバックとも言う ) は、検索フレーズの後に WITH QUERY EXPANSION または IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION を加えることによって有効になります。これは検索を 2 度行うことで作動し、2 度目の検索には、最初の検索で検出された資料から、最も関連性の強い単語を抜き出してつなぎ合わせた、独自の検索フレーズを使用します。従って、資料のどれかに単語「databases」および「MySQL」が含まれている場合、2 度目の検索では「database」を含んでいなくても、「MySQL」を含む資料が検出されます。次の例はその相違点を示しています :

mysql> SELECT * FROM articles
    -> WHERE MATCH (title,body)
    -> AGAINST ('database' IN NATURAL LANGUAGE MODE);
+----+-------------------+------------------------------------------+
| id | title             | body                                     |
+----+-------------------+------------------------------------------+
|  5 | MySQL vs. YourSQL | In the following database comparison ... |
|  1 | MySQL Tutorial    | DBMS stands for DataBase ...             |
+----+-------------------+------------------------------------------+
2 rows in set (0.00 sec)

mysql> SELECT * FROM articles
    -> WHERE MATCH (title,body)
    -> AGAINST ('database' WITH QUERY EXPANSION);
+----+-------------------+------------------------------------------+
| id | title             | body                                     |
+----+-------------------+------------------------------------------+
|  1 | MySQL Tutorial    | DBMS stands for DataBase ...             |
|  5 | MySQL vs. YourSQL | In the following database comparison ... |
|  3 | Optimizing MySQL  | In this tutorial we will show ...        |
+----+-------------------+------------------------------------------+
3 rows in set (0.00 sec)

他の例では、Georges Simenon 著の Maigret についての書籍を検索する時に、ユーザが「Maigret」のスペルを知らないと仮定します。クエリ拡張なしで、「Megre and the reluctant witnesses」で検索した場合、「Maigret and the Reluctant Witnesses」の単語群でしか検出されません。クエリ拡張を使用すれば、2 度目の検索で、「Maigret」を含むすべての書籍が検出されます。

注記 :ブラインドクエリ拡張は関連性のない雑多な資料も戻しがちなため、検索フレーズが短い時にだけ使用することをお薦めします。

11.7.3. 全文ストップワード

次のテーブルは、フルテキストのストップワードのデフォルトのリストです。

a's	able	about	above	according
accordingly	across	actually	after	afterwards
again	against	ain't	all	allow
allows	almost	alone	along	already
also	although	always	am	among
amongst	an	and	another	any
anybody	anyhow	anyone	anything	anyway
anyways	anywhere	apart	appear	appreciate
appropriate	are	aren't	around	as
aside	ask	asking	associated	at
available	away	awfully	be	became
because	become	becomes	becoming	been
before	beforehand	behind	being	believe
below	beside	besides	best	better
between	beyond	both	brief	but
by	c'mon	c's	came	can
can't	cannot	cant	cause	causes
certain	certainly	changes	clearly	co
com	come	comes	concerning	consequently
consider	considering	contain	containing	contains
corresponding	could	couldn't	course	currently
definitely	described	despite	did	didn't
different	do	does	doesn't	doing
don't	done	down	downwards	during
each	edu	eg	eight	either
else	elsewhere	enough	entirely	especially
et	etc	even	ever	every
everybody	everyone	everything	everywhere	ex
exactly	example	except	far	few
fifth	first	five	followed	following
follows	for	former	formerly	forth
four	from	further	furthermore	get
gets	getting	given	gives	go
goes	going	gone	got	gotten
greetings	had	hadn't	happens	hardly
has	hasn't	have	haven't	having
he	he's	hello	help	hence
her	here	here's	hereafter	hereby
herein	hereupon	hers	herself	hi
him	himself	his	hither	hopefully
how	howbeit	however	i'd	i'll
i'm	i've	ie	if	ignored
immediate	in	inasmuch	inc	indeed
indicate	indicated	indicates	inner	insofar
instead	into	inward	is	isn't
it	it'd	it'll	it's	its
itself	just	keep	keeps	kept
know	knows	known	last	lately
later	latter	latterly	least	less
lest	let	let's	like	liked
likely	little	look	looking	looks
ltd	mainly	many	may	maybe
me	mean	meanwhile	merely	might
more	moreover	most	mostly	much
must	my	myself	name	namely
nd	near	nearly	necessary	need
needs	neither	never	nevertheless	new
next	nine	no	nobody	non
none	noone	nor	normally	not
nothing	novel	now	nowhere	obviously
of	off	often	oh	ok
okay	old	on	once	one
ones	only	onto	or	other
others	otherwise	ought	our	ours
ourselves	out	outside	over	overall
own	particular	particularly	per	perhaps
placed	please	plus	possible	presumably
probably	provides	que	quite	qv
rather	rd	re	really	reasonably
regarding	regardless	regards	relatively	respectively
right	said	same	saw	say
saying	says	second	secondly	see
seeing	seem	seemed	seeming	seems
seen	self	selves	sensible	sent
serious	seriously	seven	several	shall
she	should	shouldn't	since	six
so	some	somebody	somehow	someone
something	sometime	sometimes	somewhat	somewhere
soon	sorry	specified	specify	specifying
still	sub	such	sup	sure
t's	take	taken	tell	tends
th	than	thank	thanks	thanx
that	that's	thats	the	their
theirs	them	themselves	then	thence
there	there's	thereafter	thereby	therefore
therein	theres	thereupon	these	they
they'd	they'll	they're	they've	think
third	this	thorough	thoroughly	those
though	three	through	throughout	thru
thus	to	together	too	took
toward	towards	tried	tries	truly
try	trying	twice	two	un
under	unfortunately	unless	unlikely	until
unto	up	upon	us	use
used	useful	uses	using	usually
value	various	very	via	viz
vs	want	wants	was	wasn't
way	we	we'd	we'll	we're
we've	welcome	well	went	were
weren't	what	what's	whatever	when
whence	whenever	where	where's	whereafter
whereas	whereby	wherein	whereupon	wherever
whether	which	while	whither	who
who's	whoever	whole	whom	whose
why	will	willing	wish	with
within	without	won't	wonder	would
would	wouldn't	yes	yet	you
you'd	you'll	you're	you've	your
yours	yourself	yourselves	zero	?

11.7.4. 全文制限

全文検索は MyISAM テーブルでのみサポートされています。
全文検索は、ほとんどのマルチバイト文字セットと使用できます。例外は Unicode で、utf8 文字セットは使用可能ですが、ucs2 文字セットは使用できません。
中国語や日本語のような表意文字を用いる言語は区切り符号を持ちません。従って、FULLTEXT パーサはその種の言語では単語の始めと終わりを区別することができません。この含意と問題の回避については項11.7. 「全文検索関数」で説明されています。
単一テーブル内での複数の文字セットの使用はサポートされているものの、FULLTEXT インデックスのすべてのカラムは、同じ文字セットと照合を使用する必要があります。
MATCH() カラムリストは、MATCH() が IN BOOLEAN MODE でない限り、FULLTEXT インデックスのテーブルのための定義のカラムリストと正確に一致していなければなりません。ブールモードの検索はインデックス付きでないカラムでも行えますが、スピードは遅くなるでしょう。
AGAINST() への引数は定数ストリングでなければなりません。

11.7.5. 微調整 MySQL 全文検索

MySQL の全文検索の機能は、ユーザが調整できるパラメータをほどんど持っていません。全文検索の動作をある程度コントロールすることは可能ですが、変更にはソースコードの改変が必要になる場合があるので、MySQL ソース配布物が必要です。詳細は項2.9. 「ソースのディストリビューションを使用した MySQL のインストール」を参照してください。

全文検索は最大の効果を発揮するよう、慎重に調整されています。デフォルトの動作を改変すると、多くの場合、その効果を低めることになります。特に知識がない限り、MySQL のソースを変更しないでください。。

このセクションで説明されている全文変数のほとんどは、サーバの起動時に設定する必要があります。変更にはサーバの再起動が必要です。サーバが作動している間は手を加えることはできません。

変数のあるものは、変更するとテーブルの FULLTEXT インデックスを再構築しなければなりません。この手順は、このセクションの最後で説明されています。

インデックスを付けるにあたっての単語の最小および最大の文字数は、ft_min_word_len および ft_max_word_len システム環境変数によって定義されています。( 項4.2.3. 「システム変数」参照 ) デフォルトの最小値は 4 文字で、最大値はバージョンによって異なります。これらの値を変更する場合は、FULLTEXT インデックスを再構築する必要があります。例えば、3 文字でも検索を可能にしたい場合、次のラインをオプションファイルに入力することで、ft_min_word_len 変数を設定できます :
```
[mysqld]
ft_min_word_len=3
```
その後、サーバを再起動し、FULLTEXT インデックスを再構築します。このリストの後にある説明の、myisamchk についての記述は特に注意してお読みください。
デフォルトのストップワードリストを書き換えるには、ft_stopword_file システム環境を設定してください。( 項4.2.3. 「システム変数」参照 ) 変数値は、ストップワードリストを含むファイルのパス名か、ストップワードのフィルタ処理を無効にする空のストリングになります。この変数の値か、ストップワードファイルの内容を変更した後、サーバを再起動し、FULLTEXT インデックスを再構築してください。
ストップワードリストはフリー形態です。つまり、改行、スペース、またはコンマなどの非英数文字を使用して、ストップワードを区切ることができます。例外は、単語の一部として扱われる、下線文字 ( ‘_’ ) と単一引用符 ( ‘'’ ) です。ストップワードリストの文字セットは、サーバのデフォルトの文字セットです。項9.3.1. 「サーバのキャラクタセットおよび照合順序」参照。
自然言語検索の 50% の境界値は、選択された特定の加重スキームによって定義されています。これを無効にするには、storage/myisam/ftdefs.h で次のラインを探してください :
```
#define GWS_IN_USE GWS_PROB
```
Change that line to this:
```
#define GWS_IN_USE GWS_FREQ
```
その語、MySQL を再コンパイルします。この場合は、インデックスを再構築する必要はありません。注記 :この変更を行うことで、MATCH() 関数に対して適切な関連値を提供する MySQL の能力は大幅に低下します。一般的な単語をどうしても検索する必要があるなら、50% の境界値を変更しなくても済む、IN BOOLEAN MODE を使用して検索するほうが賢明です。
ブール全文検索に使用した演算子を変更するには、ft_boolean_syntax システム環境変数を設定します。この変数はサーバの使用中でも変更することができますが、実行するには SUPER 権限が必須です。この場合は、インデックスを再構築する必要はありません。この変数の設定をつかさどるルールの説明を、項4.2.3. 「システム変数」でご覧ください。
言語文字とされる文字のセットを変更したい場合、方法はふたつあります。ハイフン文字 ( ' - ' ) を言語文字として扱いたいと仮定します。下記のどちらかの方法を使用してください :
- MySQL ソースを改変する : storage/myisam/ftdefs.h で、true_word_char() および misc_word_char() マクロをご覧ください。そのマクロのどちらかに '-' を加え、MySQL を再コンパイルします。
- 文字セットファイルを改変する : これには再コンパイルは不要です。true_word_char() マクロは、「character type」テーブルを使用して、他の文字と、アルファベットおよび数字を区別します。. 文字セットの XML ファイルのひとつで、<ctype><map> の内容を編集し、'-' を「letter」に指定します。その後、FULLTEXT インデックスに、提示された文字セットを使用します。
改変の後で、FULLTEXT インデックスを含む各テーブルのインデックスを再構築します。

インデックスに影響を及ぼす全文変数 ( ft_min_word_len 、ft_max_word_len 、または ft_stopword_file )を改変する場合、もしくはストップワードファイルそのものを変更する場合、変更を行った後に FULLTEXT インデックスを再構築し、サーバを再起動させてください。この場合にインデックスを再構築するには、QUICK 修復オペレーションを行えば十分です ;

mysql> REPAIR TABLE tbl_name QUICK;

FULLTEXT インデックスをひとつでも含むテーブルはそれぞれ、上記のように修復が必要です。さもなければ、テーブルのクエリが誤った結果を生産し、テーブルの変更によって、サーバはテーブルを修復が必要な破損があるものとみなします。

myisamchk を使用してテーブルのインデックスを改変する操作 ( 修復や分析 ) を行った場合、特に指定しない限り、FULLTEXT インデックスは、最小文字数、最大文字数、そしてストップワードファイルに対するデフォルトの全文パラメータ値を使用して再構築されます。これはクエリの失敗につながります。

問題の原因は、これらのパラメータがサーバにしか認識されていないことです。それらは MyISAM インデックスファイルには保存されていません。この問題を避けるには、サーバによって使用される最小または最大文字数、もしくはストップワードファイル値を改変した場合、mysqld に使用する myisamchk と同じ ft_min_word_len 、ft_max_word_len 、および ft_stopword_file 値を指定してください。例えば、最小文字数を 3 に設定した場合、次のように myisamchk をもってテーブルを修復することができます :

shell> myisamchk --recover --ft_min_word_len=3 tbl_name.MYI

myisamchk とサーバが、間違いなく全文パラメータに同じ値を使用するよう、それぞれをオプションファイルの [mysqld] と [myisamchk] のセクションに置いてください :

[mysqld]
ft_min_word_len=3

[myisamchk]
ft_min_word_len=3

myisamchk の使用に替わる方法は、REPAIR TABLE 、ANALYZE TABLE 、OPTIMIZE TABLE 、もしくは ALTER TABLE 文の使用です。これらのステートメントは、適切な全文パラメータ値を選ぶことのできるサーバによって実行されます。

11.8. キャスト関数と演算子

BINARY
BINARY 演算子はそれに続いて、バイナリストリングにストリングをキャストします。これはカラムの比較を強制的に、文字ごとでなくバイトごとに行わせる簡易な方法です。カラムが BINARY または BLOB と定義されていない場合でも、大文字小文字を区別した比較になります。BINARY もまた、後続のスペースを重要なものにします。
```
mysql> SELECT 'a' = 'A';
        -> 1
mysql> SELECT BINARY 'a' = 'A';
        -> 0
mysql> SELECT 'a' = 'a ';
        -> 1
mysql> SELECT BINARY 'a' = 'a ';
        -> 0
```
比較において、BINARY は演算全体に影響を与えます。同じ結果を持つどちらのオペランドの前にでも、与えることができます。
BINARY str は、CAST(str AS BINARY) の省略表記です。
コンテキストのあるものでは、インデックス付きのカラムを BINARY にキャストした場合、MySQL はそのインデックスを有効に使うことができません。
CAST(expr AS type), CONVERT(expr,type), CONVERT(expr USING transcoding_name)
CAST() および CONVERT() 関数はひとつのタイプの値をもって、他のタイプの値を生成します。
その type は次の値のどれかになりえます :
- BINARY[(N)]
- CHAR[(N)]
- DATE
- DATETIME
- DECIMAL
- SIGNED [INTEGER]
- TIME
- UNSIGNED [INTEGER]
BINARY は、BINARY データタイプを持つストリングを生成します。これが比較に及ぼす影響については項10.4.2. 「BINARY と VARBINARY タイプ」をご覧ください。任意の長さ N が与えられた場合、BINARY(N) は、キャストが N バイト以下の引数を使用する原因となります。N バイトより短い値は、0x00 バイトで N の長さまでパッドされます。
CHAR(N) 句は、キャストが N 文字以下の引数を使用する原因になります。
CAST() および CONVERT(... USING ...) は標準の SQL シンタックスです。CONVERT() の非 USING フォームは ODBC シンタックスです。
USING を持つ CONVERT() は、異なる文字セット間のデータを変換するのに使用されます。MySQL では、符号化名は対応文字セット名と同じものです。例えば、このステートメントは、デフォルトの文字セットのストリング 'abc' を、utf8 文字セットの対応ストリングに変換します。
```
SELECT CONVERT('abc' USING utf8);
```

バイナリストリングは文字セットを持たないため、通常は BLOB 値、またはバイナリストリングを、大文字小文字の区別のない方法で比較はできず、従って大文字小文字という概念はありません。大文字小文字を区別しない比較を行うには、CONVERT() 関数を使用して、値を非バイナリストリングに変換します。結果の文字セットが大文字小文字を区別しない照合を得た場合、LIKE 演算は大文字小文字の区別をしません :

SELECT 'A' LIKE CONVERT(blob_col USING latin1) FROM tbl_name;

異なる文字セットを使用するには、先行するステートメントで、その名前を latin1 の代わりにします。大文字小文字の区別のない照合を確実に使用するには、CONVERT() 呼び出しの後に COLLATE 句を特定します。

CONVERT() を、異なる文字セットで示されているストリングの比較に、より一般的に使用することができます。

キャスト関数は、CREATE ... SELECT 文で、特定のタイプのカラム作成したい場合に役立ちます :

CREATE TABLE new_table SELECT CAST('2000-01-01' AS DATE);

この関数はまた、ENUM カラムを語彙順にソートしたい場合にも利用できます。通常は、ENUM カラムのソートは内部数値を使用して行います。値を CHAR にキャストすると、結果は語彙順になります :

SELECT enum_col FROM tbl_name ORDER BY CAST(enum_col AS CHAR);

CAST(str AS BINARY) は BINARY str と同じものです。CAST(expr AS CHAR) は式を、デフォルトの文字セットを持つストリングとして扱います。

CONCAT('Date: ',CAST(NOW() AS DATE)) のようなより複雑な式の一部として使用する場合、CAST() もまた結果を変えます。

データを異なるフォーマットに抽出するには、CAST() ではなく、LEFT() または EXTRACT() のようなストリング関数を使用します。詳細は項11.5. 「日付時刻関数」を参照してください。

ストリングを数値コンテキストの数値にキャストするには、通常はストリング値を数字のように使用するだけで済みます。

mysql> SELECT 1+'1';
       -> 2

ストリングコンテキストで数字を使用する場合、その数字は自動的に BINARY ストリングに変換されます。

mysql> SELECT CONCAT('hello you ',2);
        -> 'hello you 2'

MySQL は、符号付きでも、符号無しでも、64 バイト値での演算をサポートします。算術演算子 ( + または - など ) を使用しており、演算のひとつは符号のない整数である場合、結果は符合なしになります。SIGNED および UNSIGNED キャスト演算子を使用して、演算を符号付き、もしくは符号なしの 64 ビットの整数にキャストすることで、これをそれぞれオーバーライドすることができます。

mysql> SELECT CAST(1-2 AS UNSIGNED)
        -> 18446744073709551615
mysql> SELECT CAST(CAST(1-2 AS UNSIGNED) AS SIGNED);
        -> -1

オペランドのどちらかが浮動小数点値で有る場合、結果は浮動小数点値になり、前のルールには影響を受けません。( このコンテキストでは、DECIMAL カラム値は浮動小数点値とみなされます。)

mysql> SELECT CAST(1 AS UNSIGNED) - 2.0;
        -> -1.0

算術演算でストリングを使用している場合、これは浮動小数点数に変換されます。

「zero」日付ストリングを日付に変換する場合、CONVERT() と CAST() は NULL を戻し、NO_ZERO_DATE SQL モードが有効になれば警告を発行します。

11.9. XML 関数

このセクションでは MySQL での XML と関連する機能について説明します。

--xml オプションで呼び出して、mysql および mysqldump クライアントの XML フォーマットの出力を MySQL から得ることは可能です。項7.7. 「mysql ? MySQL コマンドラインツール」および項7.12. 「mysqldump ? データベースバックアッププログラム」を参照してください。

MySQL 5.1.5 からは、基礎的な XPath ( XML Path Language ) 機能を提供するふたつの関数を利用することができます。

これらの関数は現在もまだ開発途中ですのでご注意ください。MySQL 5.1 と今後のためにも、これらの関数や XML および XPath の機能を改良し続けていきます。これらについてご意見や質問のある方、また他のユーザからのアドバイスを得たい方は、MySQL XML User Forum をご覧ください。

ExtractValue(xml_frag, xpath_expr)
ExtractValue() はふたつのストリング引数、XML マークアップのフラグメント xml_frag 、そして XPath 式 xpath_expr ( locator とも呼ばれる ) を取り、XPath 式によってマッチされたエレメントの子である、最初のテキストノードのテキスト ( CDATA ) を戻します。これは、/text() を付加した後に、xpath_expr を使用してマッチを行うのと同様です。つまり、ExtractValue('<a>Sakila</a>', '/a/b') と ExtractValue('<a>Sakila</a>', '/a/b/text()') は同じ結果を生成します。
複数のマッチが検出される場合、各マッチングエレメントの、最初の子のテキストノードの内容は、単一の、スペースで区切られたストリングとして ( マッチした順で ) 戻されます。
( 拡大された ) 式 ? に対して、マッチするテキストノードが検出されない場合 ? どういう理由であれ、xpth_expr が有効で、xml_frag が適切に成型されていれば ? 空のストリングが戻されます。空のエレメントでの整合と、整合するものがないのとは、区別はされません。これはデザインによるものです。
xml_frag でマッチするエレメントが見つからなかったのか、またはマッチするエレメントはあったものの、非子テキストノードを含んでいたのかを判断する必要があれば、XPath count() 関数を使用する式の結果をテストしてください。例えば、次のように、これらのステートメントの両方が空のストリングを返す場合 :
```
mysql> SELECT ExtractValue('<a></a>', '/a/b');
+-------------------------------------+
| ExtractValue('>a<>b/<>/a<', '/a/b') |
+-------------------------------------+
| |
+-------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ExtractValue('<a><c/></a>', '/a/b');
+-------------------------------------+
| ExtractValue('<a><c/></a>', '/a/b') |
+-------------------------------------+
| |
+-------------------------------------+
1 row in set (0.00 sec)
```
しかし、次のように、実際にまっちするエレメントがあったのかを確認することはできます :
```
mysql> SELECT ExtractValue('<a></a>', 'count(/a/b)');
+-------------------------------------+
| ExtractValue('<a></a>', 'count(/a/b)') |
+-------------------------------------+
| 1 |
+-------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ExtractValue('<a><c/></a>', 'count(/a/b)');
+-------------------------------------+
| ExtractValue('<a><c/></a>', 'count(/a/b)') |
+-------------------------------------+
| 0 |
+-------------------------------------+
1 row in set (0.01 sec)
```
ExtractValue() は CDATA のみを戻し、マッチングタグに含まれるタグや、それらのコンテントは戻されません ( 次の例の、val1 として戻された結果を参照 ) 。
```
mysql> SELECT
 -> ExtractValue('<a>cccddd</a>', '/a') AS val1,
 -> ExtractValue('<a>cccddd</a>', '/a/b') AS val2,
 -> ExtractValue('<a>cccddd</a>', '//b') AS val3,
 -> ExtractValue('<a>cccddd</a>', '/b') AS val4,
 -> ExtractValue('<a>cccdddeee</a>', '//b') AS val5;

+------+------+------+------+---------+
| val1 | val2 | val3 | val4 | val5 |
+------+------+------+------+---------+
| ccc | ddd | ddd | | ddd eee |
+------+------+------+------+---------+
```
MySQL 5.1.8 からは、この関数は、contains() との比較に現行の SQL の照合を使用します。( 以前は、バイナリ ? 大文字小文字の区別あり ? 比較が常に使用されていました。)

UpdateXML(xml_target, xpath_expr, new_xml)

この関数は、XML マークアップ xml_target の提示されたフラグメントの単一部を、新しい XML フラグメント new_xml に置き換え、その後チャージされた XML を戻します。置換された xml_target の一部は、ユーザから提供された XPath 式 xpath_expr にマッチします。xpath_expr にマッチする式が検出されない場合、または複数のマッチが見つかった場合、この関数は独自の xml_target XML フラグメントを戻します。3 つすべての引数はストリングでなければなりません

mysql> SELECT
    ->   UpdateXML('<a><b>ccc</b><d></d></a>', '/a', '<e>fff</e>') AS val1,
    ->   UpdateXML('<a><b>ccc</b><d></d></a>', '/b', '<e>fff</e>') AS val2,
    ->   UpdateXML('<a><b>ccc</b><d></d></a>', '//b', '<e>fff</e>') AS val3,
    ->   UpdateXML('<a><b>ccc</b><d></d></a>', '/a/d', '<e>fff</e>') AS val4,
    ->   UpdateXML('<a><d></d><b>ccc</b><d></d></a>', '/a/d', '<e>fff</e>') AS val5
    -> \G

*************************** 1. row ***************************
val1: <e>fff</e>
val2: <a><b>ccc</b><d></d></a>
val3: <a><e>fff</e><d></d></a>
val4: <a><b>ccc</b><e>fff</e></a>
val5: <a><d></d><b>ccc</b><d></d></a>

次は、いくつかの基本的な XPath 式の説明と例です :

/tag
<tag/> がルートのエレメントである場合にのみ、<tag/> にマッチします。
例 :/a は、最外部の ( ルート ) タグとマッチするため、<a></a> に一致を持ちます。このインスタンスでは他のエレメントの子になるため、<a/> の内側 a エレメントとは一致しません。
/tag1/tag2
<tag1/> の子と、<tag1/> がルートのエレメントである場合にのみ、<tag2/> にマッチします。
例 :ルートのエレメント a の子であるため、/a/b は XML フラグメント <a></a> 内の b エレメントとマッチします。このケースでは bはルートのエレメント ( 従って他のどのエレメントの子でもない ) ため、<a/> でマッチするものはありません。XPath 式もまた、<a><c></c></a> でマッチするものはありません。従って、b は a の子孫ですが、a の子ではありません。
この構築は 3 つ以上のエレメントに拡張可能です。例えば、XPath 式 /a/b/c は、フラグメント <a><c/></a> の c エレメントに一致します。
//tag
tag のすべてのインスタンスと一致します。
例 ://a は、次のうちのどの a エレメントとも一致します : <a><c/></a>; <c><a></a>; <c><a/></c>
// は / との結合が可能です。例えば、//a/b は、フラグメント <a></a> または <a><c/></a> のどれの b エレメントともマッチします。
* 演算子は、どのエレメントともマッチする「wildcard」のように作用します。例えば、式 /*/b は、XML フラグメント <a></a> または <c></c> のどの b エレメントともマッチします。しかし、b は他のどれかのエレメントの子であるため、この式はフラグメント <a/> ではマッチを生産しません。ワイルドカードはどのポジションででも使用することができます : 式 /*/b/* は、それ自身がルートのエレメントでない b エレメントの、どの子ともマッチします。
複数のロケータが、| ( 論理和 OR ) 演算子を用いてマッチすることができます。例えば、XPath 式 //b|//c は、XML ターゲットのすべての b および c エレメントにマッチします。
その特性のひとつ以上の値に基づいたエレメントにマッチすることも可能です。これは、シンタックス tag[@attribute="value"] を用いて行います。例えば、XPath 式 //b[@id="idB"] は、フラグメント <a><c/></a> の 2 番目の b エレメントに一致します。attribute="value" を持ついかなるに対しても一致するには、XPath 式 //*[attribute="value"] を使用します。
複数の属性値をフィルターにかけるには、単に複数の属性比較句を継続的に使用します。例えば、XPath 式 //b[@c="x"][@d="y"] は、与えられた XML フラグメントの各所で起こっている  エレメントに一致します。
同じ特性が複数の値のうちのひとつとマッチするエレメントを見つけるには、| 演算子によってつながれた複数のロケータを使う必要があります。例えば、c 特性が値 23 もしくは 17 を持つ、すべての b エレメントをマッチするには、式 //b[@c="23"]|b[@c="17"] を使用します。

XPath シンタックスのさらに詳しい説明や使用方法は、このマニュアルの対象範囲ではありません。決定的な情報については XML Path Language (XPath) 1.0 standard をご覧ください。XPath をご存知ない方、基本を復習したい方は Zvon.org XPath Tutorial を参照してください。複数の言語でご覧いただけます。

これらの関数にサポートされている XPath シンタックスは、現在、以下の制限の対象となっています :

ノードセット間比較 ( '/a/b[@c=@d]' など ) はサポートされていません。const が定数値のフォーム [@attribute="const"] の唯一の比較は、現在可能です。サポートされている比較演算子は、同等と不等 ( = と (!= ) のみです。
相対ロケータ式はサポートされていません。XPath 式は、/ または // で始まります。
:: 演算子はサポートされていません。
「Up-and-down」ナビゲーションは、パスがルートエレメントの「上」をリードする場合はサポートされていません。つまり、現在のエレメントのひとつ以上の祖先が同時にルートエレメントの祖先であり、与えたれたエレメントの祖先の継承上でマッチする式を使用することができません ( Bug#16321 参照 ) 。
次の XPath 関数はサポートされていません :
- id()
- lang()
- MySQL 5.1.8 よりで前は、last() 関数はサポートされていません ( Bug#16318 参照　) 。
- local-name()
- name()
- namespace-uri()
- normalize-space()
- starts-with()
- string()
- substring-after()
- substring-before()
- translate()
次の軸はサポートされていません :
- following-sibling
- following
- preceding-sibling
- preceding

MySQL 5.1.10 からは、XPath 式は引数として ExtractValue() に渡され、UpdateXML() が、XML ネームスペース記号を採用してマークアップとの使用を有効にするエレメントセレクタに、コロン文字 ( 「:」 ) を含むこともあります。例 :

mysql> SET @xml = '<a>111<b:c>222<d>333</d><e:f>444</e:f></b:c></a>';
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT ExtractValue(@xml, '//e:f');
+-----------------------------+
| ExtractValue(@xml, '//e:f') |
+-----------------------------+
| 444                         |
+-----------------------------+
1 row in set (0.00 sec)

mysql> SELECT UpdateXML(@xml, '//b:c', '<g:h>555</g:h>');
+--------------------------------------------+
| UpdateXML(@xml, '//b:c', '<g:h>555</g:h>') |
+--------------------------------------------+
| <a>111<g:h>555</g:h></a>                   |
+--------------------------------------------+
1 row in set (0.00 sec)

これは Apache Xalan と他のいくつかのパーサによって利用できるものに似ており、また、ネームスペース宣言または namespace-uri() や、local-name() 関数を要求したりするよりより単純です。

11.10. その他の関数

11.10.1. ビット関数
11.10.2. 暗号化関数と圧縮関数
11.10.3. 情報関数
11.10.4. その他の関数

11.10.1. ビット関数

MySQL はビット演算に BIGINT ( 64 ビット ) 演算を使用し、演算子が 64 ビットの最大範囲を持つようにします。

|
ビット単位の論理積 :
```
mysql> SELECT 29 | 15;
        -> 31
```
結果は符合なしの 64 ビット整数です。
&
ビット単位の論理積 :
```
mysql> SELECT 29 & 15;
        -> 13
```
結果は符合なしの 64 ビット整数です。

^

ビット単位の排他的論理和 :

mysql> SELECT 1 ^ 1;
        -> 0
mysql> SELECT 1 ^ 0;
        -> 1
mysql> SELECT 11 ^ 3;
        -> 8

結果は符合なしの 64 ビット整数です。

<<
longlong ( BIGINT ) ナンバーを左にシフトします。
```
mysql> SELECT 1 << 2;
 -> 4
```
結果は符合なしの 64 ビット整数です。
>>
longlong ( BIGINT ) ナンバーを右にシフトします。
```
mysql> SELECT 4 >> 2;
        -> 1
```
結果は符合なしの 64 ビット整数です。
~
すべてのビットを反転します。
```
mysql> SELECT 5 & ~1;
        -> 4
```
結果は符合なしの 64 ビット整数です。

BIT_COUNT(N)

引数 N で設定されているビットの数を戻します。

mysql> SELECT BIT_COUNT(29), BIT_COUNT(b'101010');
        -> 4, 3

11.10.2. 暗号化関数と圧縮関数

このセクションの関数は暗号化と復号化、そして圧縮と非圧縮を行います。

暗号化または圧縮	復号化または解凍
AES_ENCRYT()	AES_DECRYPT()
COMPRESS()	UNCOMPRESS()
ENCODE()	DECODE()
DES_ENCRYPT()	DES_DECRYPT()
ENCRYPT()	使用不可
MD5()	使用不可
OLD_PASSWORD()	使用不可
PASSWORD()	使用不可
SHA() or SHA1()	使用不可
使用不可	UNCOMPRESSED_LENGTH()

注記 :暗号化および圧縮関数はバイナリストリングを戻します。これらの関数の多くは、結果が任意のバイト値を含む場合があります。これらの結果を保存したい場合は、CHAR や VARCHAR カラムでなく、BLOB を使用して、後続のスペースの削除でデータ値が変更される可能性を避けてください。

注記 :MD5 および SHA-1 アルゴリズムの利用についてはすでに知られています。開発者は、このセクションで紹介されている他の暗号化関数の使用も考慮してください。

AES_ENCRYPT(str,key_str), AES_DECRYPT(crypt_str,key_str)
これらの関数では、以前は「Rijndael」として知られていた公式の AES ( Advanced Encryption Standard ) アルゴリズムを使用した、データの暗号化と復号化が可能です。128 ビットのキーの長さを使用したエンコードを行いますが、ソースを改変することで 256 ビットまで延長することができます。当社では、より速く、ほとんどの使用では十分に安全なため、128 ビットを採用しています。
AES_ENCRYPT() はストリングを暗号化し、バイナリストリングを戻します。AES_DECRYPT() はストリングを暗号化されたストリングを復号化し、本来のストリングを戻します。入力引数の長さは自由です。どちらかの引数が NULL の場合は、この関数の結果も NULL になります。
AES ブロックレベルアルゴリズムであるため、長さが不揃いなストリングのエンコードにはパッドを使用し、次の方式を使って結果ストリングの長さが計算されるようにします。
```
16 × (trunc(string_length / 16) + 1)
```
AES_DECRYPT() が無効な日付または不正確なパッドを検出した場合は、NULL が戻されます。しかし、入力データまたはキーが無効になっている場合は、AES_DECRYPT() が非 NULL 値 ( 不要データの可能性あり ) を戻すことも考えられます。
AES 関数を使用して、暗号化されたフォームのデータを、クエリを改変することによって格納することができます :
```
INSERT INTO t VALUES (1,AES_ENCRYPT('text','password'));
```
AES_ENCRYPT() および AES_DECRYPT() は、現在 MySQL で使用が可能なものの中で、暗号的に最も安全な暗号化関数だと考えられています。
COMPRESS(string_to_compress)
ストリングを圧縮し、結果をバイナリストリングとして戻します。この関数では、MySQL が zlib のような圧縮ライブラリとコンパイルされている必要があります。その条件が満たされない場合、その戻り値は常に 0 になります。圧縮されたストリングは、UNCOMPRESS() によって非圧縮することができます。
```
mysql> SELECT LENGTH(COMPRESS(REPEAT('a',1000)));
        -> 21
mysql> SELECT LENGTH(COMPRESS(''));
        -> 0
mysql> SELECT LENGTH(COMPRESS('a'));
        -> 13
mysql> SELECT LENGTH(COMPRESS(REPEAT('a',16)));
        -> 15
```
圧縮されたストリングの内容は次の方法で格納されます :
- 空のストリングは空のストリングとして格納。
- 空でないストリングは、圧縮されたストリングの後に、4 バイト長の非圧縮ストリングとして ( 下位バイトから ) 格納されます。ストリングの最後にスペースがある場合は、最後のスペースが除かれることがないよう、‘.’ 文字が追加されます。結果は CHAR または VARCHAR カラムに格納されます。( CHAR または VARCHAR を使用して、圧縮されたストリングを保存するのはお薦めできません。BLOB カラムをご使用ください。 )
DECODE(crypt_str,pass_str)
暗号化されたストリング crypt_str を、pass_str を使用し、パスワードとして復号化します。crypt_str は、ENCODE() から戻されたストリングであるべきです。
ENCODE(str,pass_str)
pass_str を使用し、str をパスワードとして暗号化します。結果を復号化するには DECODE() を用います。
結果は、str と同じ長さのバイナリストリングになります。
暗号化の強度は、ランダム発生器の質によります。短いストリングでも十分です。
DES_DECRYPT(crypt_str[,key_str])
DES_ENCRYPT() によって暗号化されたストリングを復号化します。エラーが起きた場合、この関数は NULL を戻します。
この関数は、MySQL が SSL サポートで設定されている場合のみ作動しますのでご注意ください。詳細は項4.8.7. 「接続安全」を参照してください。
key_str 引数が与えられていない場合、DES_DECRYPT() は暗号化されたストリングの最初のバイトを調査して、本来のストリングの暗号化に使用した DES キーナンバーを特定し、DES キーファイルからキーを読み取って、メッセージを復号化します。これを正しく行うには、ユーザは SUPER 権限を持っている必要があります。キーファイルは --des-key-file サーバオプションで特定できます。
この関数を key_str 引数に渡した場合、そのストリングはメッセージの復号化のキーとして使用されます。
crypt_str 引数が暗号化されたストリングでない場合は、MySQL は与えられた crypt_str を戻します。

DES_ENCRYPT(str[,{key_num|key_str}])

Triple-DES アルゴリズムを使用して、与えられたキーでストリングを暗号化します。

この関数は、MySQL が SSL サポートで設定されている場合のみ作動しますのでご注意ください。詳細は項4.8.7. 「接続安全」を参照してください。

使用する暗号化キーは、与えられていれば、DES_ENCRYPT() への 2 番目の引数に基づいて選択されます :

引数	解説
引数なし	DES キーファイルの最初のキーが使用される。
`key_num`	DES キーファイルからの与えられたキー番号 ( 0-9 ) が使用される。
`key_str`	与えられたキーストリングが `str` の暗号化に使用される。

キーファイルは --des-key-file サーバオプションで特定できます。

戻されるストリングは、最初の文字が CHAR(128 | key_num) であるバイナリストリングです。エラーが起きた場合、DES_ENCRYPT() は NULL を戻します。

暗号化されたキーが分かりやすいように、128 が加えられます。ストリングキーを使用する場合は、key_num は 127 です。

結果のストリングの長さは次の方式によって提示されます :

new_len = orig_len + (8 - (orig_len % 8)) + 1

DES キーファイルの各ラインは次のフォーマットを含みます :

key_num des_key_str

各 key_num 値は、0 から 9 の範囲の数字でなければなりません。ファイル内のラインの順は特定されていません。des_key_str はメッセージの暗号化に使用されるストリングです。数字とキーの間には、少なくともひとつはスペースが入ります。最初のキーは、DES_ENCRYPT() へのキー引数を指定しなかった場合に使用されるデフォルトのキーです。

MySQL に、キーファイルからの新しいキー値を、FLUSH DES_KEY_FILE 文で読み込むよう指示することができます。これには RELOAD 権限が必須です。

デフォルトキーのセットを持つことの利点のひとつは、エンドユーザにこれらの値を復号化する権利を与えることなく、既存の暗号化されたカラム値を確認する方法をアプリケーションに与えられることです。

mysql> SELECT customer_address FROM customer_table 
     > WHERE crypted_credit_card = DES_ENCRYPT('credit_card_number');

ENCRYPT(str[,salt])
Unix crypt() システム呼び出しを使って str を暗号化し、バイナリストリングを戻します。salt 引数は少なくとも 2 文字のストリングでなければいけません。salt が与えられていない場合は、ランダム値が使用されます。
```
mysql> SELECT ENCRYPT('hello');
        -> 'VxuFAJXVARROc'
```
ENCRYPT() は、少なくともいくつかのシステムでは、str の最初の 8 文字以外のすべてを無視します。この動作は、crypt() システム呼び出しを基本とした実装によって定められています。
utf8 以外のマルチバイト文字セットとの ENCYPT() の使用は、システム呼び出しが、ストリングがゼロバイトによって終了させられると想定するため、お薦めできません。
crypt() が使用しているシステムで利用できない場合 ( Windows のケースなど ) 、ENCRYPT() は常に NULL を戻します。
MD5(str)
MD5 128 ビットのチェックサムを、ストリング用に計算します。その値は 32 16進数のバイナリストリングとして戻され、または引数が NULL の場合は NULL が戻されます。例として、戻り値をハッシュキーとして使用することができます。
```
mysql> SELECT MD5('testing');
        -> 'ae2b1fca515949e5d54fb22b8ed95575'
```
これは、「RSA Data Security, Inc. MD5 Message-Digest Algorithm.」です。
値を大文字に変換したい場合は、項11.8. 「キャスト関数と演算子」の BINARY 演算子のエントリで挙げられているバイナリストリングの変換に関する説明をご覧ください。
このセクション始めの MD5 アルゴリズムに関する注記をご覧ください。
OLD_PASSWORD(str)
セキュリティ向上のため、PASSWORD() の実装が変更された際に、OLD_PASSWORD() が MySQL に追加されました。OLD_PASSWORD() は PASSWORD() のバイナリストリングの旧 ( 4.1 の前 ) 実装の値を戻し、使用しているバージョンの 5.1 MySQL サーバに接続する必要のある 4.1 より前のクライアントが、自らを締め出すことなく、パスワードをリセットすることを許可することが目的です。詳細は項4.7.9. 「MySQL 4.1 のパスワードハッシュ」を参照してください。
PASSWORD(str)
平文のパスワード str からパスワードストリングを計算して戻し、バイナリストリングか、引数が NULL の場合は NULL を戻します。この関数を使用して、user 権限テーブルの Password カラムの格納の MySQL パスワードを暗号化します。
```
mysql> SELECT PASSWORD('badpwd');
        -> '*AAB3E285149C0135D51A520E1940DD3263DC008C'
```
PASSWORD() の暗号化は一方的なものです ( 可逆性はない ) 。
PASSWORD() の行うパスワードの暗号化は、Unix パスワードの暗号化とは異なります。ENCRYPT() を参照してください。
注記 :PASSWORD() 関数は、MySQL サーバの認証システムによって使用されます。独自にアプリケーションでは使用しないで ください。その代わりには、MD5() または SHA1() をお薦めします。また、RFC 2195, section 2 (Challenge-Response Authentication Mechanism (CRAM)) で、パスワードの扱いとアプリケーションの認証セキュリティーについての詳細をご覧ください。
SHA1(str), SHA(str)
ストリングの SHA-1 160 ビットのチェックサムを、RFC 3174 ( Secure Hash Algorithm ) で説明されているように計算します。その値は 40 16進数のバイナリストリングとして戻され、または引数が NULL の場合は NULL が戻されます。この関数の使用例のひとつとして、ハッシュキーとしての使用が考えられます。また、パスワードの保管のための暗号化関数としても使用できます。 SHA() は SHA1() と同義です。
```
mysql> SELECT SHA1('abc');
        -> 'a9993e364706816aba3e25717850c26c9cd0d89d'
```
SHA1() は、 MD5() と同等に、暗号化に関してはさらに安全であると考えられています。ただし、このセクション始めの MD5 と SHA-1 アルゴリズムに関する注記をご参照ください。
UNCOMPRESS(string_to_uncompress)
COMPRESS() 関数によって圧縮されたストリングを非圧縮します。引数が圧縮された値でない場合は、結果は NULL になります。この関数では、MySQL が zlib のような圧縮ライブラリとコンパイルされている必要があります。その条件が満たされない場合、その戻り値は常に NULL になります。
```
mysql> SELECT UNCOMPRESS(COMPRESS('any string'));
        -> 'any string'
mysql> SELECT UNCOMPRESS('any string');
        -> NULL
```
UNCOMPRESSED_LENGTH(compressed_string)
圧縮されたストリングの、圧縮前の長さを戻します。
```
mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT('a',30)));
        -> 30
```

11.10.3. 情報関数

BENCHMARK(count,expr)
BENCHMARK() 関数は、式 expr を count の回数だけ繰り返し実行します。MySQL がどれだけ素早く式を処理するかをこれで計ることも可能です。この結果値は常に 0 になります。この使用目的は、クエリの実行時間を報告する mysql クライアント内からです :
```
mysql> SELECT BENCHMARK(1000000,ENCODE('hello','goodbye'));
+----------------------------------------------+
| BENCHMARK(1000000,ENCODE('hello','goodbye')) |
+----------------------------------------------+
|                                            0 |
+----------------------------------------------+
1 row in set (4.74 sec)
```
報告された時間は、クライアント側の経過時間であり、サーバ側の CPU 時間ではありません。BENCHMARK() を複数回実行し、サーバコンピュータにどれだけ負担がかかっているかについて、結果を解釈することをお薦めします。

CHARSET(str)

ストリング引数の文字セットを戻します。

mysql> SELECT CHARSET('abc');
        -> 'latin1'
mysql> SELECT CHARSET(CONVERT('abc' USING utf8));
        -> 'utf8'
mysql> SELECT CHARSET(USER());
        -> 'utf8'

COERCIBILITY(str)

ストリング引数の照合型変換値を戻します。

mysql> SELECT COERCIBILITY('abc' COLLATE latin1_swedish_ci);
        -> 0
mysql> SELECT COERCIBILITY(USER());
        -> 3
mysql> SELECT COERCIBILITY('abc');
        -> 4

戻り値は下の表にあるような意味を持ちます。値が低いほど、優先順位は高くなります。

型変換属性	意味	例
`0`	明示的な照合	`COLLATE` 句との値
`1`	照合なし	異なる照合とのストリングの結合
`2`	暗示的な照合	カラム値、ストアドルーチンパラメータ、またはローカル変数
`3`	系統定数	`USER()` 戻り値
`4`	型変換可能	リテラルストリング
`5`	無視可能	`NULL` または `NULL` から引き出された式

COLLATION(str)

ストリング引数の照合を戻します。

mysql> SELECT COLLATION('abc');
        -> 'latin1_swedish_ci'
mysql> SELECT COLLATION(_utf8'abc');
        -> 'utf8_general_ci'

CONNECTION_ID()
接続のコネクション ID ( スレッド ID ) を戻します。すべての接続は、接続しているクライアントのセットの中で一意となる ID を持っています。
```
mysql> SELECT CONNECTION_ID();
        -> 23786
```
CURRENT_USER, CURRENT_USER()
現在のクライアントの認証にサーバが使用した MySQL アカウントの、ユーザ名とホスト名のコンビネーションを戻します。このアカウントは、開発者のアクセス特権を確認します。SQL SECURITY DEFINER 特徴で定義されたストアドルーチン内で、CURRENT_USER() はルーチンのクリエイターを戻します。戻り値は utf8 文字セット内のストリングです。
CURRENT_USER() の値は、USER() の値によって異なる場合があります。
```
mysql> SELECT USER();
        -> 'davida@localhost'
mysql> SELECT * FROM mysql.user;
ERROR 1044: Access denied for user ''@'localhost' to
database 'mysql'
mysql> SELECT CURRENT_USER();
        -> '@localhost'
```
この例は、クライアントが davida のユーザ名を指定 ( USER() の値で示されるように ) した場合でも、サーバは匿名のユーザアカウント ( CURRENT_USER() 値の空のユーザ名部分に見られるように ) を使用してクライアントを認証するということを示しています。これが起こるひとつの原因として、davida の権限テーブルにアカウントリストがないことが挙げられます。
DATABASE()
デフォルト ( 現行の ) データベース名を、utf8 文字セット内のストリングとして戻します。デフォルトのデータベースがない場合は、DATABASE() は NULL を戻します。ストアドルーチン内で、デフォルトのデータベースはルーチンが関連するデータベースですが、コーリングコンテキストのデフォルトのデータベースと同様である必要はありません。
```
mysql> SELECT DATABASE();
        -> 'test'
```
デフォルトのデータベースがない場合は、DATABASE() は NULL を戻します。
FOUND_ROWS()
SELECT 文は、サーバがクライアントに戻す行の数を制限するために、LIMIT 句を含んでいる場合があります。場合によっては、LIMIT なしでステートメントが返す行の数を知ることが望ましいですが、ステートメントを再度実行しないでください。この行のカウントを得るには、SELECT 文に SQL_CALC_FOUND_ROWS オプションを含み、その後に FOUND_ROWS() を実行します :
```
mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name
    -> WHERE id > 100 LIMIT 10;
mysql> SELECT FOUND_ROWS();
```
2 番目の SELECT は、最初の SELECT が返した、LIMIT 句なしで書かれた行数を示す数字を戻します。
最も最近の SELECT 文に SQL_CALC_FOUND_ROWS オプションがない場合、FOUND_ROWS() はその文によって戻された結果セットの行の数を戻します。
FOUND_ROWS() によって得られる行数は一過性のもので、SELECT SQL_CALC_FOUND_ROWS 文に続くステートメントを過ぎると取得できなくなるようになっています。この値を後で参照する必要がある場合は保存してください :
```
mysql> SELECT SQL_CALC_FOUND_ROWS * FROM ... ;
mysql> SET @rows = FOUND_ROWS();
```
SELECT SQL_CALC_FOUND_ROWS を使用している場合、MySQL は完全な結果セットにいくつ行があるか計算する必要があります。しかし、結果セットをクライアントに送る必要がないため、LIMIT なしでクエリを再度実行するより速く行えます。
SQL_CALC_FOUND_ROWS および FOUND_ROWS() は、クエリが戻す行の数を制限する際に便利ですが、クエリを再度実行することなく完全な結果セットの行の数を決定するためにも利用できます。検索結果の他のセクションを表示するページへのリンクを含む、ページ表示を提示するウェブスクリプトが例に挙げられます。FOUND_ROWS() を使用することで、残りの結果がさらに何ページを必要とするかを決定することができます。
SQL_CALC_FOUND_ROWS および FOUND_ROWS() の使用は、UNION の複数箇所で LIMIT が起こる場合があるため、簡単な SELECT 文よりも、UNION 文に対してのほうがより複雑になります。これは、UNION の個々の SELECT 文に用いられるか、または UNION 結果全体にグローバルに適用されます。
UNION に対する SQL_CALC_FOUND_ROWS の目的は、グローバルな LIMIT なしで返される行数を戻すことです。UNION との SQL_CALC_FOUND_ROWS の使用の条件は以下 :
- SQL_CALC_FOUND_ROWS キーワードが、UNION の最初の SELECT に表示されている。
- UNION ALL が使用されている場合のみ、FOUND_ROWS() の値は正確。ALL なしで UNION が使用される場合は、複製が除去され、FOUND_ROWS() の値は近似のみになる。
- UNION で LIMIT が提示されない場合、SQL_CALC_FOUND_ROWS は無視され、UNION を処理するために作成された一時テーブルの行の数を戻す。
LAST_INSERT_ID(), LAST_INSERT_ID(expr)
MySQL 5.1.12 以降では、LAST_INSERT_ID() ( 引数なし ) は、最も最近に実行された INSERT 文の結果として AUTO_INCREMENT カラムに正常に インサートされた、自動的に生成された最初の値を戻します。LAST_INSERT_ID() の値は、正常にインサートされた行がない場合は、未変更のままになります。
例えば、AUTO_INCREMENT 値を生成する行をインサートした後は、次のようにして値を得ることができます :
```
mysql> SELECT LAST_INSERT_ID();
        -> 195
```
MySQL 5.1.11 以前では、LAST_INSERT_ID() ( 引数なし ) は、行が正常にインサート、または更新された場合、自動低に生成された最初の値を戻します。つまり、戻された値は、テーブルに正常にインサートされなかった値である可能性があります。正常にインサートされた行がなければ、LAST_INSERT_ID() は 0 を戻します。
LAST_INSERT_ID() の値は、INSERT または UPDATE 文のすべての行が正常である場合、全バージョンにわたって一貫するでしょう。
実行中のステートメントが、LAST_INSERT_ID() の値に影響をおよぼすことはありません。ひとつのステートメントで AUTO_INCREMENT 値を生成し、その後、独自の AUTO_INCREMENT カラムで行をテーブルにインサートする複数行の INSERT 文で、LAST_INSERT_ID() を照会すると仮定します。LAST_INSERT_ID() の値は 2 番目のステートメントに安定したまま残ります。2 番目以降の行でのその値は、以前の行の挿入に影響されません。( しかし、LAST_INSERT_ID() と LAST_INSERT_ID(expr) への参照を混ぜると、その効果は未定義になります ) 。
以前のステートメントがエラーを戻した場合、LAST_INSERT_ID() は未定義になります。トランザクションテーブルでは、ステートメントがエラーによってロールバックされる場合、LAST_INSERT_ID() は未定義のまま残されます。手動の ROLLBACK では、LAST_INSERT_ID() の値はトランザクションの前に復元されず、ROLLBACK 時点と同じまま残ります。
ストアドルーチン ( プロシージャまたは関数 ) もしくはトリガのボディ内で、LAST_INSERT_ID() の値は、これらの種類のオブジェクトの外で実行されたステートメントと同様に変化します。後に続くステートメントに参照される LAST_INSERT_ID() の値に基づくストアドルーチンもしくはトリガの効果は、ルーチンの種類によって異なります :
- ストアドプロシージャが LAST_INSERT_ID() の値を変えるステートメントを実行する場合、変更された値はプロシージャ呼び出しに従うステートメントによって参照されます。
- 値を変更するストアドファンクションやトリガでは、値は関数やトリガが終了した時に復元され、続くステートメントは変更された値を参照しません。
生成された ID は、接続ベースで サーバ内で保持されます。つまり、関数によって指定のクライアントに戻された値は、そのクライアントによって AUTO_INCREMENT カラムに影響を及ぼす最も最近のステートメントのために生成された、最初の AUTO_INCREMENT 値です。この値は、他のクライアントが独自の AUTO_INCREMENT 値を生成した場合でも、他のクライアントによって影響を受けることはありません。この動作は、各クライアントが他のクライアントの動向を気にせず、ロックやトランザクションなしで、独自の ID を呼び出せるようにします。
行の AUTO_INCREMENT カラムを非「magic」値 ( NULL でも 0 でもない値 ) に設定する場合、LAST_INSERT_ID() の値は変更されません。
重要点 : 単一の INSERT 文を使用して複数の行をインサートする場合、LAST_INSERT_ID() は、最初の インサートされた行のみに対して生成された値を戻します。これは、他のサーバに対して同じ INSERT 文を簡単に再現できるようにするためです。
例 :
```
mysql> USE test;
Database changed
mysql> CREATE TABLE t (
    ->   id INT AUTO_INCREMENT NOT NULL PRIMARY KEY,
    ->   name VARCHAR(10) NOT NULL
    -> );
Query OK, 0 rows affected (0.09 sec)

mysql> INSERT INTO t VALUES (NULL, 'Bob');
Query OK, 1 row affected (0.01 sec)

mysql> SELECT * FROM t;
+----+------+
| id | name |
+----+------+
|  1 | Bob  |
+----+------+
1 row in set (0.01 sec)

mysql> SELECT LAST_INSERT_ID();
+------------------+
| LAST_INSERT_ID() |
+------------------+
|                1 |
+------------------+
1 row in set (0.00 sec)

mysql> INSERT INTO t VALUES
    -> (NULL, 'Mary'), (NULL, 'Jane'), (NULL, 'Lisa');
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT * FROM t;
+----+------+
| id | name |
+----+------+
|  1 | Bob  |
|  2 | Mary |
|  3 | Jane |
|  4 | Lisa |
+----+------+
4 rows in set (0.01 sec)

mysql> SELECT LAST_INSERT_ID();
+------------------+
| LAST_INSERT_ID() |
+------------------+
|                2 |
+------------------+
1 row in set (0.00 sec)
```
2 番目の INSERT 文が 3 つの新しい行を t にインサートしても、これらの行の 1 番目に生成された ID は 2 であり、次の SELECT 文に対して LAST_INSERT_ID() が返す値も同じです。
INSERT IGNORE を使用して行を無視する場合は、AUTO_INCREMENT カウンタは増分されず、行がインサートされなかったことを反映して、LAST_INSERT_ID() は 0 を戻します。
expr が LAST_INSERT_ID() への引数として与えられる場合、その引数の値は関数によって戻され、LAST_INSERT_ID() によって戻される次の値として記憶されます。これによってシークエンスのシミュレーションをすることも可能です :
1. テーブルを作成してシークエンスカウンタを保留にし、初期化 :
```
mysql> CREATE TABLE sequence (id INT NOT NULL);
mysql> INSERT INTO sequence VALUES (0);
```
2. テーブルを使用して、次のようにシークエンス番号を生成 :
```
mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1);
mysql> SELECT LAST_INSERT_ID();
```
  UPDATE 文はシークエンスカウンタを増分し、LAST_INSERT_ID() への次の呼び出しが更新された値を戻すようにします。SELECT 文はその値を引き出します。mysql_insert_id() C API 関数は、値の入手に使用することもできます。詳細は項23.2.3.37. 「mysql_insert_id()」を参照してください。
LAST_INSERT_ID() を呼び出さずにシークエンスを生成することはできますが、このように関数を使用することの利点は、ID 値が自動的に生成された最後の値として保持されることです。独自のシークエンス値を生成する他のクライアントと互いに影響しあうことなく、複数のクライアントが UPDATE 文を発行し、UPDATE 文 ( または mysql_insert_id() ) でそれぞれのシークエンス値を取得することができるため、マルチユーザでも安全です。
mysql_insert_id() は INSERT および UPDATE 文の後にのみ更新され、SELECT もしくは SET のような他の SQL 文を実行した後に、C API 関数を使用して LAST_INSERT_ID(expr) の値を引き出すことはできないのでご注意ください。

ROW_COUNT()

ROW_COUNT() は、先行するステートメントによって更新、インサート、または削除された行の数を戻します。これは mysql クライアントが表示する行のカウントおよび、mysql_affected_rows() C API 関数からの値と同じです。

mysql> INSERT INTO t VALUES(1),(2),(3);
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
|           3 |
+-------------+
1 row in set (0.00 sec)

mysql> DELETE FROM t WHERE i IN(1,2);
Query OK, 2 rows affected (0.00 sec)

mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
|           2 |
+-------------+
1 row in set (0.00 sec)

SCHEMA()
この関数は DATABASE() のシノニムです。
SESSION_USER()
SESSION_USER() は USER() のシノニムです。
SYSTEM_USER()
SYSTEM_USER() は USER() のシノニムです。
USER()
現行の MySQL ユーザ名とホスト名を、utf8 文字セット内のストリングとして戻します。
```
mysql> SELECT USER();
        -> 'davida@localhost'
```
その値はサーバへの接続時に指定したユーザ名と、接続したホストからのクライアントを示します。値は CURRENT_USER() によって異なる場合があります。
次のように、ユーザ名の部分だけを摘出することができます :
```
mysql> SELECT SUBSTRING_INDEX(USER(),'@',1);
        -> 'davida'
```
VERSION()
MySQL サーバのバージョンを示すストリングを戻します。そのストリングは、utf8 文字セットを使用します。
```
mysql> SELECT VERSION();
        -> '5.1.15-beta-standard'
```
-log で終わるバージョンストリングは、ロギングが有効になっていることを表しています。

11.10.4. その他の関数

DEFAULT(col_name)
テーブルカラムにデフォルト値を戻します。カラムがデフォルト値を持たない場合はエラーが発生します。
```
mysql> UPDATE t SET i = DEFAULT(i)+1 WHERE id < 100;
```
FORMAT(X,D)
数字 X を '#,###,###.##' のようにフォーマットし、D 少数位まで丸め、その結果をストリングとして戻します。詳細は、項11.3. 「文字列関数」をご覧ください。
GET_LOCK(str,timeout)
timeout 秒の待機時間を使用して、ストリング str によって与えられた名前でロックの獲得を試みます。ロックの獲得が成功した場合は 1 を戻し、試行が時間切れになった場合 ( 例えば、他のクライアントがすでにその名前をロックしている場合 ) は 0 を、または、エラーが発生 ( メモリの不足、または mysqladmin kill によるスレッドの停止 ) した場合は NULL を戻します。GET_LOCK() でロックを獲得した場合、RELEASE_LOCK() を実行した時、新しい GET_LOCK() を実行した時、または接続が切断された時 ( 正常または異常な終了を問わず ) にリリースされます。GET_LOCK() でロックを獲得した場合は、トランザクションと対話しないようにしてください。これは、トランザクションをコミットしても、トランザクション中に獲得されたそれらのロックはリリースされないためです。
この関数は、アプリケーションロックの実装、またはレコードロックのシミュレートに使用することができます。名前はサーバ全体に渡ってロックされます。ひとつのクライアントが名前をロックすると、GET_LOCK() が他のクライアントからの同じ名前の使用要求をブロックします。これによって、与えられたロック名を承認したクライアントが、名前を使用して協調任意型のロックを行うことができます。ただし同時に、協調するクライアントのセットにないクライアントも、過失にせよ故意にせよ、名前をロックすることができることになり、協調するクライアントがその名前を使用できなくなりますので注意してください。それを防ぐひとつの方法は、データベース固有、またはアプリケーション固有のロック名を使用することです。フォーム db_name.str または app_name.str のロック名を使用するのもその一例です。
```
mysql> SELECT GET_LOCK('lock1',10);
        -> 1
mysql> SELECT IS_FREE_LOCK('lock2');
        -> 1
mysql> SELECT GET_LOCK('lock2',10);
        -> 1
mysql> SELECT RELEASE_LOCK('lock2');
        -> 1
mysql> SELECT RELEASE_LOCK('lock1');
        -> NULL
```
2 番目の RELEASE_LOCK() 呼び出しは、ロック 'lock1' が 2 番目の GET_LOCK() 呼び出しによって自動的にリリースされるため、NULL を戻します。
注記 :ライアントが、他のクライアントによってすでに確保されたロックの獲得を試みると、timeout 引数によってそのクライアントはブロックされます。ブロックされたクライアントが停止する場合、そのスレッドはロックがタイムアウトを要求するまで停止しません。これは既知のバグです。
INET_ATON(expr)
ネットワークアドレスのドット形式のクワッド表示がストリングとして与えられ、アドレスの数値を示す整数を戻します。アドレスは 4 または 8 バイトのアドレスである可能性があります。
```
mysql> SELECT INET_ATON('209.207.224.40');
        -> 3520061480
```
生成される数字は常にネットワークバイト順になります。例えばこの例のように、数字は 209×256³ + 207×256² + 224×256 + 40 として計算されます。
また INET_ATON() は、短縮形式の IP アドレスを理解します :
```
mysql> SELECT INET_ATON('127.0.0.1'), INET_ATON('127.1');
        -> 2130706433, 2130706433
```
注記 :INET_ATON() によって記憶数値が生成される場合は、INT UNSIGNED カラムの使用を推奨します。( 符号付の ) INT カラムを使用すると、最初のオクテットが 127 以上である IP アドレスに対応する値は正しく保存されません。詳細は項10.2. 「数値タイプ」を参照してください。
INET_NTOA(expr)
数字のネットワークアドレス ( 4 または 8 バイト ) を与えられ、アドレスのドット形式のクワッド表示をストリングとして戻します。
```
mysql> SELECT INET_NTOA(3520061480);
        -> '209.207.224.40'
```
IS_FREE_LOCK(str)
str と名付けられたロックが使用可能か ( ロックされていないか ) 調べます。ロックが使用可能 ( まだ使用されていない ) 場合は 1 を、すでに使用されている場合は 0 を戻し、エラーが発生した場合 ( 引数が不正確、など ) は NULL を戻します。
IS_USED_LOCK(str)
str と名付けられたロックが使用されているか ( ロックされているか ) 調べます。ロックされている場合は、ロックを持っているクライアントの接続識別子を戻します。ロックされていない時は NULL を戻します。
MASTER_POS_WAIT(log_name,log_pos[,timeout])
この関数は、マスター / スレーブの同期化のコントロールに役立ちます。スレーブがマスターログで指定された位置まで読み取り、すべてのアップデートを適用するまでブロックします。戻り値は、指定の位置まで進むまでスレーブが待たなければいけないログイベントの数です。この関数は、スレーブ SQL スレッドが開始されていない、スレーブのマスター情報が初期化されていない、引数が正しくない、またはエラーが発生、という場合は NULL を戻します。タイムアウトの時間を越えると -1 が戻されます。MASTER_POS_WAIT() の待機中にスレーブ SQL スレッドが停止すると、関数は NULL を戻します。スレーブが指定の位置を過ぎたら、関数はただちに戻しを行います。
timeout 値が指定された場合、timeout の秒数を経過したのち MASTER_POS_WAIT() は待機をやめます。timeout は 0 より大きい数字でなければなりません。0 または負数の timeout では待機時間なしになります。
NAME_CONST(name,value)
与えられた値を戻します。結果セットのカラムの生成に使用された場合、NAME_CONST() が、カラムが与えられた名前を持つ原因になります。
```
mysql> SELECT NAME_CONST('myname', 14);
+--------+
| myname |
+--------+
|     14 |
+--------+
```
この関数は MySQL 5.0.12 から、内部使用のみの目的で追加されました。項17.4. 「ストアドルーチンとトリガのバイナリログ」で説明されているように、ローカルルーチン変数への参考を含むストアドルーチンからのステートメントを書く時にサーバが使用します。mysqlbinlog からの出力にこの関数が含まれる場合があります。
RELEASE_LOCK(str)
GET_LOCK() で獲得されたストリング str によって名付けられたロックをリリースします。ロックがリリースされた場合は 1 を、ロックがこのスレッドによって確立されていない場合 ( その場合ロックはリリースされません ) は 0 を、そして、名前付きのロックが存在しない場合は NULL を戻します。GET_LOCK() への呼び出しで獲得、またはすでにリリースされていない限り、ロックは存在しません。
DO 文は RELEASE_LOCK() との使用に便利です。詳細は項12.2.2. 「DO 構文」を参照してください。
SLEEP(duration)
duration 引数で指定され秒数間だけ休止 ( 一時停止 ) し、その後 0 を戻します。SLEEP() が妨げられた場合は 1 を戻します。継続時間はマイクロ秒で指定された少数部を持つが場合があります。
UUID()
1977 年 10 月に、The Open Group が発行した「DCE 1.1:Remote Procedure Call」 (Appendix A) CAE (Common Applications Environment) Specifications ( Document Number C706 、http://www.opengroup.org/public/pubs/catalog/c706.htm ) に基づいて生成された Universal Unique Identifier (UUID) を戻します。
UUID は、スペースおよび時間においてグローバルに一意の数字としてデザインされています。UUID() へのふたつの呼び出しは、互いに接続されていない別々のコンピュータ上で行った場合でも、それぞれ異なるふたつの値を生成することが想定されます。
A UUID is a 128-bit number represented by a string of five hexadecimal numbers in aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee format:
- 最初の 3 桁はタイムスタンプから生成されます。
- 4 番目の数字は、タイムスタンプ値が単調整を失う場合 ( 例えば、夏時間の影響などで ) に備えて、一時的な一意性を保ちます。
- 5 番目の数字は、スペースの一意性を提供する IEEE 802 ノード番号です。後者が利用できない場合 ( 例えば、ホストコンピュータが Ethernet カードを持たない、または使用のオペレーションシステムでインターフェイスのハードウェアアドレスを見つける方法が分からない、など ) 、ランダムな数字で代替されます。その場合、スペースの一意性は保証されません。しかしそれでも、不調和が起こる可能性は 非常に 低いと思われます。
  現在、インターフェイスの MAC アドレスは、FreeBSD と Linux でのみ考慮されています。他のオペレーションシステムでは、MySQL はランダムに生成された 48 ビットの数字を使用します。
```
mysql> SELECT UUID();
        -> '6ccd780c-baba-1026-9564-0040f4311e29'
```
UUID() はまだ複製との作業は不可能ですのでご注意ください。
VALUES(col_name)
INSERT ... ON DUPLICATE KEY UPDATE 文では、UPDATE 句の VALUES(col_name) 関数を使用して、ステートメントの INSERT 部分からのカラム値を参照することができます。つまり、UPDATE 句内の VALUES(col_name) は、複製キーとの衝突もなく、インサートされる col_name 値を参照するということです。この関数は複数行のインサートにおいて特に便利です。VALUES() 関数は、INSERT ... ON DUPLICATE KEY UPDATE 文においてのみ有用で、その他では NULL を戻します。項12.2.4.3. 「INSERT ... ON DUPLICATE KEY UPDATE 構文」参照。
```
mysql> INSERT INTO table (a,b,c) VALUES (1,2,3),(4,5,6)
    -> ON DUPLICATE KEY UPDATE c=VALUES(a)+VALUES(b);
```

11.11. `GROUP BY` 句との関数および修飾子の使用

11.11.1. GROUP BY ( 集約 ) 関数
11.11.2. GROUP BY 修飾子
11.11.3. 非常時フィールドとの GROUP BY および HAVING

11.11.1. `GROUP BY` ( 集約 ) 関数

このセクションでは、値のセットを演算するグループ ( 集約 ) 関数について説明します。特別に説明されていない限り、グループ関数は NULL 値を無視します。

GROUP BY 句を含まないステートメントでグループ関数を使用する場合、すべての行をグループ分けするのと同様の効果になります。

数値引数では、分散値と標準偏差関数が DOUBLE 値を戻します。SUM() および AVG() 関数は、高精度値引数 ( 整数または DECIMAL ) に対して DECIMAL 値を戻し、近似値引数 ( FLOAT または DOUBLE ) に対してDOUBLE 値を戻します。

SUM() および AVG() 集約関数は、一時値とはうまく作動しません。( 値を数字に変換し、最初の非数値文字の後のパートを失います ) 。この問題を回避するには、数値ユニットを変換し、集約演算を行い、一時値に変換しなおすという方法があります。例 :

SELECT SEC_TO_TIME(SUM(TIME_TO_SEC(time_col))) FROM tbl_name;
SELECT FROM_DAYS(SUM(TO_DAYS(date_col))) FROM tbl_name;

AVG([DISTINCT] expr)
expr の平均値を戻します。expr の固有値の平均を戻すのに、DISTINCT オプションを使用することができます。
一致する行がない場合、AVG() は NULL を戻します。
```
mysql> SELECT student_name, AVG(test_score)
    ->        FROM student
    ->        GROUP BY student_name;
```
BIT_AND(expr)
expr 内のすべてのビットの、ビット単位の AND を戻します。計算は 64 ビット ( BIGINT ) の精度で行われます。
この関数は、一致する行がない場合は、18446744073709551615 を戻します。( これは、すべてのビットが 1 に設定された、符号なしの BIGINT 値の値です。)
BIT_OR(expr)
expr 内のすべてのビットの、ビット単位の OR を戻します。計算は 64 ビット ( BIGINT ) の精度で行われます。
この関数は、一致する行がない場合は、0 を戻します。
BIT_XOR(expr)
expr 内のすべてのビットの、ビット単位の XOR を戻します。計算は 64 ビット ( BIGINT ) の精度で行われます。
この関数は、一致する行がない場合は、0 を戻します。
COUNT(expr)
SELECT 分によって引き出された行の、非 NULL 値の数を戻します。結果は BIGINT 値になります。
一致する行がない場合、COUNT() は 0 を戻します。
```
mysql> SELECT student.student_name,COUNT(*)
    ->        FROM student,course
    ->        WHERE student.student_id=course.student_id
    ->        GROUP BY student_name;
```
COUNT(*) は、NULL 値を含む含まざるに関わらず、引き出された行の数を戻すという点でやや異なります。
COUNT(*) は、SELECT がひとつのテーブルから検索し、他のカラムは引き出されず、また WHERE カラムがない場合、きわめて素早く戻すよう最適化されています。例 :
```
mysql> SELECT COUNT(*) FROM student;
```
この最適化は、正確な行の数がこの保存エンジンに保管されており、素早いアクセスが可能なため、MyISAM テーブルにのみ適用します。InnoDB をはじめとするトランザクション保存エンジンに関しては、正確な行の数を保存するのは、複数のトランザクションが起こって、それぞれが行の係数に影響をおよぼす場合があるため、より困難になります。
COUNT(DISTINCT expr,[expr...])
異なる非 NULL 値の数を戻します。
一致する行がない場合、COUNT(DISTINCT) は 0 を戻します。
```
mysql> SELECT COUNT(DISTINCT results) FROM student;
```
MySQL では、式のリストを提供することにより、NULL を含まない、異なる式のコンビネーションの数を得ることができます。標準 SQL では、COUNT(DISTINCT ...) 内で、すべての式の連結を行わなければなりません。
GROUP_CONCAT(expr)
この関数は、グループからの連結された非 NULL 値を伴うストリング結果を戻します。非 NULL 値がない場合は NULL を戻します。全構文は次の通りです :
```
GROUP_CONCAT([DISTINCT] expr [,expr ...]
             [ORDER BY {unsigned_integer | col_name | expr}
                 [ASC | DESC] [,col_name ...]]
             [SEPARATOR str_val])
```
```
mysql> SELECT student_name,
    ->     GROUP_CONCAT(test_score)
    ->     FROM student
    ->     GROUP BY student_name;
```
または :
```
mysql> SELECT student_name,
    ->     GROUP_CONCAT(DISTINCT test_score
    ->               ORDER BY test_score DESC SEPARATOR ' ')
    ->     FROM student
    ->     GROUP BY student_name;
```
MySQL では、式のコンビネーションの連結された値を得ることができます。DISTINCT を使用することで、重複した値を除くことが可能です。結果の値をソートしたい場合は、ORDER BY 句を使用してください。逆順でソートするには、DESC ( 降順 ) キーワードを、ORDER BY 句のソートするカラムの名前に加えてください。デフォルトでは昇順になっています。これは、ASC を使うことで明示的に指定することができます。SEPARATOR の後には、結果の値の間に挿入されるべきストリング値が続きます。デフォルトはコンマ ( ‘,’ ) です。SEPARATOR '' を使用すると、セパレータを一挙に取り除くことができます。
group_concat_max_len システム環境変数は、許可された最大の長さに設定することができます。 ( デフォルト値は 1024 ) 。ランタイムでこれを行う構文は次です。val は符号なしの整数になります :
```
SET [SESSION | GLOBAL] group_concat_max_len = val;
```
最大の長さが設定された場合、結果はその最大の長さに切り詰められます。
GROUP_CONCAT() によって戻されるタイプは、group_concat_max_len が 512 より大きい場合意外は常に VARCHAR になります。512 を越える場合は BLOB になります。
CONCAT() および CONCAT_WS() も併せてご覧ください : 項11.3. 「文字列関数」.
MIN([DISTINCT] expr), MAX([DISTINCT] expr)
expr の最小または最大値を戻します。MIN() および MAX() はストリングの引数を取る場合があります。その場合、それらは最小または最大のストリング値を戻します。項6.4.5. 「MySQLにおけるインデックスの使用」をご覧ください。DISTINCT キーワードで expr の固有の値の最小または最大を検出できますが、その場合、DISTINCT を省略した場合と同じ結果を生成します。
一致する行がない場合、MIN() および MAX() は NULL を戻します。
```
mysql> SELECT student_name, MIN(test_score), MAX(test_score)
    ->        FROM student
    ->        GROUP BY student_name;
```
MIN() 、MAX() 、および他の集約関数に関しては、MySQL は現在、ENUM と SET カラムを、セット内でのそれらのストリングの相対位置によってではなく、ストリング値によって比較しています。これは、ORDER BY がそれらをどう比較するかによって異なります。この点は、将来の MySQL リリースに反映される予定です。
STD(expr) STDDEV(expr)
expr の母標準偏差を戻します。これは標準 SQL へのエクステンションです。この関数の STDDEV() フォームは、Oracle との相互性のために提供されています。標準 SQL 関数 STDDEV_POP() を代わりに使用することも可能です。
これらの関数は、一致する行がない場合は、NULL を戻します。
STDDEV_POP(expr)
expr の母標準偏差 ( VAR_POP() の平方根 ) を戻します。STD() または STDDEV() を使用することもできます。これらは同等ですが標準 SQL ではありません。
一致する行がない場合、STDDEV_POP() は NULL を戻します。
STDDEV_SAMP(expr)
expr の試料標準偏差 ( VAR_SAMP() の平方根 ) を戻します。
一致する行がない場合、STDDEV_SAMP() は NULL を戻します。
SUM([DISTINCT] expr)
expr の集計を戻します。返しセットが行を持たない場合、SUM() は NULL を戻します。MySQL 5.1 で DISTINCT を使用して、expr の重複しない値のみを集計することができます。
一致する行がない場合、SUM() は NULL を戻します。
VAR_POP(expr)
expr の母標準分散を戻します。行をサンプルではなく全母集団としてとらえ、行の数を分母として得ます。また、VARIANCE() を使用することもできます。これは同等ですが標準 SQL ではありません。
一致する行がない場合、VAR_POP() は NULL を戻します。
VAR_SAMP(expr)
expr のサンプル分散を戻します。この分母は行の数から 1 をひいたものです。
一致する行がない場合、VAR_SAMP() は NULL を戻します。
VARIANCE(expr)
expr の母標準分散を戻します。これは標準 SQL へのエクステンションです。標準 SQL 関数 VAR_POP() を代わりに使用することも可能です。
一致する行がない場合、VARIANCE() は NULL を戻します。

11.11.2. `GROUP BY` 修飾子

GROUP BY 句は、要約出力に行を追加する WITH ROLLUP 修飾子を許可します。これらの行は、高レベル ( または超集約 ) の要約演算を表します。したがって ROLLUP は、複数レベルでの解析で質問に単一クエリで答えることを可能にします。これは、例えば、OLAP ( Online Analytical Processing ) 演算へのサポートに使用することができます。

Sales と名付けられたテーブルが、売り上げの収益性を記録するために、year 、country 、product 、そして profit のカラムを持つ場合 :

CREATE TABLE sales
(
    year    INT NOT NULL,
    country VARCHAR(20) NOT NULL,
    product VARCHAR(32) NOT NULL,
    profit  INT
);

テーブルのコンテンツを、次のように簡単な GROUP BY で年ごとに要約することができます :

mysql> SELECT year, SUM(profit) FROM sales GROUP BY year;
+------+-------------+
| year | SUM(profit) |
+------+-------------+
| 2000 |        4525 |
| 2001 |        3010 |
+------+-------------+

この出力は各年の収益合計を表示しますが、すべての年にわたる収益合計を確認したい場合は、各値を自分で合計するか、別のクエリを実行する必要があります。

または、単一クエリで両方のレベルの解析を提供する ROLLUP を使用することもできます。GROUP BY 句に WITH ROLLUP 修飾子を加えると、クエリがすべての年にわたる総合計の値を示す行を生成します :

mysql> SELECT year, SUM(profit) FROM sales GROUP BY year WITH ROLLUP;
+------+-------------+
| year | SUM(profit) |
+------+-------------+
| 2000 |        4525 |
| 2001 |        3010 |
| NULL |        7535 |
+------+-------------+

総合計の超集約ラインは、year カラムの値 NULL によって特定されます。

ROLLUP は、複数の GROUP BY カラムがある場合に、さらに複雑な効果をあらわします。この場合、「break」 ( 値の変更 ) が最後のグループ分けのカラムにある度に、クエリは追加の超集約要約行を生成します。

例えば、 ROLLUP なしの場合、year 、country 、そして product を基にした sales テーブルの要約はこのようになる場合があります :

mysql> SELECT year, country, product, SUM(profit)
    -> FROM sales
    -> GROUP BY year, country, product;
+------+---------+------------+-------------+
| year | country | product    | SUM(profit) |
+------+---------+------------+-------------+
| 2000 | Finland | Computer   |        1500 |
| 2000 | Finland | Phone      |         100 |
| 2000 | India   | Calculator |         150 |
| 2000 | India   | Computer   |        1200 |
| 2000 | USA     | Calculator |          75 |
| 2000 | USA     | Computer   |        1500 |
| 2001 | Finland | Phone      |          10 |
| 2001 | USA     | Calculator |          50 |
| 2001 | USA     | Computer   |        2700 |
| 2001 | USA     | TV         |         250 |
+------+---------+------------+-------------+

この出力は year/country/product レベルでのみの解析での要約値を示します。ROLLUP が加えられる時、クエリは複数の追加行を生成します :

mysql> SELECT year, country, product, SUM(profit)
    -> FROM sales
    -> GROUP BY year, country, product WITH ROLLUP;
+------+---------+------------+-------------+
| year | country | product    | SUM(profit) |
+------+---------+------------+-------------+
| 2000 | Finland | Computer   |        1500 |
| 2000 | Finland | Phone      |         100 |
| 2000 | Finland | NULL       |        1600 |
| 2000 | India   | Calculator |         150 |
| 2000 | India   | Computer   |        1200 |
| 2000 | India   | NULL       |        1350 |
| 2000 | USA     | Calculator |          75 |
| 2000 | USA     | Computer   |        1500 |
| 2000 | USA     | NULL       |        1575 |
| 2000 | NULL    | NULL       |        4525 |
| 2001 | Finland | Phone      |          10 |
| 2001 | Finland | NULL       |          10 |
| 2001 | USA     | Calculator |          50 |
| 2001 | USA     | Computer   |        2700 |
| 2001 | USA     | TV         |         250 |
| 2001 | USA     | NULL       |        3000 |
| 2001 | NULL    | NULL       |        3010 |
| NULL | NULL    | NULL       |        7535 |
+------+---------+------------+-------------+

このクエリでは、ROLLUP 句を加えると、ひとつでなく、よっつの解析のレベルでの要約情報が出力に含まれます。以下が ROLLUP 出力の解釈方法です :

指定の year と country に対する product 行の各セットに続き、追加の要約行がすべての product の合計を示して生成されます。これらの行は NULL に対して product カラムセットを備えています。
指定の year に対する product 行の各セットに続き、追加の要約行がすべての country と product の合計を示して生成されます。これらの行は NULL に対して country および products カラムセットを備えています。
そして最後に、他のすべての行に続き、追加の要約行がすべての year 、country 、および product の総合系を示して生成されます。この行は NULL に対して year 、country および products カラムセットを備えています。

ROLLUP を使用する際のその他の注意

次の項目は、ROLLUP の MySQL 実装特定の動作をリストしたものです :

ROLLUP を使用する場合、ORDER BY 句を同時に使用して結果をソートすることはできません。つまり、ROLLUP と ORDER BY は互いに排し合うということになります。しかし、ソートの順番をいくらかコントロールすることは可能です。MySQL の GROUP BY が結果をソートし、そして明示的な ASC および DESC キーワードを GROUP BY 内で名付けられたカラムと使用し、各カラムのソート順を指定することができます。( しかし、ROLLUP によって加えられた高レベルな要約行は、ソート順に関わらず、それらが計算された行の後に現れます。)

LIMIT はクライアントに戻される行の数を限定するのに使用できます。LIMIT は ROLLUP の後に適用され、それによって ROLLUP によって追加された行に対しての制限が適用されます。例 :

mysql> SELECT year, country, product, SUM(profit)
    -> FROM sales
    -> GROUP BY year, country, product WITH ROLLUP
    -> LIMIT 5;
+------+---------+------------+-------------+
| year | country | product    | SUM(profit) |
+------+---------+------------+-------------+
| 2000 | Finland | Computer   |        1500 |
| 2000 | Finland | Phone      |         100 |
| 2000 | Finland | NULL       |        1600 |
| 2000 | India   | Calculator |         150 |
| 2000 | India   | Computer   |        1200 |
+------+---------+------------+-------------+

LIMIT を ROLLUP と使用すると、超集約行を理解するにはコンテキストが少ないため、より解釈が難しい結果を生成する場合があります。

各超集約行の NULL 指示子は、行がクライアントに送られた時に生成されます。サーバは、GROUP BY 句で名付けられたカラムを、変更値を持つ左側のものに続いて調査します。それらの名前に語彙がマッチした名称を持つ、結果セット内のすべてのカラムには、その値が NULL に設定されます。( カラム番号によってグループ分けのカラムを指定する場合、サーバは番号によってどのカラムを NULL に設定するかを確認します。)

超集約行の NULL 値は、クエリの処理の非常に遅い時点で結果セットに配置されるため、それらをクエリそのものの中で NULL 値としてテストすることはできません。例えば、クエリに HAVING product IS NULL を追加して、超集約行以外のすべての出力から除くことはできません。

一方、NULL 値はクライアント側には NULL として表れ、MySQL クライアントプログラミングインターフェイスのいずれかを使用してテストすることができます。

11.11.3. 非常時フィールドとの `GROUP BY` および `HAVING`

MySQL は GROUP BY の使用を拡張し、GROUP BY 句には現れない SELECT リストでの、超集約カラムまたは計算の使用を可能にします。この機能を利用して、不要なカラムのソートやグループ分けを避けることで、性能を改善することができます。例えば、次のクエリでは、customer.name のグループ分けをする必要がありません :

SELECT order.custid, customer.name, MAX(payments)
  FROM order,customer
  WHERE order.custid = customer.custid
  GROUP BY order.custid;

標準 SQL では、GROUP BY 句に customer.name を加える必要があります。MySQL では、この名前は二重化しています。

GROUP BY 部から省略したカラムがグループ内で一定していない場合は、この機能を 使用しないで ください。サーバはいかなる値もグループから自由に戻すことができ、すべての値が同じでない限り、結果は不確定です。

同様の MySQL 拡張機能が HAVING 句に適用されます。SQL の基準では、GROUP BY 句で検出されないカラムで、集約関数で囲まれていないものを、 HAVING 句で名付けることはできません。MySQL では、それらのカラムで計算を簡易化することができます。この拡張は、グループ分けされていないカラムが、同じグループに関する値を持っていることを前提としています。それ以外では、結果は不確実になります。

ONLY_FULL_GROUP_BY SQL モードが有効になっている場合、GROUP BY への MySQL 拡張は適用されません。これは、GROUP BY 句で名付けられていないカラムは、集約関数で使用されていない場合、SELECT リスト、または HAVING 句で利用することができません。

選択リストの拡張も、ORDER BY に適用できます。つまり、GROUP BY 句に表れない ORDER BY 句の非集約カラムまたは計算を使用することができます。この拡張は、ONLY_FULL_GROUP_BY SQL モードが有効になっている時は適用しません。

いくつかのケースでは、MIN() および MAX() を使用して、ユニークなもの意外でも特定のカラム値を取得することができます。次の例は、sort カラムでの最小値を含む行からの column の値を与えます :

SUBSTR(MIN(CONCAT(RPAD(sort,6,' '),column)),7)

The Rows Holding the Group-wise Maximum of a Certain Field 参照。

標準 SQL に準じる場合は、GROUP BY 句で式を使用することはできないのでご注意ください。式にエイリアスを使用することで、この制限を回避することが可能です :

SELECT id,FLOOR(value/100) AS val
  FROM tbl_name
  GROUP BY id, val;

MySQL は GROUP BY 句での式の使用を許可していません。例 :

SELECT id,FLOOR(value/100)
  FROM tbl_name
  GROUP BY id, FLOOR(value/100);

前のページ?	?	?次のページ
第10章データタイプ?	ホーム	?第12章 SQL ステートメント構文

文字	説明
`%`	0 からあらゆる数の文字でもマッチする。
`_`	ひとつの文字を明確にマッチする。

ストリング	説明
`\%`	‘`%`’ 文字をひとつマッチする。
`\_`	‘`_`’ 文字をひとつマッチする。