標準 SQL の集計関数

集計関数は、一連の値に対して計算を実行する関数です。集計関数には、COUNTMINMAX などがあります。

SELECT COUNT(*) as total_count, COUNT(fruit) as non_null_count,
       MIN(fruit) as min, MAX(fruit) as max
FROM (SELECT NULL as fruit UNION ALL
      SELECT "apple" as fruit UNION ALL
      SELECT "pear" as fruit UNION ALL
      SELECT "orange" as fruit)

+-------------+----------------+-------+------+
| total_count | non_null_count | min   | max  |
+-------------+----------------+-------+------+
| 4           | 3              | apple | pear |
+-------------+----------------+-------+------+

以降のセクションで、BigQuery でサポートされている集計関数について説明します。

ANY_VALUE

ANY_VALUE(expression)  [OVER (...)]

説明

入力値から任意の値を返します。入力行がない場合は、NULL を返します。返される値は変動する可能性があります。つまり、この関数を使用するたびに異なる結果を受け取る可能性があります。

サポートされる引数の型

すべて

省略可能な句

OVER: ウィンドウを指定します。分析関数をご覧ください。

返されるデータ型

入力データ型と一致します。

SELECT ANY_VALUE(fruit) as any_value
FROM UNNEST(["apple", "banana", "pear"]) as fruit;

