

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# 数学関数
<a name="Math_functions-spark"></a>

このセクションでは、Spark SQL AWS Clean Rooms でサポートされている数学演算子と関数について説明します。

**Topics**
+ [数学演算子の記号](OPERATOR_SYMBOLS.md)
+ [ABS 関数](ABS.md)
+ [ACOS 関数](ACOS.md)
+ [ASIN 関数](ASIN.md)
+ [ATAN 関数](ATAN.md)
+ [ATAN2 関数](ATAN2.md)
+ [CBRT 関数](CBRT.md)
+ [CEILING (または CEIL）関数](CEILING_FLOOR.md)
+ [COS 関数](COS.md)
+ [COT 関数](COT.md)
+ [DEGREES 関数](DEGREES.md)
+ [DIV 関数](DIV.md)
+ [EXP 関数](EXP.md)
+ [FLOOR 関数](FLOOR.md)
+ [LN 関数](LN.md)
+ [LOG 関数](LOG.md)
+ [MOD 関数](MOD.md)
+ [PI 関数](PI.md)
+ [POWER 関数](POWER.md)
+ [RADIANS 関数](RADIANS.md)
+ [RAND 関数](RAND.md)
+ [RANDOM 関数](RANDOM.md)
+ [ROUND 関数](ROUND.md)
+ [SIGN 関数](SIGN.md)
+ [SIN 関数](SIN.md)
+ [SQRT 関数](SQRT.md)
+ [TRUNC 関数](TRUNC.md)

# 数学演算子の記号
<a name="OPERATOR_SYMBOLS"></a>

 次の表に、サポートされる数学演算子の一覧を示します。

## サポートされている演算子
<a name="OPERATOR_SYMBOLS-supported-operators"></a>

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/clean-rooms/latest/sql-reference/OPERATOR_SYMBOLS.html)

## 例
<a name="OPERATOR_SYMBOLS-examples"></a>

特定の取引において支払われたコミッションに手数料 2.00 USD を加算します。

```
select commission, (commission + 2.00) as comm
from sales where salesid=10000;

commission | comm
-----------+-------
28.05      | 30.05
(1 row)
```

特定の取引において販売価格の 20% を計算します。

```
select pricepaid, (pricepaid * .20) as twentypct
from sales where salesid=10000;

pricepaid | twentypct
----------+-----------
187.00    |    37.400
(1 row)
```

継続的な成長パターンに基づいてチケット販売数を予測します。次の例では、サブクエリによって、2008 年に販売されたチケット数が返されます。その結果に、10 年にわたって継続する成長率 5% が指数関数的に乗算されます。

```
select (select sum(qtysold) from sales, date
where sales.dateid=date.dateid and year=2008)
^ ((5::float/100)*10) as qty10years;

qty10years
------------------
587.664019657491
(1 row)
```

日付 ID が 2000 以上である販売の合計支払額および合計コミッションを求め、その後、合計支払額から合計コミッションを減算します。

```
select sum (pricepaid) as sum_price, dateid,
sum (commission) as sum_comm, (sum (pricepaid) - sum (commission)) as value
from sales where dateid >= 2000
group by dateid order by dateid limit 10;

 sum_price | dateid | sum_comm |   value
-----------+--------+----------+-----------
 364445.00 |   2044 | 54666.75 | 309778.25
 349344.00 |   2112 | 52401.60 | 296942.40
 343756.00 |   2124 | 51563.40 | 292192.60
 378595.00 |   2116 | 56789.25 | 321805.75
 328725.00 |   2080 | 49308.75 | 279416.25
 349554.00 |   2028 | 52433.10 | 297120.90
 249207.00 |   2164 | 37381.05 | 211825.95
 285202.00 |   2064 | 42780.30 | 242421.70
 320945.00 |   2012 | 48141.75 | 272803.25
 321096.00 |   2016 | 48164.40 | 272931.60
(10 rows)
```

# ABS 関数
<a name="ABS"></a>

 ABS は、数値の絶対値を計算します。この数値は、リテラルでも、数値に評価される式でも構いません。

## 構文
<a name="ABS-synopsis"></a>

```
ABS (number)
```

## 引数
<a name="ABS-arguments"></a>

 *number*   
数値、または数値に評価される式。SMALLINT、INTEGER、BIGINT、DECIMAL、FLOAT4、または FLOAT8 型にすることができます。