+-----------+
| any_value |
+-----------+
| apple     |
+-----------+
SELECT
  fruit,
  ANY_VALUE(fruit) OVER (ORDER BY LENGTH(fruit) ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS any_value
FROM UNNEST(["apple", "banana", "pear"]) as fruit;

+--------+-----------+
| fruit  | any_value |
+--------+-----------+
| pear   | pear      |
| apple  | pear      |
| banana | apple     |
+--------+-----------+

ARRAY_AGG

ARRAY_AGG([DISTINCT] expression [{IGNORE|RESPECT} NULLS]
          [ORDER BY key [{ASC|DESC}] [, ... ]]  [LIMIT n])
[OVER (...)]

説明

expression 値の配列を返します。

サポートされる引数の型

ARRAY を除くすべてのデータ型。

省略可能な句

次の順番で句が適用されます。

  1. OVER: ウィンドウを指定します。分析関数をご覧ください。この句は現在、ARRAY_AGG() 内の他の句と互換性がありません。

  2. DISTINCT: expression の重複を除いた値を集約して結果を返します。

  3. IGNORE NULLS または RESPECT NULLS: IGNORE NULLS を指定すると、結果から NULL 値が除外されます。RESPECT NULLS を指定した場合あるいは両方とも指定しない場合、結果に NULL 値が含まれます。ただし、最終的なクエリ結果の配列に NULL 要素が含まれる場合にはエラーが発生します。

  4. ORDER BY: 値の順序を指定します。

    • それぞれの並べ替えキーで、デフォルトの並べ替え方向は ASC になります。
    • NULL: ORDER BY 句のコンテキストの場合、NULL が最小の可能値です。つまり、NULL は ASC の並べ替えでは先頭になり、DESC の並べ替えでは最後になります。
    • 浮動小数点データ型の場合の順序とグループ化については、浮動小数点のセマンティクスをご覧ください。
    • DISTINCT も指定する場合には、並べ替えキーは expression と同じにする必要があります。
    • ORDER BY を指定しないと、出力配列内の要素の順序は変わる可能性があります。つまり、この関数を使用するたびに、異なる結果を受け取る可能性があります。
  5. LIMIT: 結果の expression 入力の最大数を指定します。制限 n は INT64 型の定数にする必要があります。

返されるデータ型

ARRAY

ゼロ入力行がある場合、この関数は NULL を返します。

SELECT FORMAT("%T", ARRAY_AGG(x)) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+-------------------------+
| array_agg               |
+-------------------------+
| [2, 1, -2, 3, -2, 1, 2] |
+-------------------------+
SELECT FORMAT("%T", ARRAY_AGG(DISTINCT x)) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+---------------+
| array_agg     |
+---------------+
| [2, 1, -2, 3] |
+---------------+
SELECT FORMAT("%T", ARRAY_AGG(x IGNORE NULLS)) AS array_agg
FROM UNNEST([NULL, 1, -2, 3, -2, 1, NULL]) AS x;

+-------------------+
| array_agg         |
+-------------------+
| [1, -2, 3, -2, 1] |
+-------------------+
SELECT FORMAT("%T", ARRAY_AGG(x ORDER BY ABS(x))) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+-------------------------+
| array_agg               |
+-------------------------+
| [1, 1, 2, -2, -2, 2, 3] |
+-------------------------+
SELECT FORMAT("%T", ARRAY_AGG(x LIMIT 5)) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+-------------------+
| array_agg         |
+-------------------+
| [2, 1, -2, 3, -2] |
+-------------------+
SELECT FORMAT("%T", ARRAY_AGG(DISTINCT x IGNORE NULLS ORDER BY x LIMIT 2)) AS array_agg
FROM UNNEST([NULL, 1, -2, 3, -2, 1, NULL]) AS x;

+-----------+
| array_agg |
+-----------+
| [-2, 1]   |
+-----------+
SELECT
  x,
  FORMAT("%T", ARRAY_AGG(x) OVER (ORDER BY ABS(x))) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+----+-------------------------+
| x  | array_agg               |
+----+-------------------------+
| 1  | [1, 1]                  |
| 1  | [1, 1]                  |
| 2  | [1, 1, 2, -2, -2, 2]    |
| -2 | [1, 1, 2, -2, -2, 2]    |
| -2 | [1, 1, 2, -2, -2, 2]    |
| 2  | [1, 1, 2, -2, -2, 2]    |
| 3  | [1, 1, 2, -2, -2, 2, 3] |
+----+-------------------------+

ARRAY_CONCAT_AGG

ARRAY_CONCAT_AGG(expression  [ORDER BY key [{ASC|DESC}] [, ... ]]  [LIMIT n])

説明

ARRAY 型の expression から要素を結合し、結果として単一の ARRAY を返します。この関数は NULL 入力配列を無視しますが、NULL 以外の入力配列に含まれる NULL 要素は無視しません。ただし、クエリの最終結果の配列に NULL 要素が含まれていると、エラーが発生します。

サポートされる引数の型

ARRAY

省略可能な句

次の順番で句が適用されます。

  1. ORDER BY: 値の順序を指定します。

    • それぞれの並べ替えキーで、デフォルトの並べ替え方向は ASC になります。
    • 配列の順序指定には対応していません。並べ替えキーを expression と同じにすることはできません。
    • NULL: ORDER BY 句のコンテキストの場合、NULL が最小の可能値です。つまり、NULL は ASC の並べ替えでは先頭になり、DESC の並べ替えでは最後になります。
    • 浮動小数点データ型の場合の順序とグループ化については、浮動小数点のセマンティクスをご覧ください。
    • ORDER BY を指定しないと、出力配列内の要素の順序は変わる可能性があります。つまり、この関数を使用するたびに、異なる結果を受け取る可能性があります。
  2. LIMIT: 結果の expression 入力の最大数を指定します。この制限は、入力配列の数に適用されます。配列内の要素数には適用されません。空の配列は 1 とカウントされます。NULL 配列はカウントされません。制限 n は INT64 型の定数にする必要があります。

返されるデータ型

ARRAY

ゼロ入力行がある場合に NULL を返すか、expression によってすべての行が NULL と評価されます。

SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x)) AS array_concat_agg FROM (
  SELECT [NULL, 1, 2, 3, 4] AS x
  UNION ALL SELECT NULL
  UNION ALL SELECT [5, 6]
  UNION ALL SELECT [7, 8, 9]
);

+-----------------------------------+
| array_concat_agg                  |
+-----------------------------------+
| [NULL, 1, 2, 3, 4, 5, 6, 7, 8, 9] |
+-----------------------------------+
SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x ORDER BY ARRAY_LENGTH(x))) AS array_concat_agg FROM (
  SELECT [1, 2, 3, 4] AS x
  UNION ALL SELECT [5, 6]
  UNION ALL SELECT [7, 8, 9]
);

+-----------------------------------+
| array_concat_agg                  |
+-----------------------------------+
| [5, 6, 7, 8, 9, 1, 2, 3, 4]       |
+-----------------------------------+
SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x LIMIT 2)) AS array_concat_agg FROM (
  SELECT [1, 2, 3, 4] AS x
  UNION ALL SELECT [5, 6]
  UNION ALL SELECT [7, 8, 9]
);

+--------------------------+
| array_concat_agg         |
+--------------------------+
| [1, 2, 3, 4, 5, 6]       |
+--------------------------+
SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x ORDER BY ARRAY_LENGTH(x) LIMIT 2)) AS array_concat_agg FROM (
  SELECT [1, 2, 3, 4] AS x
  UNION ALL SELECT [5, 6]
  UNION ALL SELECT [7, 8, 9]
);

+------------------+
| array_concat_agg |
+------------------+
| [5, 6, 7, 8, 9]  |
+------------------+

AVG

AVG([DISTINCT] expression)  [OVER (...)]

説明

NULL 以外の値の平均を返すか、入力に NaN が含まれる場合は NaN を返します。

サポートされる引数の型

INT64 のような、任意の数値入力型。浮動小数点入力型の場合、戻り値の結果は変動する可能性があります、つまり、この関数を使用するたびに異なる結果を受け取る可能性があります。

省略可能な句

次の順番で句が適用されます。

  1. OVER: ウィンドウを指定します。分析関数をご覧ください。この句は現在、AVG() 内の他の句と互換性がありません。

  2. DISTINCT: expression の重複を除いた値を集約して結果を返します。

返されるデータ型

  • 入力型が NUMERIC の場合は NUMERIC。
  • FLOAT64

SELECT AVG(x) as avg
FROM UNNEST([0, 2, 4, 4, 5]) as x;

+-----+
| avg |
+-----+
| 3   |
+-----+
SELECT AVG(DISTINCT x) AS avg
FROM UNNEST([0, 2, 4, 4, 5]) AS x;