## 戻り型
<a name="ABS-return-type"></a>

ABS は、その引数と同じデータ型を返します。

## 例
<a name="ABS-examples"></a>

-38 の絶対数を計算する 

```
select abs (-38);
abs
-------
38
(1 row)
```

(14-76) の絶対数を計算する 

```
select abs (14-76);
abs
-------
62
(1 row)
```

# ACOS 関数
<a name="ACOS"></a>

ACOS は、数値のアークコサイン (逆余弦) を返す三角関数です。戻り値はラジアンで、`0`～`PI` の範囲内です。

## 構文
<a name="ACOS-synopsis"></a>

```
ACOS(number)
```

## 引数
<a name="ACOS-arguments"></a>

 *number*   
入力パラメータは `DOUBLE PRECISION` 数です。

## 戻り型
<a name="ACOS-return-type"></a>

`DOUBLE PRECISION`

## 例
<a name="ACOS-examples"></a>

`-1` のアークコサイン (逆余弦) を返すには、次の例を使用します。

```
SELECT ACOS(-1);

+-------------------+
|       acos        |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# ASIN 関数
<a name="ASIN"></a>

ASIN は、数値のアークサイン (逆正弦) を返す三角関数です。戻り値はラジアンで、`PI/2`～`-PI/2` の範囲内です。

## 構文
<a name="ASIN-synopsis"></a>

```
ASIN(number)
```

## 引数
<a name="ASIN-argument"></a>

 *number*   
入力パラメータは `DOUBLE PRECISION` 数です。

## 戻り型
<a name="ASIN-return-type"></a>

`DOUBLE PRECISION`

## 例
<a name="ASIN-examples"></a>

`1` のアークサイン (正弦) を返すには、次の例を使用します。

```
SELECT ASIN(1) AS halfpi;

+--------------------+
|       halfpi       |
+--------------------+
| 1.5707963267948966 |
+--------------------+
```

# ATAN 関数
<a name="ATAN"></a>

ATAN は、数値のアークタンジェント (逆正接) を返す三角関数です。戻り値はラジアンで、`-PI`～`PI` の範囲内です。

## 構文
<a name="ATAN-synopsis"></a>

```
ATAN(number)
```

## 引数
<a name="ATAN-argument"></a>

 *number*   
入力パラメータは `DOUBLE PRECISION` 数です。

## 戻り型
<a name="ATAN-return-type"></a>

`DOUBLE PRECISION`

## 例
<a name="ATAN-examples"></a>

`1` のアークタンジェント (逆正接) を返し、その値に 4 を乗算するには、次の例を使用します。

```
SELECT ATAN(1) * 4 AS pi;
            
+-------------------+
|        pi         |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# ATAN2 関数
<a name="ATAN2"></a>

ATAN2 は、一方の数値をもう一方の数値で除算した値のアークタンジェント (逆正接) を返す三角関数です。戻り値はラジアンで、`PI/2`～`-PI/2` の範囲内です。

## 構文
<a name="ATAN2-synopsis"></a>

```
ATAN2(number1, number2)
```

## 引数
<a name="ATAN2-arguments"></a>

 *number1*   
`DOUBLE PRECISION` 数。

 *number2*   
`DOUBLE PRECISION` 数。

## 戻り型
<a name="ATAN2-return-type"></a>

`DOUBLE PRECISION`

## 例
<a name="ATAN2-examples"></a>

`2/2` のアークタンジェント (逆正接) を返し、その値に 4 を乗算するには、次の例を使用します。

```
SELECT ATAN2(2,2) * 4 AS PI;

+-------------------+
|        pi         |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# CBRT 関数
<a name="CBRT"></a>

 CBRT 関数は、数値の立方根を計算する数学関数です。

## 構文
<a name="CBRT-synopsis"></a>

```
CBRT (number)
```

## 引数
<a name="CBRT-argument"></a>

CBRT は、引数として DOUBLE PRECISION 型の数値を取ります。

## 戻り型
<a name="CBRT-return-type"></a>

CBRT は DOUBLE PRECISION 型の数値を返します。

## 例
<a name="CBRT-examples"></a>

特定の取引において支払われたコミッションの立方根を計算します。

```
select cbrt(commission) from sales where salesid=10000;

cbrt
------------------
3.03839539048843
(1 row)
```

# CEILING (または CEIL）関数
<a name="CEILING_FLOOR"></a>

CEILING 関数または CEIL 関数は、数値を最も近い整数に切り上げるために使用します。([FLOOR 関数](FLOOR.md)は、数値を最も近い整数に切り下げます。) 

## 構文
<a name="CEILING_FLOOR-synopsis"></a>

```
CEIL | CEILING(number)
```

## 引数
<a name="CEILING_FLOOR-arguments"></a>

 *number*   
数値、または数値に評価される式。SMALLINT、INTEGER、BIGINT、DECIMAL、FLOAT4、または FLOAT8 型にすることができます。

## 戻り型
<a name="CEILING_FLOOR-return-type"></a>

CEILING および CEIL は、引数と同じデータ型を返します。

## 例
<a name="CEILING_FLOOR-example"></a>

特定の取引において支払われたコミッションの切り上げ値を計算します。

```
select ceiling(commission) from sales
where salesid=10000;

ceiling
---------
29
(1 row)
```

# COS 関数
<a name="COS"></a>

COS は、数値のコサイン (余弦) を返す三角関数です。戻り値はラジアンで、`-1` 以上 `1` 以下です。

## 構文
<a name="COS-synopsis"></a>

```
COS(double_precision)
```

## 引数
<a name="COS-argument"></a>

 *number*   
入力パラメータは倍精度の数値です。

## 戻り型
<a name="COS-return-type"></a>

COS 関数は、倍精度の数値を返します。

## 例
<a name="COS-examples"></a>

次の例は、0 のコサイン (余弦) を返します。

```
select cos(0);
cos
-----
1
(1 row)
```

次の例は、PI のコサイン (余弦) を返します。

```
select cos(pi());
cos
-----
-1
(1 row)
```

# COT 関数
<a name="COT"></a>

COT は、数値のコタンジェント (余接) を返す三角関数です。入力パラメータは 0 以外である必要があります。

## 構文
<a name="COT-synopsis"></a>

```
COT(number)
```

## 引数
<a name="COT-argument"></a>

 *number*   
入力パラメータは `DOUBLE PRECISION` 数です。

## 戻り型
<a name="COT-return-type"></a>

`DOUBLE PRECISION`

## 例
<a name="COT-examples"></a>

1 のコタンジェント (余接) を返すには、次の例を使用します。

```
SELECT COT(1);

+--------------------+
|        cot         |
+--------------------+
| 0.6420926159343306 |
+--------------------+
```

# DEGREES 関数
<a name="DEGREES"></a>

ラジアンで指定された角度を、その値に相当する度数に変換します。

## 構文
<a name="DEGREES-synopsis"></a>

```
DEGREES(number)
```

## 引数
<a name="DEGREES-argument"></a>

 *number*   
入力パラメータは `DOUBLE PRECISION` 数です。

## 戻り型
<a name="DEGREES-return-type"></a>

`DOUBLE PRECISION`

## 例
<a name="DEGREES-examples"></a>

0.5 ラジアンに相当する度数を返すには、次の例を使用します。

```
SELECT DEGREES(.5);

+-------------------+
|      degrees      |
+-------------------+
| 28.64788975654116 |
+-------------------+
```

PI ラジアンを度数に変換するには、次の例を使用します。

```
SELECT DEGREES(pi());