+------+
| avg  |
+------+
| 2.75 |
+------+
SELECT
  x,
  AVG(x) OVER (ORDER BY x ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS avg
FROM UNNEST([0, 2, NULL, 4, 4, 5]) AS x;

+------+------+
| x    | avg  |
+------+------+
| NULL | NULL |
| 0    | 0    |
| 2    | 1    |
| 4    | 3    |
| 4    | 4    |
| 5    | 4.5  |
+------+------+

BIT_AND

BIT_AND(expression)

説明

expression でビット積演算を実行し、結果を返します。

サポートされる引数の型

  • INT64

返されるデータ型

INT64

SELECT BIT_AND(x) as bit_and FROM UNNEST([0xF001, 0x00A1]) as x;

+---------+
| bit_and |
+---------+
| 1       |
+---------+

BIT_OR

BIT_OR(expression)

説明

expression に対してビット論理和演算を実行し、結果を返します。

サポートされる引数の型

  • INT64

返されるデータ型

INT64

SELECT BIT_OR(x) as bit_or FROM UNNEST([0xF001, 0x00A1]) as x;

+--------+
| bit_or |
+--------+
| 61601  |
+--------+

BIT_XOR

BIT_XOR([DISTINCT] expression)

説明

expression でビット排他論理和演算を実行し、結果を返します。

サポートされる引数の型

  • INT64

省略可能な句

DISTINCT: expression で重複した値を除いて結果を返します。

返されるデータ型

INT64

SELECT BIT_XOR(x) AS bit_xor FROM UNNEST([5678, 1234]) AS x;

+---------+
| bit_xor |
+---------+
| 4860    |
+---------+
SELECT BIT_XOR(x) AS bit_xor FROM UNNEST([1234, 5678, 1234]) AS x;

+---------+
| bit_xor |
+---------+
| 5678    |
+---------+
SELECT BIT_XOR(DISTINCT x) AS bit_xor FROM UNNEST([1234, 5678, 1234]) AS x;

+---------+
| bit_xor |
+---------+
| 4860    |
+---------+

COUNT

1. COUNT(*) [OVER (...)]

2. COUNT([DISTINCT] expression) [OVER (...)]

説明

  1. 入力内の行数を返します。
  2. expressionNULL 以外の値と評価された行数を返します。

サポートされる引数の型

expression には、任意のデータ型を指定できます。

省略可能な句

次の順番で句が適用されます。

  1. OVER: ウィンドウを指定します。分析関数をご覧ください。

  2. DISTINCT: expression の重複を除いた値を集約して結果を返します。

戻りデータの型

INT64

SELECT
  COUNT(*) AS count_star,
  COUNT(DISTINCT x) AS count_dist_x
FROM UNNEST([1, 4, 4, 5]) AS x;

+------------+--------------+
| count_star | count_dist_x |
+------------+--------------+
| 4          | 3            |
+------------+--------------+
SELECT
  x,
  COUNT(*) OVER (PARTITION BY MOD(x, 3)) AS count_star,
  COUNT(DISTINCT x) OVER (PARTITION BY MOD(x, 3)) AS count_dist_x
FROM UNNEST([1, 4, 4, 5]) AS x;

+------+------------+--------------+
| x    | count_star | count_dist_x |
+------+------------+--------------+
| 1    | 3          | 2            |
| 4    | 3          | 2            |
| 4    | 3          | 2            |
| 5    | 1          | 1            |
+------+------------+--------------+
SELECT
  x,
  COUNT(*) OVER (PARTITION BY MOD(x, 3)) AS count_star,
  COUNT(x) OVER (PARTITION BY MOD(x, 3)) AS count_x
FROM UNNEST([1, 4, NULL, 4, 5]) AS x;

+------+------------+---------+
| x    | count_star | count_x |
+------+------------+---------+
| NULL | 1          | 0       |
| 1    | 3          | 3       |
| 4    | 3          | 3       |
| 4    | 3          | 3       |
| 5    | 1          | 1       |
+------+------------+---------+

COUNTIF

COUNTIF(expression)  [OVER (...)]

説明

expression に対する TRUE の値の数を返します。ゼロ入力行がある場合に 0 を返すか、expression によってすべての行が FALSE と評価されます。

サポートされる引数の型

BOOL

省略可能な句

OVER: ウィンドウを指定します。分析関数をご覧ください。

戻りデータの型

INT64

SELECT COUNTIF(x<0) AS num_negative, COUNTIF(x>0) AS num_positive
FROM UNNEST([5, -2, 3, 6, -10, -7, 4, 0]) AS x;

+--------------+--------------+
| num_negative | num_positive |
+--------------+--------------+
| 3            | 4            |
+--------------+--------------+
SELECT
  x,
  COUNTIF(x<0) OVER (ORDER BY ABS(x) ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS num_negative
FROM UNNEST([5, -2, 3, 6, -10, NULL, -7, 4, 0]) AS x;

+------+--------------+
| x    | num_negative |
+------+--------------+
| NULL | 0            |
| 0    | 1            |
| -2   | 1            |
| 3    | 1            |
| 4    | 0            |
| 5    | 0            |
| 6    | 1            |
| -7   | 2            |
| -10  | 2            |
+------+--------------+

LOGICAL_AND

LOGICAL_AND(expression)

説明

すべての非 NULL 式の論理 AND を返します。ゼロ入力行がある場合は NULL を返すか、expression によってすべての行が NULL と評価されます。

サポートされる引数の型

BOOL

戻りデータの型

BOOL

SELECT LOGICAL_AND(x) AS logical_and FROM UNNEST([true, false, true]) AS x;

+-------------+
| logical_and |
+-------------+
| false       |
+-------------+

LOGICAL_OR

LOGICAL_OR(expression)

説明

すべての非 NULL 式の論理 OR を返します。ゼロ入力行がある場合は NULL を返すか、expression によってすべての行が NULL と評価されます。

サポートされる引数の型

BOOL

戻りデータの型

BOOL

SELECT LOGICAL_OR(x) AS logical_or FROM UNNEST([true, false, true]) AS x;

+------------+
| logical_or |
+------------+
| true       |
+------------+

MAX

MAX(expression)  [OVER (...)]

説明

NULL 式の最大値を返します。入力行がない場合、またはすべての行で expressionNULL に評価された場合は、NULL を返します。入力に NaN が含まれている場合、NaN を返します。

サポートされる引数の型

ARRAYSTRUCT を除くすべてのデータ型

省略可能な句

OVER: ウィンドウを指定します。分析関数をご覧ください。

戻りデータの型

入力値として使用されるデータ型と同じ型。

SELECT MAX(x) AS max
FROM UNNEST([8, 37, 4, 55]) AS x;

+-----+
| max |
+-----+
| 55  |
+-----+
SELECT x, MAX(x) OVER (PARTITION BY MOD(x, 2)) AS max
FROM UNNEST([8, NULL, 37, 4, NULL, 55]) AS x;

+------+------+
| x    | max  |
+------+------+
| NULL | NULL |
| NULL | NULL |
| 8    | 8    |
| 4    | 8    |
| 37   | 55   |
| 55   | 55   |
+------+------+

MIN

MIN(expression)  [OVER (...)]

説明

NULL 式の最小値を返します。ゼロ入力行がある場合は NULL を返すか、expression によってすべての行が NULL と評価されます。入力に NaN が含まれている場合、NaN を返します。

サポートされる引数の型

ARRAYSTRUCT を除くすべてのデータ型

省略可能な句

OVER: ウィンドウを指定します。分析関数をご覧ください。

戻りデータの型

入力値として使用されるデータ型と同じ型。

SELECT MIN(x) AS min
FROM UNNEST([8, 37, 4, 55]) AS x;

+-----+
| min |
+-----+
| 4   |
+-----+
SELECT x, MIN(x) OVER (PARTITION BY MOD(x, 2)) AS min
FROM UNNEST([8, NULL, 37, 4, NULL, 55]) AS x;

+------+------+
| x    | min  |
+------+------+
| NULL | NULL |
| NULL | NULL |
| 8    | 4    |
| 4    | 4    |
| 37   | 37   |
| 55   | 37   |
+------+------+

STRING_AGG

STRING_AGG([DISTINCT] expression [, delimiter]  [ORDER BY key [{ASC|DESC}] [, ... ]]  [LIMIT n])
[OVER (...)]

説明

非 NULL 値を結合して得られた値(STRING または BYTES のいずれか)を返します。

delimiter が指定された場合、連結された値はその区切り文字で区切られ、それ以外の場合は区切り文字としてカンマが使用されます。

サポートされる引数の型

STRING BYTES

省略可能な句

次の順番で句が適用されます。

  1. OVER: ウィンドウを指定します。分析関数をご覧ください。この句は現在、STRING_AGG() 内の他の句と互換性がありません。

  2. DISTINCT: expression の重複を除いた値を集約して結果を返します。

  3. ORDER BY: 値の順序を指定します。

    • それぞれの並べ替えキーで、デフォルトの並べ替え方向は ASC になります。
    • NULL: ORDER BY 句のコンテキストの場合、NULL が最小の可能値です。つまり、NULL は ASC の並べ替えでは先頭になり、DESC の並べ替えでは最後になります。
    • 浮動小数点データ型の場合の順序とグループ化については、浮動小数点のセマンティクスをご覧ください。
    • DISTINCT も指定する場合には、並べ替えキーは expression と同じにする必要があります。
    • ORDER BY を指定しないと、出力配列内の要素の順序は変わる可能性があります。つまり、この関数を使用するたびに、異なる結果を受け取る可能性があります。
  4. LIMIT: 結果の expression 入力の最大数を指定します。この制限は、入力文字列の数に適用されます。入力内の文字数またはバイト数には適用されません。空の文字列は 1 とカウントされます。NULL 文字列はカウントされません。制限 n は INT64 型の定数にする必要があります。

戻りデータの型

STRING BYTES

SELECT STRING_AGG(fruit) AS string_agg
FROM UNNEST(["apple", NULL, "pear", "banana", "pear"]) AS fruit;

+------------------------+
| string_agg             |
+------------------------+
| apple,pear,banana,pear |
+------------------------+
SELECT STRING_AGG(fruit, " & ") AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+------------------------------+
| string_agg                   |
+------------------------------+
| apple & pear & banana & pear |
+------------------------------+
SELECT STRING_AGG(DISTINCT fruit, " & ") AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+-----------------------+
| string_agg            |
+-----------------------+
| apple & pear & banana |
+-----------------------+
SELECT STRING_AGG(fruit, " & " ORDER BY LENGTH(fruit)) AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+------------------------------+
| string_agg                   |
+------------------------------+
| pear & pear & apple & banana |
+------------------------------+
SELECT STRING_AGG(fruit, " & " LIMIT 2) AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+--------------+
| string_agg   |
+--------------+
| apple & pear |
+--------------+
SELECT STRING_AGG(DISTINCT fruit, " & " ORDER BY fruit DESC LIMIT 2) AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+---------------+
| string_agg    |
+---------------+
| pear & banana |
+---------------+
SELECT
  fruit,
  STRING_AGG(fruit, " & ") OVER (ORDER BY LENGTH(fruit)) AS string_agg
FROM UNNEST(["apple", NULL, "pear", "banana", "pear"]) AS fruit;

+--------+------------------------------+
| fruit  | string_agg                   |
+--------+------------------------------+
| NULL   | NULL                         |
| pear   | pear & pear                  |
| pear   | pear & pear                  |
| apple  | pear & pear & apple          |
| banana | pear & pear & apple & banana |
+--------+------------------------------+

SUM

SUM([DISTINCT] expression)  [OVER (...)]

説明

非 NULL 値の合計を返します。

式が浮動小数点値である場合、合計は変動する可能性があります。つまり、この関数を使用するたびに異なる結果を受け取る可能性があります。

サポートされる引数の型

サポートされているすべての数値データ型。

省略可能な句

次の順番で句が適用されます。

  1. OVER: ウィンドウを指定します。分析関数をご覧ください。

  2. DISTINCT: expression の重複を除いた値を集約して結果を返します。

戻りデータの型

  • 入力が整数の場合、INT64 を返します。

  • 入力型が NUMERIC の場合、NUMERIC を返します。

  • 入力が浮動小数点値の場合、FLOAT64 を返します。

入力が NULL のみの場合、NULL を返します。

入力に Inf が含まれる場合、Inf を返します。

入力に -Inf が含まれる場合、-Inf を返します。

入力に NaN が含まれている場合、NaN を返します。

入力に Inf-Inf の組み合わせが含まれている場合、NaN を返します。

SELECT SUM(x) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+-----+
| sum |
+-----+
| 25  |
+-----+
SELECT SUM(DISTINCT x) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+-----+
| sum |
+-----+
| 15  |
+-----+
SELECT
  x,
  SUM(x) OVER (PARTITION BY MOD(x, 3)) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+---+-----+
| x | sum |
+---+-----+
| 3 | 6   |
| 3 | 6   |
| 1 | 10  |
| 4 | 10  |
| 4 | 10  |
| 1 | 10  |
| 2 | 9   |
| 5 | 9   |
| 2 | 9   |
+---+-----+
SELECT
  x,
  SUM(DISTINCT x) OVER (PARTITION BY MOD(x, 3)) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+---+-----+
| x | sum |
+---+-----+
| 3 | 3   |
| 3 | 3   |
| 1 | 5   |
| 4 | 5   |
| 4 | 5   |
| 1 | 5   |
| 2 | 7   |
| 5 | 7   |
| 2 | 7   |
+---+-----+
このページは役立ちましたか?評価をお願いいたします。

フィードバックを送信...

ご不明な点がありましたら、Google のサポートページをご覧ください。