+---------+
| degrees |
+---------+
|     180 |
+---------+
```

# DIV 関数
<a name="DIV"></a>

DIV 演算子は、除算除算の積分部分を返します。

## 構文
<a name="DIV-syntax"></a>

```
dividend div divisor
```

## 引数
<a name="DIV-arguments"></a>

 *分配*   
数値または間隔に評価される式。

*除数*  
`dividend` が間隔の場合は一致する間隔タイプ、それ以外の場合は数値。

## 戻り型
<a name="DIV-returns"></a>

`BIGINT`

## 例
<a name="DIV-examples"></a>

次の例では、リステーブルから 2 つの列を選択します。各リスの一意の識別子を含む `id` 列と、年齢`calculated`列の整数除算を 2 で`age div 2`表す 列です。`age div 2` 計算は`age`列で整数除算を実行し、実質的に経過時間を最も近い偶数に切り下げます。たとえば、`age`列に 3、5、7、10 などの値が含まれている場合、`age div 2`列にはそれぞれ 1、2、3、5 の値が含まれます。

```
SELECT id, age div 2 FROM squirrels
```

このクエリは、年齢範囲に基づいてデータをグループ化または分析する必要があり、最も近い偶数に切り下げて年齢値を簡素化する場合に役立ちます。結果の出力は、`squirrels`テーブル内のリスごとに `id`と経過時間を 2 で割ったものになります。

# EXP 関数
<a name="EXP"></a>

EXP 関数では、数値式、または式の累乗で累乗された自然対数 `e` の基数に対して指数関数を実装します。EXP 関数は、[LN 関数](LN.md)の逆です。

## 構文
<a name="EXP-synopsis"></a>

```
EXP (expression)
```

## 引数
<a name="EXP-argument"></a>

 *expression*   
式のデータ型は INTEGER、DECIMAL、または DOUBLE PRECISION である必要があります。

## 戻り型
<a name="EXP-return-type"></a>

EXP は DOUBLE PRECISION 型の数値を返します。

## 例
<a name="EXP-example"></a>

EXP 関数は、継続的な成長パターンに基づいてチケット販売を予測するために使用します。次の例では、サブクエリによって、2008 年に販売されたチケット数が返されます。その結果に、10 年にわたって継続する成長率 7% を指定する EXP 関数の結果が乗算されます。

```
select (select sum(qtysold) from sales, date
where sales.dateid=date.dateid
and year=2008) * exp((7::float/100)*10) qty2018;

qty2018
------------------
695447.483772222
(1 row)
```

# FLOOR 関数
<a name="FLOOR"></a>

FLOOR 関数は、数値を次の整数に切り捨てます。

## 構文
<a name="FLOOR-synopsis"></a>

```
FLOOR (number)
```

## 引数
<a name="FLOOR-argument"></a>

 *number*   
数値、または数値に評価される式。SMALLINT、INTEGER、BIGINT、DECIMAL、FLOAT4、または FLOAT8 型にすることができます。

## 戻り型
<a name="FLOOR-return-type"></a>

FLOOR は、その引数と同じデータ型を返します。

## 例
<a name="FLOOR-example"></a>

この例では、FLOOR 関数を使用する前と後に特定の販売取引に対して支払われたコミッションの値を示します。

```
select commission from sales
where salesid=10000;

floor
-------
28.05
(1 row)

select floor(commission) from sales
where salesid=10000;

floor
-------
28
(1 row)
```

# LN 関数
<a name="LN"></a>

LN 関数は、入力パラメータの自然対数を返します。

## 構文
<a name="LN-synopsis"></a>

```
LN(expression)
```

## 引数
<a name="LN-argument"></a>

 *expression*   
関数の対象となる列または式。  
この関数は、式が AWS Clean Rooms ユーザーが作成したテーブル、または AWS Clean Rooms STL または STV システムテーブルを参照している場合、一部のデータ型にエラーを返します。
式の参照先がユーザー作成テーブルまたはシステムテーブルである場合、式のデータ型が以下のいずれかであるときに、エラーが発生します。  
+ BOOLEAN 
+ CHAR 
+ DATE 
+ DECIMAL または NUMERIC 
+ TIMESTAMP 
+ VARCHAR 
以下のデータ型の式は、ユーザー作成テーブルおよび STL または STV システムテーブルで、正常に実行されます。  
+ BIGINT 
+ DOUBLE PRECISION 
+ INTEGER 
+ REAL 
+ SMALLINT 

## 戻り型
<a name="LN-return-type"></a>

LN 関数は、式と同じ型を返します。

## 例
<a name="LN-example"></a>

次の例は、数値 2.718281828 の自然対数、または e を底とする対数を返します。

```
select ln(2.718281828);
ln
--------------------
0.9999999998311267
(1 row)
```

解は 1 の近似値になることに注意してください。

次の例は、USERS テーブル内の USERID 列の値の自然対数を返します。

```
select username, ln(userid) from users order by userid limit 10;

 username |        ln
----------+-------------------
 JSG99FHE |                 0
 PGL08LJI | 0.693147180559945
 IFT66TXU |  1.09861228866811
 XDZ38RDD |  1.38629436111989
 AEB55QTM |   1.6094379124341
 NDQ15VBM |  1.79175946922805
 OWY35QYB |  1.94591014905531
 AZG78YIP |  2.07944154167984
 MSD36KVR |  2.19722457733622
 WKW41AIW |  2.30258509299405
(10 rows)
```

# LOG 関数
<a name="LOG"></a>

`expr` で の対数を返します`base`。

## 構文
<a name="LOG-synopsis"></a>

```
LOG(base, expr)
```

## 引数
<a name="LOG-argument"></a>

 expr**   
この式は整数、10 進数、または浮動小数点数データ型である必要があります。

 *base*   
対数計算のベース。倍精度データ型の正の数 (1 と等しくない) である必要があります。

## 戻り型
<a name="LOG-return-type"></a>

LOG 関数は、倍精度の数値を返します。

## 例
<a name="LOG-example"></a>

次の例は、数値 100 の 10 を底とする対数を返します。

```
select log(10, 100);
--------
2
(1 row)
```

# MOD 関数
<a name="MOD"></a>

2 つの数値の余りを返します。*モジュロ*演算とも呼ばれます。結果を計算するには、最初のパラメータを 2 番目のパラメータで除算します。

## 構文
<a name="MOD-synopsis"></a>

```
MOD(number1, number2)
```

## 引数
<a name="MOD-arguments"></a>

 *number1*   
最初の入力パラメータは INTEGER 型、SMALLINT 型、BIGINT 型、または DECIMAL 型の数値です。一方のパラメータが DECIMAL 型である場合は、もう一方のパラメータも DECIMAL 型である必要があります。一方のパラメータが INTEGER である場合、もう一方のパラメータは INTEGER、SMALLINT、または BIGINT のいずれかにします。両方のパラメータを SMALLINT または BIGINT にすることもできますが、一方のパラメータが BIGINT である場合に、もう一方のパラメータを SMALLINT にすることはできません。

 *number2*   
2 番目のパラメータは INTEGER 型、SMALLINT 型、BIGINT 型、または DECIMAL 型の数値です。*number1* と同じデータ型ルールが *number2* に適用されます。

## 戻り型
<a name="MOD-return-type"></a>

有効な戻り型は DECIMAL、INT、SMALLINT、および BIGINT です。両方の入力パラメータが同じ型である場合、MOD 関数の戻り型は、入力パラメータと同じ数値型になります。ただし、一方の入力パラメータが INTEGER である場合は、戻り型も INTEGER になります。

## 使用に関する注意事項
<a name="MOD-usage-notes"></a>

*%* をモジュロ演算子として使用できます。

## 例
<a name="MOD-example"></a>

次の例は、ある数値を別の数値で除算したときの余りを返します。

```
SELECT MOD(10, 4);
               
 mod
------
 2
```

次の例は、小数の結果を返します。

```
SELECT MOD(10.5, 4);
               
 mod
------
 2.5
```

パラメータ値をキャストできます。

```
SELECT MOD(CAST(16.4 as integer), 5);
               
 mod
------
 1
```

最初のパラメータを 2 で割って偶数かどうかをチェックします。

```
SELECT mod(5,2) = 0 as is_even;
               
 is_even
--------
 false
```

*%* をモジュロ演算子として使用できます。

```
SELECT 11 % 4 as remainder;
               
 remainder
-----------
 3
```

次の例は、CATEGORY テーブル内の奇数カテゴリーの情報を返します。

```
select catid, catname
from category
where mod(catid,2)=1
order by 1,2;

 catid |  catname
-------+-----------
     1 | MLB
     3 | NFL
     5 | MLS
     7 | Plays
     9 | Pop
    11 | Classical

(6 rows)
```

# PI 関数
<a name="PI"></a>

pi 関数は、PI の値を小数第 14 位まで返します。

## 構文
<a name="PI-synopsis"></a>

```
PI()
```

## 戻り型
<a name="PI-return-type"></a>

`DOUBLE PRECISION`

## 例
<a name="PI-examples"></a>

pi の値を返すには、次の例を使用します。

```
SELECT PI();

+-------------------+
|        pi         |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# POWER 関数
<a name="POWER"></a>

 POWER 関数は指数関数であり、最初の数値式がべき乗の底、2 番目の数値式がべき乗の指数です。例えば、2 の 3 乗は `POWER(2,3)` と表され、結果は `8` になります。

## 構文
<a name="POWER-synopsis"></a>

```
{POWER(expression1, expression2)
```

## 引数
<a name="POWER-arguments"></a>

 *expression1*   
べき乗の底とする数値式。`INTEGER`、`DECIMAL`、または `FLOAT` データ型である必要があります。

 *expression2*   
*expression1* を底とするべき乗の指数。`INTEGER`、`DECIMAL`、または `FLOAT` データ型である必要があります。

## 戻り型
<a name="POWER-return-type"></a>

`DOUBLE PRECISION`

## 例
<a name="POWER-examples"></a>

```
SELECT (SELECT SUM(qtysold) FROM sales, date
WHERE sales.dateid=date.dateid
AND year=2008) * POW((1+7::FLOAT/100),10) qty2010;

+-------------------+
|      qty2010      |
+-------------------+
| 679353.7540885945 |
+-------------------+
```

# RADIANS 関数
<a name="RADIANS"></a>

RADIANS 関数は、角度 (度数) をそれに相当するラジアンに変換します。

## 構文
<a name="RADIANS-synopsis"></a>

```
RADIANS(number)
```

## 引数
<a name="RADIANS-argument"></a>

 *number*   
入力パラメータは `DOUBLE PRECISION` 数です。

## 戻り型
<a name="RADIANS-return-type"></a>

`DOUBLE PRECISION`

## 例
<a name="RADIANS-examples"></a>

180 度に相当するラジアンを返すには、次の例を使用します。

```
SELECT RADIANS(180);

+-------------------+
|      radians      |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# RAND 関数
<a name="RAND"></a>

RAND 関数は、0 から 1 までのランダムな浮動小数点数を生成します。RAND 関数は、呼び出されるたびに新しい乱数を生成します。

## 構文
<a name="RAND-syntax"></a>

```
RAND()
```

## 戻り型
<a name="RAND-return-type"></a>

RANDOM は DOUBLE を返します。

## 例
<a name="RAND-example"></a>

次の例では、`squirrels`テーブル内の行ごとに 0 から 1 までのランダムな浮動小数点数の列を生成します。結果の出力は、ランダムな 10 進値のリストを含む単一の列になり、リステーブルの行ごとに 1 つの値が含まれます。

```
SELECT rand() FROM squirrels
```

このタイプのクエリは、ランダムなイベントをシミュレートしたり、データ分析にランダム性を導入したりするなど、乱数を生成する必要がある場合に便利です。`squirrels` テーブルのコンテキストでは、各リスにランダムな値を割り当てて、さらなる処理や分析に使用できる場合があります。

# RANDOM 関数
<a name="RANDOM"></a>

RANDOM 関数は、0.0 (この値を含む) ～1.0 (この値は含まない) のランダム値を生成します。

## 構文
<a name="RANDOM-synopsis"></a>

```
RANDOM()
```

## 戻り型
<a name="RANDOM-return-type"></a>

RANDOM は DOUBLE PRECISION 型の数値を返します。

## 例
<a name="RANDOM-examples"></a>

1. 0～99 のランダム値を計算します。ランダムな数値が 0～1 である場合、このクエリは、0～100 のランダムな数値を生成します。

   ```
   select cast (random() * 100 as int);
   
   INTEGER
   ------
   24
   (1 row)
   ```

1. 10 個のアイテムの均一なランダムサンプルを取得します。

   ```
   select * 
   from sales
   order by random()
   limit 10;
   ```

   10 個のアイテムのランダムサンプルを取得しますが、料金に比例してアイテムを選択します。例えば、別の料金の 2 倍のアイテムは、クエリ結果に表示される可能性が 2 倍になります。

   ```
   select * 
   from sales
   order by log(1 - random()) / pricepaid
   limit 10;
   ```

1. 次の例では、SET コマンドを使用して SEED 値を設定します。これにより RANDOM が予測可能な順序で数値を生成します。

   まず、SEED 値を最初に設定せずに、3 つの整数の乱数を返します。

   ```
   select cast (random() * 100 as int);
   INTEGER
   ------
   6
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   68
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   56
   (1 row)
   ```

   次に、SEED 値を `.25` に設定して、さらに 3 つの整数の乱数を返します。

   ```
   set seed to .25;
   select cast (random() * 100 as int);
   INTEGER
   ------
   21
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   79
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   12
   (1 row)
   ```

   最後に、SEED 値を `.25` にリセットして、RANDOM が前の 3 つの呼び出しと同じ結果を返すことを確認します。

   ```
   set seed to .25;
   select cast (random() * 100 as int);
   INTEGER
   ------
   21
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   79
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   12
   (1 row)
   ```

# ROUND 関数
<a name="ROUND"></a>

ROUND 関数は、数値を四捨五入して、最も近い整数または 10 進数にします。

ROUND 関数にはオプションで、2 番目の引数として整数を指定できます。この整数は、四捨五入後の小数点以下または小数点以上の桁数を指定します。2 番目の引数を指定しない場合、関数は最も近い整数に四捨五入されます。2 番目の引数 *>n* が指定されている場合、関数は小数点以下 *n* 桁の精度で最も近い数値に四捨五入されます。

## 構文
<a name="ROUND-synopsis"></a>

```
ROUND (number [ , integer ] )
```

## 引数
<a name="ROUND-argument"></a>

 *number*   
数値、または数値に評価される式。DECIMAL または FLOAT8 type. AWS Clean Rooms can は、暗黙的な変換ルールに従って他のデータ型を変換できます。

*integer* (オプション)  
いずれかの方向で小数点以上または小数点以下の桁数を示す整数。

## 戻り型
<a name="ROUND-return-type"></a>

ROUND は、入力引数と同じ数値データ型を返します。

## 例
<a name="ROUND-examples"></a>

特定の取引において支払われたコミッションを四捨五入して、最も近い整数にします。

```
select commission, round(commission)
from sales where salesid=10000;

commission | round
-----------+-------
     28.05 |    28
(1 row)
```

特定の取引において支払われたコミッションを四捨五入して、小数点以下第 1 位までの数値にします。

```
select commission, round(commission, 1)
from sales where salesid=10000;

commission | round
-----------+-------
     28.05 |  28.1
(1 row)
```

上記と同じクエリで、小数点以上 1 桁 (つまり 1 の位) までの数値にします。

```
select commission, round(commission, -1)
from sales where salesid=10000;

commission | round
-----------+-------
     28.05 |    30
(1 row)
```

# SIGN 関数
<a name="SIGN"></a>

 SIGN 関数は、数の符号 (正または負) を返します。SIGN 関数の結果は、引数の符号を示す `1`、`-1`、または `0` です。

## 構文
<a name="SIGN-synopsis"></a>

```
SIGN (number)
```

## 引数
<a name="SIGN-argument"></a>

 *number*   
数値、または数値に評価される式。DECIMALor FLOAT8 type. AWS Clean Rooms can は、暗黙的な変換ルールに従って他のデータ型を変換できます。

## 戻り型
<a name="SIGN-return-type"></a>

SIGN は、入力引数と同じ数値データ型を返します。入力が DECIMAL の場合、出力は DECIMAL(1,0) になります。

## 例
<a name="SIGN-examples"></a>

SALES テーブルから、特定の取引において支払われたコミッションの符号を判別するには、次の例を使用します。

```
SELECT commission, SIGN(commission)
FROM sales WHERE salesid=10000;

+------------+------+
| commission | sign |
+------------+------+
|      28.05 |    1 |
+------------+------+
```

# SIN 関数
<a name="SIN"></a>

SIN は、数値のサイン (正弦) を返す三角関数です。戻り値は、`-1`～`1` です。

## 構文
<a name="SIN-synopsis"></a>

```
SIN(number)
```

## 引数
<a name="SIN-argument"></a>

 *number*   
ラジアン単位の `DOUBLE PRECISION` 数。

## 戻り型
<a name="SIN-return-type"></a>

`DOUBLE PRECISION` 

## 例
<a name="SIN-examples"></a>

`-PI` のサイン (正弦) を返すには、次の例を使用します。

```
SELECT SIN(-PI());

+-------------------------+
|           sin           |
+-------------------------+
| -0.00000000000000012246 |
+-------------------------+
```

# SQRT 関数
<a name="SQRT"></a>

 SQRT 関数は、数値の平方根を返します。平方根は、与えられた値を得るためにそれ自体を掛けた数値です。

## 構文
<a name="SQRT-synopsis"></a>

```
SQRT (expression)
```

## 引数
<a name="SQRT-argument"></a>

 *expression*   
この式は整数、10 進数、または浮動小数点数データ型である必要があります。式には関数を含めることができます。システムが暗黙的にタイプの変換を行う場合があります。

## 戻り型
<a name="SQRT-return-type"></a>

SQRT は DOUBLE PRECISION 型の数値を返します。

## 例
<a name="SQRT-examples"></a>

次の例では、数値の平方根を返します。

```
select sqrt(16);
               
sqrt
---------------
4
```

次の例では、暗黙的なタイプの変換を実行します。

```
select sqrt('16');
               
sqrt
---------------
4
```

次の例では、関数をネストしてより複雑なタスクを実行します。

```
select sqrt(round(16.4)); 

sqrt
---------------
4
```

次の例では、円のエリアを指定したときの半径の長さが得られます。例えば、エリアを平方インチで指定すると、半径をインチで計算します。サンプルのエリアは 20 です。

```
select sqrt(20/pi());
```

これにより 5.046265044040321 という値が返されます。

次の例では、SALES テーブルから COMMISSION 値の平方根を返します。COMMISSION 列は DECIMAL 型列です。この例は、より複雑な条件ロジックを含むクエリで関数を使用する方法を示しています。

```
select sqrt(commission)
from sales where salesid < 10 order by salesid;

sqrt
------------------
10.4498803820905
3.37638860322683
7.24568837309472
5.1234753829798
...
```

次のクエリでは、上記と同じ COMMISSION 値の四捨五入された平方根を返します。

```
select salesid, commission, round(sqrt(commission))
from sales where salesid < 10 order by salesid;

salesid | commission | round
--------+------------+-------
      1 |     109.20 |    10
      2 |      11.40 |     3
      3 |      52.50 |     7
      4 |      26.25 |     5
...
```

のサンプルデータの詳細については AWS Clean Rooms、[「サンプルデータベース](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html)」を参照してください。

# TRUNC 関数
<a name="TRUNC"></a>

TRUNC 関数は、数値を前の整数または小数に切り捨てます。

TRUNC 関数にはオプションで、2 番目の引数として整数を指定できます。この整数は、四捨五入後の小数点以下または小数点以上の桁数を指定します。2 番目の引数を指定しない場合、関数は最も近い整数に四捨五入されます。2 番目の引数 *>n* が指定されている場合、関数は小数点以下 *>n* 桁以上の精度で最も近い数値に四捨五入されます。この関数は、タイムスタンプも切り捨て、日付を返します。

## 構文
<a name="TRUNC-synopsis"></a>

```
TRUNC (number [ , integer ] |
timestamp )
```

## 引数
<a name="TRUNC-arguments"></a>

 *number*   
数値、または数値に評価される式。DECIMAL または FLOAT8 type. AWS Clean Rooms can は、暗黙的な変換ルールに従って他のデータ型を変換できます。

 *integer* (オプション)   
小数点以上または小数点以下の桁数を示す整数。この整数が指定されなかった場合は、数値が切り捨てられて整数になります。この整数が指定された場合は、数値が切り捨てられて、指定された桁数になります。

 *timestamp*   
この関数は、タイムスタンプから取得した日付も返します。(タイムスタンプの値 `00:00:00` を時刻として返すには、関数の結果をタイムスタンプにキャストします。) 

## 戻り型
<a name="TRUNC-return-type"></a>

TRUNC は、最初の入力引数と同じデータ型を返します。タイムスタンプの場合、TRUNC は日付を返します。

## 例
<a name="TRUNC-examples"></a>

特定の販売取引について支払われたコミッションを切り捨てます。

```
select commission, trunc(commission)
from sales where salesid=784;

commission | trunc
-----------+-------
    111.15 |   111

(1 row)
```

同じコミッション値を切り捨てて、小数点以下第 1 位までの数値にします。

```
select commission, trunc(commission,1)
from sales where salesid=784;

commission | trunc
-----------+-------
    111.15 | 111.1

(1 row)
```

コミッションを切り捨てますが、2 番目の引数に負の値が指定されています。`111.15` は切り捨てられて、`110`になります。

```
select commission, trunc(commission,-1)
from sales where salesid=784;

commission | trunc
-----------+-------
    111.15 |   110
(1 row)
```

SYSDATE 関数 (タイムスタンプを返す) の結果から日付部分を返します。

```
select sysdate;

timestamp
----------------------------
2011-07-21 10:32:38.248109
(1 row)

select trunc(sysdate);

trunc
------------
2011-07-21
(1 row)
```

TRUNC 関数を TIMESTAMP 列に適用します。戻り型は日付です。

```
select trunc(starttime) from event
order by eventid limit 1;

trunc
------------
2008-01-25
(1 row)
```