PostgreSQL徹底解説：ROUND関数で実現する小数点以下の精緻な端数処理

はじめに：データベースにおける数値の精度と丸めの重要性

データベースシステムにおいて、数値データは非常に重要な情報です。金額、数量、測定値、統計データなど、多岐にわたる情報が数値として格納され、日々のビジネスや研究活動において利用されています。これらの数値データを取り扱う際、特に小数点以下の値をどのように扱うかは、計算結果の正確性やデータの表示品質に直結する重要な課題となります。

実世界のデータはしばしば無限の精度を持つ場合がありますが、コンピューター上で扱える数値の精度には限界があります。また、ビジネス上の要件として、特定の桁数で数値を丸める（端数処理を行う）必要がある場面も頻繁に発生します。例えば、通貨計算における最小単位（円であれば整数、ドルであればセント）への丸め、パーセンテージの表示における小数点以下第何位までの表示、統計データにおける有効数字への丸めなどです。

PostgreSQLは、堅牢で高機能なリレーショナルデータベース管理システム（RDBMS）です。PostgreSQLは、多様な数値データ型を提供し、これらのデータ型に対する様々な数値演算関数を備えています。その中でも、数値の端数処理を行うための最も基本的で頻繁に使用される関数の一つが ROUND 関数です。

ROUND 関数は、指定された数値を最も近い値に丸めるために使用されます。小数点以下の特定の桁数で丸める機能を提供し、正確な計算結果を得るため、あるいはデータの表示形式を整えるために不可欠なツールです。しかし、ROUND 関数の動作、特に様々な数値型や桁数指定に対する振る舞いを完全に理解することは、意図しない結果や計算誤差を防ぐ上で非常に重要です。

この記事では、PostgreSQLの ROUND 関数について、その基本的な使い方から、引数の詳細、内部的な丸めルール、さらには他の端数処理関数との比較、パフォーマンスに関する考慮事項、そして浮動小数点数と固定小数点数（numeric 型）における動作の違いといった、深く掘り下げた内容までを徹底的に解説します。約5000語にわたる詳細な説明と豊富なコード例を通じて、読者の皆様がPostgreSQLにおける小数点以下の端数処理、特に ROUND 関数を完全にマスターし、日々のデータベース操作やアプリケーション開発に自信を持って活かせるようになることを目指します。

さあ、PostgreSQLの ROUND 関数の世界へ深く潜り込んでいきましょう。

ROUND関数の基本：構文と最も単純な使い方

PostgreSQLの ROUND 関数は、数値を指定した桁数で丸めるために使用されます。この関数には、主に二つの基本的な構文形式があります。

桁数を指定しない構文: ROUND(数値)
桁数を指定する構文: ROUND(数値, 桁数)

それぞれの構文について詳しく見ていきましょう。

1. 桁数を指定しない構文：`ROUND(数値)`

この形式では、ROUND 関数は指定された 数値 を最も近い整数に丸めます。小数点以下第1位の端数処理を行い、結果は整数になります。

構文:
sql ROUND(source_value)

source_value: 丸めの対象となる数値。任意の数値データ型のカラム名、リテラル値、または数値を返す式を指定できます。

動作:
source_value の小数点以下第1位（0.XのX）の数値が5以上の場合は切り上げ、5未満の場合は切り捨てが行われ、結果は整数（小数点以下を持たない数値）になります。

例:

“`sql
SELECT ROUND(123.45);
— 結果: 123 (小数点以下第1位が4なので切り捨て)

SELECT ROUND(123.56);
— 結果: 124 (小数点以下第1位が5なので切り上げ)

SELECT ROUND(123.0);
— 結果: 123 (もともと整数)

SELECT ROUND(-123.45);
— 結果: -123 (負の数の場合も同様。-123.45は-123に最も近い)

SELECT ROUND(-123.56);
— 結果: -124 (負の数の場合。-123.56は-124に最も近い)
“`

この最も単純な形式の ROUND 関数は、数値を最も近い整数に変換したい場合に便利です。特に、表示上の端数をなくしたい場合や、整数値としてデータを集計・格納したい場合などに使用されます。

2. 桁数を指定する構文：`ROUND(数値, 桁数)`

この形式は、ROUND 関数のより一般的な使い方であり、指定された 数値 を小数点以下または小数点より上の指定した 桁数 で丸めることができます。

構文:
sql ROUND(source_value, decimal_places)

source_value: 丸めの対象となる数値。
decimal_places: 丸めを行う小数点以下の桁数を指定する整数値。この値の意味については後ほど詳しく解説しますが、0以上の場合は小数点以下の桁数を、負の場合は小数点より左側の桁数を指定します。

動作:
source_value は、decimal_places で指定された桁数で最も近い値に丸められます。丸めは、指定された桁の次の位の数値に基づいて行われます。例えば、decimal_places が2の場合、小数点以下第3位の数値を見て丸めが行われます。次の位の数値が5以上の場合は指定桁の数値が切り上げられ、5未満の場合は切り捨てられます。

例:

“`sql
SELECT ROUND(123.4567, 2);
— 結果: 123.46 (小数点以下第3位が6なので、第2位が切り上げられる)

SELECT ROUND(123.4549, 2);
— 結果: 123.45 (小数点以下第3位が4なので、第2位はそのまま – 切り捨て)

SELECT ROUND(123.4, 2);
— 結果: 123.40 (指定桁数で表現。元の数値が短い場合も指定桁数で表示される傾向があるが、データ型による。numeric型の場合は精度が保たれる)

SELECT ROUND(123.4567, 0);
— 結果: 123 (桁数0は整数への丸め。小数点以下第1位が4なので切り捨て)

SELECT ROUND(123.5678, 0);
— 結果: 124 (桁数0は整数への丸め。小数点以下第1位が5なので切り上げ)

SELECT ROUND(123.4567, -1);
— 結果: 120 (桁数-1は10の位での丸め。1の位が3なので切り捨て)

SELECT ROUND(126.789, -1);
— 結果: 130 (桁数-1は10の位での丸め。1の位が6なので切り上げ)

SELECT ROUND(12345.67, -2);
— 結果: 12300 (桁数-2は100の位での丸め。10の位が4なので切り捨て)

SELECT ROUND(12356.78, -2);
— 結果: 12400 (桁数-2は100の位での丸め。10の位が5なので切り上げ)
“`

この形式が ROUND 関数の最も強力な使い方であり、小数点以下の特定桁数や、さらには小数点より左側の桁数での丸めを柔軟に行うことができます。decimal_places に0を指定すると、最初の構文（桁数指定なし）と同様に整数への丸めが行われます。これは、桁数指定なしの構文が ROUND(数値, 0) のショートカットであると考えることもできます。

基本を理解したところで、次に ROUND 関数の引数について、それぞれの詳細な仕様や注意点を見ていきましょう。これにより、様々なデータや要件に対して ROUND 関数を正確に適用するための基盤を固めます。

引数 `数値` の詳細：対応データ型と注意点

ROUND 関数の最初の引数である 数値 は、丸めの対象となる値です。PostgreSQLでは多様な数値データ型がサポートされており、ROUND 関数はこれらのほとんどに対して適用可能です。しかし、データ型によってはその振る舞いや潜在的な注意点が存在します。どのデータ型を ROUND 関数に渡すかによって、結果の型や計算の精度に違いが生じる可能性があります。

ROUND 関数が通常受け入れることができる数値データ型には以下のようなものがあります。

整数型: smallint, integer, bigint
浮動小数点数型: real (単精度浮動小数点数), double precision (倍精度浮動小数点数)
任意精度数値型: numeric, decimal

これらのデータ型に加え、PostgreSQLは必要に応じて型変換を行います。例えば、文字列で表現された数値（例: '123.45'::numeric）や、時間間隔型（interval）から抽出された数値部分なども、適切な型変換が可能であればROUND` 関数の引数として使用できることがあります。

整数型 (`smallint`, `integer`, `bigint`) を引数にした場合

整数型を ROUND 関数の引数として渡すことは構文上可能です。しかし、整数自体は小数点以下を持たないため、decimal_places が0以上の場合は、基本的に元の値がそのまま返されます。丸め処理が発生しないため、結果は元の整数型と同じか、またはより大きな整数型になります。

sql SELECT ROUND(123); -- 結果: 123 SELECT ROUND(123, 0); -- 結果: 123 SELECT ROUND(123, 2); -- 結果: 123 SELECT ROUND(123::bigint, 5); -- 結果: 123

ただし、decimal_places に負の数を指定した場合、小数点より左側の桁で丸めが行われるため、結果が変わる可能性があります。この場合、結果は指定された桁より下の位がゼロになった整数となります。

sql SELECT ROUND(123, -1); -- 結果: 120 (1の位の3を四捨五入) SELECT ROUND(126, -1); -- 結果: 130 (1の位の6を四捨五入) SELECT ROUND(12345, -2); -- 結果: 12300 (10の位の4を四捨五入) SELECT ROUND(12356::bigint, -2); -- 結果: 12400 (10の位の5を四捨五入)

整数型に対する負の桁数での丸めは、例えば概算値を表示したい場合などに便利です。

浮動小数点数型 (`real`, `double precision`) を引数にした場合

浮動小数点数型 (real および double precision) は、広い範囲の数値を表現するのに優れていますが、コンピュータの内部表現の性質上、正確な小数を表現できない場合があるという重要な特性を持っています。これは、多くの10進数の小数を、二進数の有限のビット数で正確に表現することが不可能なためです。この「浮動小数点数精度問題」は、計算結果にごくわずかな誤差を生じさせる可能性があり、それが ROUND 関数の結果に理論上影響を及ぼすことがあります。

例えば、0.1 + 0.2 の計算結果が、正確な 0.3 ではなく 0.30000000000000004 のようになることは広く知られています。このような誤差を含む値に対して ROUND 関数を適用した場合、丸めが行われるべき桁の次の位の値が、期待される「ちょうど5」からわずかにずれている可能性があり、それが丸めの結果に影響する、というシナリオが考えられます。

“`sql
— 例: 浮動小数点数の精度問題
SELECT 0.1 + 0.2; — 結果: 0.30000000000000004

— ROUND関数への影響 (PostgreSQLでは通常期待通りになるように工夫されているが、理論上の可能性)
— 例えば、本来 1.05 となる計算結果が、内部的に 1.0499999999999999 となった場合、
— ROUND(1.0499999999999999, 1) は、小数点以下第2位が4とみなされ、1.0 に丸められる可能性
— PostgreSQLのROUNDは、このような一般的なケースでの問題を回避するように設計されているため、
— 通常は ROUND(1.05::double precision, 1) -> 1.1 となります。
SELECT ROUND(1.05::double precision, 1); — 通常は 1.1
SELECT ROUND(1.0499999999999999::double precision, 1); — 結果は 1.0 になる可能性が高い
“`

PostgreSQLの ROUND 関数は、浮動小数点数を丸める際に、完全に厳密な二進数表現だけでなく、10進数表現における端数「5」が考慮されるように内部的に調整されていると言われています。このため、一般的な浮動小数点数型の値に対する ROUND は、多くのケースでユーザーの期待する四捨五入（端数5以上で切り上げ）として動作します。

しかし、極めて厳密な計算が要求される場合や、金融・会計分野のように小数点以下の精度が絶対的に保証される必要がある場面では、浮動小数点数型を使用することは避けるべきです。

浮動小数点数型を ROUND 関数に渡した場合、戻り値の型は通常 double precision 型になります。

任意精度数値型 (`numeric`, `decimal`) を引数にした場合

numeric 型およびその別名である decimal 型は、任意精度をサポートするデータ型です。この型は、数値を正確な10進数として表現し、計算における精度誤差を発生させません（ただし、表現できる桁数にはシステムや定義上の上限があります）。numeric 型は、特に金融、会計、科学技術計算など、厳密な精度が求められる分野で標準的に使用されます。

numeric 型を引数として ROUND 関数に渡した場合、丸めは常に正確な10進数表現に基づいて行われます。これにより、前述の浮動小数点数型で懸念されるような、内部的な誤差による丸めの不確実性は完全に排除されます。ROUND 関数の一般的な四捨五入ルール（端数5以上は切り上げ）は、numeric 型に対して最も信頼性の高い形で適用されます。

“`sql
SELECT ROUND(123.4567::numeric, 2); — 結果: 123.46
SELECT ROUND(123.455::numeric, 2); — 結果: 123.46 (numeric型なので、端数5は正確に切り上げ)
SELECT ROUND(123.445::numeric, 2); — 結果: 123.45 (numeric型なので、端数5は正確に切り上げ)

SELECT ROUND(12.5::numeric, 0); — 結果: 13
SELECT ROUND(11.5::numeric, 0); — 結果: 12

SELECT ROUND(12345.67::numeric, -2); — 結果: 12300
“`

numeric 型を引数にした場合、戻り値の型も通常 numeric 型になります。これにより、丸め処理後も高い精度を維持できます。特に理由がない限り、小数点以下の演算を伴う計算や、丸めが必要な数値データには numeric 型を使用するのが最も安全で推奨されるプラクティスです。

NULL値の取り扱い

ROUND 関数の 数値 引数に NULL が指定された場合、関数の結果は常に NULL になります。これは、PostgreSQLの多くの関数に共通するNULL伝播の動作です。decimal_places 引数がNULLの場合も同様です。

sql SELECT ROUND(NULL); -- 結果: NULL SELECT ROUND(NULL, 2); -- 結果: NULL SELECT ROUND(123.45, NULL); -- 結果: NULL SELECT ROUND(NULL, NULL); -- 結果: NULL

これは直感的であり、NULLを含むデータ行に対して ROUND を適用しても、結果がNULLになるだけで予期しないエラーは発生しません。

引数 `桁数` の詳細：小数点以下の桁数、整数部、そして負の値

ROUND(数値, 桁数) 構文における 桁数 引数は、丸めを行う小数点以下の位置を指定します。この引数は整数値であり、その値によって丸めの位置が大きく変わります。桁数 引数の最も柔軟で強力な点は、正の値、ゼロ、負の値のいずれも指定できることです。これにより、小数点以下の任意の桁数での丸めだけでなく、整数部の特定の位での丸めも可能になります。

正の値を `桁数` に指定した場合 (`decimal_places > 0`)

桁数 に正の整数を指定した場合、丸めは小数点以下のその桁数で行われます。例えば 桁数 が2であれば、小数点以下第2位で丸めが行われます。これは、小数点以下第3位の数値を見て、第2位を切り上げまたは切り捨てすることを意味します。結果として、指定された桁数までの小数点以下が表示されます（必要に応じて末尾にゼロが付加されることもあります）。

例:

“`sql
SELECT ROUND(123.45678, 1); — 小数点以下第1位で丸め (第2位の5を見て切り上げ)
— 結果: 123.5

SELECT ROUND(123.45678, 2); — 小数点以下第2位で丸め (第3位の6を見て切り上げ)
— 結果: 123.46

SELECT ROUND(123.45678, 3); — 小数点以下第3位で丸め (第4位の7を見て切り上げ)
— 結果: 123.457

SELECT ROUND(123.45678, 4); — 小数点以下第4位で丸め (第5位の8を見て切り上げ)
— 結果: 123.4568

SELECT ROUND(123.45678, 5); — 小数点以下第5位で丸め (第6位がない、またはゼロとみなしてそのまま)
— 結果: 123.45678

SELECT ROUND(123.4, 2); — 小数点以下第2位で丸め (第3位がない、またはゼロとみなしてそのまま)
— numeric型の場合は 123.40 となる（指定桁数まで表示）
— float8型の場合は 123.4 となることが多い

— 丸めの境界の例 (端数がちょうど5の場合)
SELECT ROUND(123.455, 2); — 小数点以下第2位で丸め (第3位の5を見て切り上げ)
— 結果: 123.46

SELECT ROUND(123.445, 2); — 小数点以下第2位で丸め (第3位の5を見て切り上げ)
— 結果: 123.45

SELECT ROUND(123.4549, 2); — 小数点以下第2位で丸め (第3位の4を見て切り捨て)
— 結果: 123.45
“`

正の値を指定するケースは、レポートや表示で小数点以下の桁数を統一したい場合、通貨計算の最小単位に合わせたい場合、統計データなどの表示精度を調整したい場合など、小数点以下の丸めが必要なシナリオで最も一般的に使用されます。

`桁数` にゼロを指定した場合 (`decimal_places = 0`)

桁数 に0を指定した場合、丸めは小数点以下第0位、つまり整数部で行われます。これは、小数点以下第1位の数値を見て、整数部を切り上げまたは切り捨てすることを意味します。この場合、結果は整数になります（ただし、戻り値のデータ型は元の数値型によっては小数点以下を持つ数値型になることもありますが、値としては整数になります）。

これは、ROUND(数値) (桁数指定なし) と同じ動作になります。

例:

“`sql
SELECT ROUND(123.45, 0); — 小数点以下第1位が4なので切り捨て
— 結果: 123

SELECT ROUND(123.56, 0); — 小数点以下第1位が5なので切り上げ
— 結果: 124

SELECT ROUND(-123.45, 0); — 小数点以下第1位が4なので切り捨て (負の数なので-123)
— 結果: -123

SELECT ROUND(-123.56, 0); — 小数点以下第1位が5なので切り上げ (負の数なので-124)
— 結果: -124

SELECT ROUND(12.5, 0); — 小数点以下第1位が5なので切り上げ
— 結果: 13

SELECT ROUND(11.5, 0); — 小数点以下第1位が5なので切り上げ
— 結果: 12

SELECT ROUND(-12.5, 0); — 小数点以下第1位が5なので切り上げ
— 結果: -13

SELECT ROUND(-11.5, 0); — 小数点以下第1位が5なので切り上げ
— 結果: -12
“`

整数への丸めは非常に頻繁に行われる処理であり、decimal_places = 0 はそのための明確な方法です。通貨の合計金額を円単位で表示する場合や、個数などの端数がないはずの値を計算で得た場合に整数に変換する場合などに使用されます。

負の値を `桁数` に指定した場合 (`decimal_places < 0`)

桁数 に負の整数を指定した場合、丸めは小数点より左側（整数部）の桁で行われます。これは、1の位、10の位、100の位といった整数部の特定の位で丸めを行うことを意味します。丸めの基準となるのは、指定された桁の「右隣」の位です。

桁数 = -1: 10の位で丸め（1の位を見て丸める）
桁数 = -2: 100の位で丸め（10の位を見て丸める）
桁数 = -3: 1000の位で丸め（100の位を見て丸める）
…といった具合になります。

結果として、指定された桁より下の位（小数点以下を含む）は全てゼロになります。

例:

“`sql
SELECT ROUND(123.45, -1); — 10の位で丸め (1の位の3を見て切り捨て)
— 結果: 120

SELECT ROUND(126.78, -1); — 10の位で丸め (1の位の6を見て切り上げ)
— 結果: 130

SELECT ROUND(125, -1); — 10の位で丸め (1の位の5を見て切り上げ)
— 結果: 130

SELECT ROUND(12345.67, -2); — 100の位で丸め (10の位の4を見て切り捨て)
— 結果: 12300

SELECT ROUND(12356.78, -2); — 100の位で丸め (10の位の5を見て切り上げ)
— 結果: 12400

SELECT ROUND(123456.78, -3); — 1000の位で丸め (100の位の4を見て切り捨て)
— 結果: 123000

SELECT ROUND(123567.89, -3); — 1000の位で丸め (100の位の5を見て切り上げ)
— 結果: 124000

SELECT ROUND(5, -1); — 10の位で丸め (1の位の5を見て切り上げ)
— 結果: 10

SELECT ROUND(4, -1); — 10の位で丸め (1の位の4を見て切り捨て)
— 結果: 0
“`

負の値を 桁数 に指定する機能は、例えば概算を示す場合（「約120人」「約12000円」など）や、数値の有効数字を調整したい場合などに役立ちます。また、科学技術計算などで特定の指数での表示に合わせたい場合にも応用可能です。

`桁数` 引数のデータ型とNULL値

桁数 引数は整数型（smallint, integer, bigint など）である必要があります。浮動小数点数や文字列など、他のデータ型を指定した場合、PostgreSQLは可能な限り整数型に暗黙的に型変換しようとします。変換できる数値の場合は小数点以下が切り捨てられて整数として扱われますが、変換できない文字列などの場合はエラーになります。明示的に整数定数を指定するのが最も安全であり、推奨される方法です。

“`sql
SELECT ROUND(123.45, 2.9::real); — 2.9は整数2に変換される
— 結果: 123.46

SELECT ROUND(123.45, ‘2’); — ‘2’は整数2に変換される
— 結果: 123.46

SELECT ROUND(123.45, ‘two’);
— エラー: invalid input syntax for type integer: “two”
“`

桁数 引数に NULL が指定された場合、数値 引数が NULL でない場合でも、関数の結果は NULL になります。

sql SELECT ROUND(123.45, NULL); -- 結果: NULL

`桁数` 引数の範囲

桁数 引数に指定できる値の理論上の範囲は、対象となる数値のデータ型やPostgreSQLの内部的な制約によって異なりますが、通常は非常に広い範囲の整数を指定できます。実用上は、対象となる数値の桁数プラスアルファの範囲で十分でしょう。

極端に大きな正の値や極端に小さな負の値を指定した場合、丸めが実際に行われる桁が数値の有効桁数の範囲を超えるため、結果が元の数値と全く変わらなくなるか、あるいはゼロになる可能性があります。例えば、非常に大きな正の 桁数 を指定すると、元の数値が持つ精度を超えるため、元の数値がそのまま（または末尾にゼロが付加されて）返されます。非常に小さな負の 桁数 を指定すると、最も左側の桁でも丸めが行われる結果、ゼロに丸められる可能性があります。通常の使用においては現実的な範囲の桁数を指定することがほとんどであり、この範囲を超える極端な値について深く心配する必要は少ないです。

ROUND関数の内部的な動作原理（四捨五入のルール）

PostgreSQLの ROUND 関数がどのように丸めを行っているのか、その内部的な動作原理、特に四捨五入のルールについて深く掘り下げてみましょう。これは、期待通りの結果を得るために非常に重要です。

多くのプログラミング言語やデータベースシステムで採用されている丸め方法には、いくつかの種類があります。代表的なものとしては、「四捨五入（Round half up）」と「最近接偶数への丸め（Round half to even, Banker’s Rounding）」があります。

四捨五入 (Round half up): 丸めを行う桁の次の位の数値が5以上であれば切り上げ、5未満であれば切り捨てを行います。これが私たちが学校で一般的に習う四捨五入のルールであり、多くの人にとって最も直感的です。
最近接偶数への丸め (Banker’s Rounding): 端数が0.5ちょうどの場合、丸められる対象の桁が偶数になるように丸めます。端数が0.5より大きい場合は切り上げ、0.5より小さい場合は切り捨てを行います。例えば、1.5 は 2 に丸められますが、2.5 は 2 に丸められます。これは、多数の数値を丸める際に、意図しない方向への統計的な偏りを減らす目的で使用されます。

PostgreSQLの ROUND 関数は、一般的な四捨五入（Round half up）を採用しています。 つまり、丸めを行う桁の次の位の数値が5以上であれば常に切り上げ（指定された桁の数値が一つ増える）、5未満であれば常に切り捨て（指定された桁の数値はそのまま）が行われます。端数がちょうど5である場合も、常に切り上げが行われます。

このルールは、浮動小数点数型と numeric 型の両方に適用されますが、前述の通り浮動小数点数型では内部表現の精度限界により、意図した通りに端数がちょうど5にならない可能性がゼロではないという点に注意が必要です。しかし、PostgreSQLは一般的な浮動小数点数の問題に対してある程度の対策を施しており、多くのケースで期待通りの四捨五入が行われます。特に numeric 型においては、常にこのルールが正確に適用されます。

一般的な四捨五入の具体例

指定された桁数の次の位の数値が判断の基準となります。丸められる「桁」とは、ROUND(数値, n) の場合の小数点以下第n位（nが負の場合は小数点より左側の第|n|位）のことです。判断の基準となる「次の位」とは、小数点以下第n+1位（nが負の場合は小数点より左側の第|n|-1位）のことです。

例1: 小数点以下第2位での丸め (桁数 = 2)

ROUND(123.456, 2): 丸められる桁は小数点以下第2位（5）。判断基準は次の位、小数点以下第3位の 6 です。6は5以上なので、第2位の 5 を切り上げます。結果は 123.46 です。
ROUND(123.454, 2): 丸められる桁は小数点以下第2位（5）。判断基準は次の位、小数点以下第3位の 4 です。4は5未満なので、第2位の 5 はそのまま（切り捨て）です。結果は 123.45 です。

例2: 小数点以下第0位（整数）での丸め (桁数 = 0)

ROUND(123.5, 0): 丸められる桁は1の位（3）。判断基準は次の位、小数点以下第1位の 5 です。5は5以上なので、1の位の 3 を切り上げます。結果は 124 です。
ROUND(123.4, 0): 丸められる桁は1の位（3）。判断基準は次の位、小数点以下第1位の 4 です。4は5未満なので、1の位の 3 はそのまま（切り捨て）です。結果は 123 です。

例3: 端数がちょうど0.5の場合 (桁数 = 2 で第3位が5, 桁数 = 0 で第1位が5)

PostgreSQLの ROUND は、端数がちょうど5の場合も切り上げを行います。これは「最近接偶数への丸め」とは異なる重要な点です。

ROUND(123.455, 2): 丸められる桁は小数点以下第2位（5）。判断基準は小数点以下第3位の 5 です。5は5以上なので、第2位の 5 を切り上げます。結果は 123.46 です。
ROUND(123.445, 2): 丸められる桁は小数点以下第2位（4）。判断基準は小数点以下第3位の 5 です。5は5以上なので、第2位の 4 を切り上げます。結果は 123.45 です。
ROUND(12.5, 0): 丸められる桁は1の位（2）。判断基準は小数点以下第1位の 5 です。5は5以上なので、1の位の 2 を切り上げます。結果は 13 です。
ROUND(11.5, 0): 丸められる桁は1の位（1）。判断基準は小数点以下第1位の 5 です。5は5以上なので、1の位の 1 を切り上げます。結果は 12 です。

このように、対象の桁が偶数であろうと奇数であろうと、次の位が5であれば常に切り上げられます。

負の数に対する丸め

負の数に対しても、一般的な四捨五入のルールが適用されます。負の数は絶対値で考え、丸め方向を考慮する必要があります。数直線をイメージすると、正の数の場合はゼロから遠ざかる方向への丸めが切り上げ、ゼロに近づく方向への丸めが切り捨てになりますが、負の数の場合はその逆になります。切り上げはゼロから遠ざかる方向（より小さな値へ）、切り捨てはゼロに近づく方向（より大きな値へ）になります。しかし、PostgreSQLの ROUND は「最も近い値」への丸めとして実装されており、その際の基準は「次の位が5以上なら」切り上げ（絶対値を大きくする方向へ進む）となります。

ROUND(-123.456, 2): 対象の桁は小数点以下第2位（-5）。判断基準は小数点以下第3位の 6。6は5以上なので、絶対値を大きくする方向へ丸めます。-123.45から絶対値を大きくすると-123.46になります。結果は -123.46 です。
ROUND(-123.454, 2): 対象の桁は小数点以下第2位（-5）。判断基準は小数点以下第3位の 4。4は5未満なので、絶対値はそのままです。結果は -123.45 です。
ROUND(-123.5, 0): 対象の桁は1の位（-3）。判断基準は小数点以下第1位の 5。5は5以上なので、絶対値を大きくする方向へ丸めます。-123から絶対値を大きくすると-124になります。結果は -124 です。
ROUND(-123.4, 0): 対象の桁は1の位（-3）。判断基準は小数点以下第1位の 4。4は5未満なので、絶対値はそのままです。結果は -123 です。
ROUND(-125, -1): 対象の桁は10の位（-2）。判断基準は1の位の 5。5は5以上なので、絶対値を大きくする方向へ丸めます。-125から絶対値を大きくすると-130になります。結果は -130 です。
ROUND(-124, -1): 対象の桁は10の位（-2）。判断基準は1の位の 4。4は5未満なので、絶対値はそのままです。結果は -120 です。

負の数に対する丸めは、正の数と同様の「次の位が5以上なら絶対値を大きくする方向へ丸める」というルールで動作すると理解すると、結果を予測しやすくなります。

PostgreSQLの ROUND 関数が一般的な四捨五入を採用しているという事実は、多くの一般的な用途に適していますが、特定の統計的手法や要件においては、他の丸め方法（例: 最近接偶数への丸め）が必要になる場合があることを覚えておいてください。その場合は、別の関数を組み合わせるか、より複雑なロジックを実装する必要があります。例えば、最近接偶数への丸めをPostgreSQLで実装するには、数値の符号、小数部、対象桁の値を調べて条件分岐するカスタム関数を作成するなどの方法が考えられます。しかし、通常は標準の ROUND 関数で十分でしょう。

ROUND関数と他の端数処理関数との比較

PostgreSQLには ROUND 関数の他にも、数値を特定の基準で端数処理するための関数がいくつか用意されています。これらの関数は ROUND とは異なるロジックで動作するため、それぞれの特性を理解し、目的に応じて使い分けることが重要です。主要な端数処理関数として、CEILING (または CEIL)、FLOOR、そして TRUNC があります。

1. `CEILING` (または `CEIL`) 関数：指定値以上の最小の整数への切り上げ

CEILING 関数（CEIL はその別名）は、指定された数値をその数値以上の最も小さな整数に切り上げる関数です。小数点以下が存在する場合、その値がわずかでもゼロでない限り、整数部に1が加算されます（ただし、数値が既に整数であるか、または負の数で小数点以下が0である場合は、元の値がそのまま返されます）。これは常に正の無限大方向への丸めとなります。

構文:
sql CEILING(source_value) CEIL(source_value)

source_value: 切り上げの対象となる数値。

動作:
数直線をイメージすると、CEILING は常に指定された数値より「右側」にある最も近い整数点を返します（数値が整数点そのものである場合を除く）。正の数の場合は小数点以下を切り上げて絶対値を大きくし、負の数の場合は小数点以下を切り捨てて絶対値を小さくします（ゼロに近づく方向へ）。

例:

sql SELECT CEILING(123.45); -- 結果: 124 (123より大きく最も近い整数) SELECT CEILING(123.99); -- 結果: 124 SELECT CEILING(123.0); -- 結果: 123 SELECT CEILING(-123.45);-- 結果: -123 (-123.45より大きく最も近い整数) SELECT CEILING(-123.99);-- 結果: -123 SELECT CEILING(-123.0); -- 結果: -123

CEILING は、例えば「商品の個数を梱包する場合、端数が出ても箱の数は切り上げが必要」といったシナリオや、「必要なメモリ容量をMB単位で計算し、端数が出ても切り上げて確保する」といった場合に役立ちます。

2. `FLOOR` 関数：指定値以下の最大の整数への切り捨て

FLOOR 関数は、指定された数値をその数値以下の最も大きな整数に切り捨てる関数です。小数点以下が存在する場合、その部分は単純に破棄されます。これは常に負の無限大方向への丸めとなります。

構文:
sql FLOOR(source_value)

source_value: 切り捨ての対象となる数値。

動作:
数直線をイメージすると、FLOOR は常に指定された数値より「左側」にある最も近い整数点を返します（数値が整数点そのものである場合を除く）。正の数の場合は小数点以下を切り捨てて絶対値を小さくし、負の数の場合は小数点以下を切り捨てて絶対値を大きくします（ゼロから遠ざかる方向へ）。

例:

sql SELECT FLOOR(123.45); -- 結果: 123 (123.45より小さく最も近い整数) SELECT FLOOR(123.99); -- 結果: 123 SELECT FLOOR(123.0); -- 結果: 123 SELECT FLOOR(-123.45);-- 結果: -124 (-123.45より小さく最も近い整数) SELECT FLOOR(-123.99);-- 結果: -124 SELECT FLOOR(-123.0); -- 結果: -123

FLOOR は、例えば「年齢を計算する際に、誕生日が来ていなければ小数点以下を切り捨てて満年齢とする」といったシナリオや、「商品の価格から税抜き価格を計算する際に、小数点以下を切り捨てて計算する」といった場合に役立ちます。

3. `TRUNC` 関数：指定桁数での切り捨て（小数点以下を単に破棄）

TRUNC 関数は ROUND 関数と似た構文を持ち、指定された 桁数 で数値を切り捨てます。ROUND が「最も近い値に丸める」のに対し、TRUNC は単純に「指定された桁より下の桁を破棄する」という動作をします。丸め処理（四捨五入のような繰り上がり/繰り下がり）は行われません。これは常にゼロ方向への切り捨てとなります。

構文:
sql TRUNC(source_value) TRUNC(source_value, decimal_places)

source_value: 切り捨ての対象となる数値。
decimal_places: 切り捨てを行う小数点以下の桁数を指定する整数値（ROUND 関数と同様に、正、ゼロ、負の値を指定可能）。桁数 を省略した場合、0を指定した場合と同様に整数への切り捨てが行われます。

動作:
TRUNC(数値, 桁数) は、小数点以下 桁数+1 位以下を全て破棄します。桁数 に負の値を指定した場合は、小数点より左側の指定された桁より下の位を全てゼロにします。正の数であれば値をより小さく、負の数であれば値をより大きく（ゼロに近づける）方向に操作します。

例:

“`sql
— 桁数指定なし / 桁数 = 0 (整数への切り捨て)
SELECT TRUNC(123.45); — 結果: 123
SELECT TRUNC(123.99); — 結果: 123 (小数点以下が大きくても単純切り捨て)
SELECT TRUNC(123.0); — 結果: 123
SELECT TRUNC(-123.45); — 結果: -123 (負の数も単純切り捨て – ゼロに近い方へ)
SELECT TRUNC(-123.99); — 結果: -123
SELECT TRUNC(-123.0); — 結果: -123

— 桁数 = 2 (小数点以下第2位で切り捨て)
SELECT TRUNC(123.4567, 2); — 小数点以下第3位以下を破棄
— 結果: 123.45
SELECT TRUNC(123.4549, 2); — 小数点以下第3位以下を破棄
— 結果: 123.45

— 桁数 = -1 (10の位で切り捨て)
SELECT TRUNC(126.78, -1); — 1の位以下をゼロにする
— 結果: 120
SELECT TRUNC(123.45, -1); — 1の位以下をゼロにする
— 結果: 120

— 桁数 = -2 (100の位で切り捨て)
SELECT TRUNC(12345.67, -2); — 10の位以下をゼロにする
— 結果: 12300
“`

TRUNC 関数は、ROUND 関数のように「最も近い値」への丸めは行いません。常にゼロ方向（正の数はゼロに近づく、負の数もゼロに近づく）へ向かって切り捨てを行います。これにより、数値の特定の桁より下を完全に無視したい場合に適しています。

比較表と使い分け

関数	構文	動作	小数点以下の指定	負の数の扱い	端数0.5の扱い（`ROUND`/`TRUNC`の例）
`ROUND`	`ROUND(数値, [桁数])`	指定桁数で最も近い値に丸める（四捨五入）	可能 (`桁数`)	絶対値に対して同様のルール適用、結果は符号付き	常に切り上げ
`CEILING`	`CEILING(数値)`	指定値以上の最小の整数へ切り上げ（正の無限大方向）	不可 (常に整数)	正の数と同様（-1.1 -> -1, -1.0 -> -1）	N/A
`FLOOR`	`FLOOR(数値)`	指定値以下の最大の整数へ切り捨て（負の無限大方向）	不可 (常に整数)	正の数と同様（-1.1 -> -2, -1.0 -> -1）	N/A
`TRUNC`	`TRUNC(数値, [桁数])`	指定桁数より下の桁を単純に破棄（ゼロ方向へ）	可能 (`桁数`)	絶対値に対して同様のルール適用、結果は符号付き	単純切り捨て（丸めはしない）

具体的な数値での比較例:

ここでは、様々な値に対してこれらの端数処理関数を適用した結果を示します。特に、正負の値、小数点以下の値、および端数がちょうど0.5の場合に注目してください。

sql SELECT value, ROUND(value, 2) AS rounded_2, TRUNC(value, 2) AS truncated_2, ROUND(value, 0) AS round_to_int, TRUNC(value, 0) AS trunc_to_int, CEILING(value) AS ceiling_val, FLOOR(value) AS floor_val, ROUND(value, -1) AS round_tens, TRUNC(value, -1) AS trunc_tens FROM (VALUES (123.456), -- 小数点以下、繰り上げ発生 (123.454), -- 小数点以下、切り捨て発生 (123.455), -- 小数点以下、端数0.5 (-123.456), -- 負の数、小数点以下、繰り上げ発生（絶対値大） (-123.454), -- 負の数、小数点以下、切り捨て発生（絶対値小） (-123.455), -- 負の数、小数点以下、端数0.5 (12.5), -- 整数丸め時の端数0.5 (11.5), -- 整数丸め時の端数0.5 (-12.5), -- 負の整数丸め時の端数0.5 (-11.5), -- 負の整数丸め時の端数0.5 (126), -- 10の位丸めの例、繰り上げ発生 (124), -- 10の位丸めの例、切り捨て発生 (-126), -- 負の10の位丸めの例、繰り上げ発生（絶対値大） (-124), -- 負の10の位丸めの例、切り捨て発生（絶対値小） (0.0000001), -- ゼロに近い正の数 (-0.0000001) -- ゼロに近い負の数 ) AS t(value);

value	rounded_2	truncated_2	round_to_int	trunc_to_int	ceiling_val	floor_val	round_tens	trunc_tens
123.456	123.46	123.45	123	123	124	123	120	120
123.454	123.45	123.45	123	123	124	123	120	120
123.455	123.46	123.45	123	123	124	123	120	120
-123.456	-123.46	-123.45	-123	-123	-123	-124	-120	-120
-123.454	-123.45	-123.45	-123	-123	-123	-124	-120	-120
-123.455	-123.46	-123.45	-123	-123	-123	-124	-120	-120
12.5	12.50	12.50	13	12	13	12	10	10
11.5	11.50	11.50	12	11	12	11	10	10
-12.5	-12.50	-12.50	-13	-12	-12	-13	-10	-10
-11.5	-11.50	-11.50	-12	-11	-11	-12	-10	-10
126	126.00	126.00	126	126	126	126	130	120
124	124.00	124.00	124	124	124	124	120	120
-126	-126.00	-126.00	-126	-126	-126	-126	-130	-120
-124	-124.00	-124.00	-124	-124	-124	-124	-120	-120
0.0000001	0.00	0.00	0	0	1	0	0	0
-0.0000001	-0.00	-0.00	0	0	0	-1	0	0

使い分けのポイント:

ROUND: 最も一般的な丸め（四捨五入）を行いたい場合。小数点以下の特定の桁数や整数部での丸めに使用します。通貨計算や統計データの表示など、一般的な丸めルールが必要な場合に適しています。結果は元の数値型または numeric 型になることが多く、小数点以下が保持される可能性があります（指定桁数による）。
CEILING / FLOOR: 数値をそれぞれ常に「その値以上の最小の整数」または「その値以下の最大の整数」にしたい場合。特定の方向への切り捨て・切り上げが要件となる場合に適しています。これらの関数は常に整数（内部的には数値型）を返します。
TRUNC: 指定桁数より下の桁を単純に破棄したい場合。例えば、特定の精度のデータを扱う際に、それ以下の情報を完全に無視したい場合などに使用します。ROUND とは異なり、丸めによる繰り上がり/繰り下がりは発生しません。結果は元の数値型または numeric 型になることが多く、指定桁数より下の小数部はゼロになります。

どの関数を選ぶかは、満たしたいビジネスロジックや計算要件によって決まります。これらの違いを正しく理解することが、正確なデータベース処理を行う上で不可欠です。特に、負の数に対する CEILING/FLOOR の挙動や、ROUND と TRUNC の端数処理の違い（丸めるか、単純に破棄するか）は混同しやすいので注意が必要です。

ROUND関数の応用例

ROUND 関数は非常に汎用性が高く、様々なシナリオで役立ちます。ここでは、いくつか具体的な応用例を紹介し、どのように ROUND 関数を活用できるかを見ていきましょう。これらの例を通じて、ROUND 関数の実践的な利用法を理解できます。

例1：通貨計算における丸め

通貨計算では、最小単位（例えば日本の円なら整数、米ドルならセント（小数点以下第2位））への丸めが必要となることがよくあります。特に消費税計算や割引計算などで端数が発生する場合、最終的な金額を適切に丸める必要があります。通貨計算には numeric 型を使用するのが原則です。

例えば、商品価格に10%の消費税をかけた後、円単位で丸めたい場合（小数点以下を四捨五入して整数にする場合）。

“`sql
— 商品価格が100円の場合の消費税込み価格 (110円)
SELECT 100::numeric * 1.10::numeric AS price_with_tax;
— 結果: 110.00

— 商品価格が98円の場合の消費税込み価格 (107.8円) を整数に丸める
SELECT ROUND(98::numeric * 1.10::numeric) AS rounded_price_with_tax;
— 結果: 108 (107.8 -> 108)

— 商品価格が99円の場合の消費税込み価格 (108.9円) を整数に丸める
SELECT ROUND(99::numeric * 1.10::numeric) AS rounded_price_with_tax;
— 結果: 109 (108.9 -> 109)

— 商品価格が97円の場合の消費税込み価格 (106.7円) を整数に丸める
SELECT ROUND(97::numeric * 1.10::numeric) AS rounded_price_with_tax;
— 結果: 107 (106.7 -> 107)
“`

このように、税込み価格などの計算結果を特定の通貨単位で丸める際に ROUND 関数が使用されます。通貨計算では精度が非常に重要であるため、対象となる数値には numeric 型を使用することが強く推奨されます。リテラル値も明示的に ::numeric でキャストすると意図が明確になります。

米ドルのように小数点以下第2位までを扱う通貨の場合：

“`sql
— 価格が $12.345 の商品を小数点以下第2位で丸める
SELECT ROUND(12.345::numeric, 2);
— 結果: 12.35

— 価格が $12.344 の商品を小数点以下第2位で丸める
SELECT ROUND(12.344::numeric, 2);
— 結果: 12.34

— 合計金額 $100.50 * 1.08 (税率8%) = $108.54 の小数点以下第2位での丸め
SELECT ROUND(100.50::numeric * 1.08::numeric, 2);
— 結果: 108.54
“`

例2：統計データの表示

平均値、パーセンテージ、比率などの統計データは、計算結果が長い小数点以下を持つことがよくあります。これをレポートやグラフで表示する際には、可読性を向上させるために特定の小数点以下の桁数に丸めるのが一般的です。

例えば、あるテストの平均点を計算し、小数点以下第1位まで表示したい場合。

sql -- scores テーブルがあり、各行に test_score カラムがあると仮定 -- 平均点を計算し、小数点以下第1位に丸める -- AVG関数は通常double precisionを返すため、numericにキャストしてから丸めるのが安全 SELECT ROUND(AVG(test_score)::numeric, 1) AS average_score FROM scores;

あるいは、あるカテゴリが全体に占める割合をパーセンテージで計算し、小数点以下第2位まで表示したい場合。

sql -- products テーブルがあり、category と price カラム（numeric型と仮定）があると仮定 -- 'Electronics' カテゴリの価格合計が全体の価格合計に占める割合を計算し、小数点以下第2位のパーセンテージで表示 SELECT ROUND( (SUM(CASE WHEN category = 'Electronics' THEN price ELSE 0 END) * 100.0::numeric) / SUM(price), 2 ) AS electronics_percentage FROM products;
ここでは、100.0::numeric とすることで、計算全体が numeric 型で行われるようにキャストしています。これにより、正確な割合計算と丸めが可能になります。

例3：レポート生成における数値整形

データベースから取得した数値をそのまま表示すると、桁数がばらばらで読みにくいことがあります。特に表形式のレポートでは、数値を特定の桁数に揃えることで見栄えが格段に向上します。ROUND 関数は、このような数値整形にも利用できます。

sql -- 製品ごとの在庫数を千単位に丸めて概算で表示 -- stock_quantity が integer または numeric 型と仮定 SELECT product_name, ROUND(stock_quantity, -3) AS estimated_stock_k FROM products;

例えば、stock_quantity が 12345 の製品は 12000 と表示され、12678 の製品は 13000 と表示されます。これは、大まかな数量感を伝えるのに役立ちます。

例4：地理空間データにおける座標値の丸め

緯度や経度といった地理空間データは、非常に多くの小数点以下の桁数を持つことがあります。アプリケーションでこれらの座標値を表示する際に、不要な精度を削減するために丸めが必要になる場合があります。必要な精度に応じて、小数点以下第何位まで表示するかを ROUND 関数で制御します。

sql -- locations テーブルがあり、latitude と longitude カラム（double precision 型）があると仮定 -- 緯度と経度を小数点以下第5位に丸めて取得 -- float8型からnumericにキャストしてからROUNDするのが安全 SELECT ROUND(latitude::numeric, 5) AS rounded_latitude, ROUND(longitude::numeric, 5) AS rounded_longitude FROM locations;

地理空間データで double precision を使用している場合でも、正確な丸めが必要な場合は一度 numeric 型にキャストしてから ROUND するのがより安全です。小数点以下第5位は、緯度・経度において約1.1メートルの精度に相当すると言われています。表示の要件に応じて適切な桁数を選択します。

これらの例からわかるように、ROUND 関数は単に数値を丸めるだけでなく、データの表示形式を整えたり、特定の計算要件を満たしたりするために幅広く利用されます。様々なデータ型や 桁数 引数の使い方を理解することで、これらの応用シナリオに柔軟に対応できるようになります。特にビジネスロジックにおいては、どの桁で、どのようなルールで丸めるべきかという要件を明確にすることが、実装の最初のステップとなります。

パフォーマンスに関する考慮事項

ROUND 関数を含む数学関数をSQLクエリで使用する際には、パフォーマンスへの影響を考慮することが重要です。特に大量のデータに対してこれらの関数を適用する場合や、WHERE 句、JOIN 条件、ORDER BY 句などで関数を使用する場合には注意が必要です。関数は通常、各行のデータに対して適用されるため、その計算コストが無視できなくなる場合があります。

1. インデックスとの関係

最も一般的なパフォーマンス上の注意点は、WHERE 句や JOIN 条件などで関数を使用すると、多くの場合、その関数が適用される列に定義されたインデックスが利用されなくなる（あるいは効率的に利用されなくなる）可能性があるという点です。データベースのオプティマイザは、関数が適用された列の元の値ではなく、関数の計算結果を評価しようとしますが、インデックスは元の値に基づいて構築されているため、インデックスルックアップが困難になります。

例えば、price 列にインデックスが張られているテーブルで、「丸めた価格が1000円ちょうどの商品を検索する」というクエリを考えます。

sql -- price列にB-treeインデックスがある -- このクエリでは、price列のインデックスが使われない可能性が高い SELECT * FROM products WHERE ROUND(price, 0) = 1000;

このクエリを実行する際、データベースシステムは通常、テーブルの各行を順番に読み込み（シーケンシャルスキャン）、price 列の値を取り出して ROUND 関数を適用し、その結果が1000であるかどうかをチェックします。この処理は、テーブルサイズが大きくなるにつれて遅くなります。

このような場合の代替策としては、以下のようなものがあります。

検索条件の変換: ROUNDの逆演算を考慮して、元の列に対する範囲検索に変換できる場合はそうします。ROUND(price, 0) = 1000 という条件は、「priceが999.5以上で、1000.5未満」という条件と同等です（ただし、数値型によっては境界値の扱いが微妙に異なる場合があるため注意）。
sql -- ROUND(price, 0) = 1000 は 999.5 <= price < 1000.5 を意味する -- このクエリでは、price列のインデックスが利用される可能性が高い SELECT * FROM products WHERE price >= 999.5 AND price < 1000.5;
この方法は、元の列に既存のインデックスがある場合に非常に効果的です。ただし、この変換は丸め方（四捨五入、切り捨てなど）や桁数によって複雑になる場合があります。特に負の桁数での丸めや、TRUNC 関数など、ROUND 以外の関数では変換ロジックが異なります。
関数インデックスの利用: よく使用される関数式に対してインデックスを作成します。PostgreSQLは関数インデックスをサポートしています。
“`sql
— ROUND(price, 0) の結果に対するインデックスを作成
CREATE INDEX idx_products_rounded_price ON products (ROUND(price, 0));

— このインデックスは以下のクエリで利用される可能性がある
SELECT *
FROM products
WHERE ROUND(price, 0) = 1000;
`` 関数インデックスは、特定の関数式を使った検索性能を向上させるのに非常に効果的です。しかし、インデックス自体の作成、ディスク容量の使用、およびデータ更新時の維持にコストがかかります。また、クエリのWHERE` 句などで使用される関数式が、インデックス定義の関数式と完全に一致している必要があります。

2. `ORDER BY` 句での使用

ORDER BY 句で ROUND 関数を使用する場合も、同様にパフォーマンスに影響を与える可能性があります。

sql -- 丸めた価格で並べ替える SELECT product_name, price FROM products ORDER BY ROUND(price, 0);

この場合、データベースは全ての行の price 値に対して ROUND 関数を計算し、その結果に基づいてソートを行う必要があります。これは、インデックスが利用できないソート操作となり、大量のデータではコストが高くなる可能性があります。特に、結果セット全体をソートする必要がある場合（メモリに収まらない場合はディスクを使用）、その遅延は顕著になることがあります。

もし頻繁に丸めた値でソートする必要がある場合は、前述の関数インデックスを検討するか、あるいはアプリケーション側でデータを取得してからソート処理を行うことを検討する必要があります。ただし、データベース側でソートする方が一般的に効率が良いことが多いです。

3. 計算列での使用

テーブル設計の段階で、丸められた値を頻繁に利用することが分かっている場合は、計算結果を格納する列を別途設けることも一つの選択肢です。

例えば、price 列に加えて rounded_price 列を用意し、データの挿入・更新時に ROUND(price, 0) の結果を rounded_price に格納します。

“`sql
— テーブル定義例
CREATE TABLE products (
product_id SERIAL PRIMARY KEY,
product_name VARCHAR(255),
price NUMERIC(10, 2),
rounded_price INTEGER — ROUND(price, 0) の結果を格納するための列
);

— データ挿入時または更新時に rounded_price を計算して格納
— INSERT例:
INSERT INTO products (product_name, price, rounded_price)
VALUES (‘Widget’, 999.75, ROUND(999.75, 0)); — rounded_price に 1000 が格納される

— UPDATE例:
UPDATE products SET price = 1000.25, rounded_price = ROUND(1000.25, 0) WHERE product_id = 1; — rounded_price が 1000 に更新される

— 検索は rounded_price 列に対して行う
SELECT *
FROM products
WHERE rounded_price = 1000; — rounded_price 列にインデックスがあれば利用可能
“`

この方法は、データの冗長化とデータ更新時の計算・格納のオーバーヘッドを伴いますが、読み取り性能が大幅に向上する可能性があります。特に読み取りが頻繁で書き込みが少ないワークロードに適しています。PostgreSQLのバージョン12以降では、生成列（Generated Columns）という機能を使うことで、このような計算列の維持をデータベース側で自動化でき、手動でトリガーなどを設定する手間を省けます。

4. 大量データへの適用

SELECT リストで単に値を整形するために ROUND 関数を大量のデータに適用する場合、各行で関数が実行されるため、ある程度のCPUコストが発生します。しかし、このコストは通常、データのディスクからの読み込みやネットワーク経由での転送のコストと比較して小さいことが多いです。パフォーマンス上のボトルネックになるのは、前述のようなインデックスが効かない検索条件やソートでの使用の方が多いでしょう。

もし純粋な計算コストが問題になる場合は、より効率的なアルゴリズムを検討するか、集計処理などでは先にデータをフィルタリングして処理対象の行数を減らしてから ROUND 関数を適用するなどの工夫が有効です。

まとめ

ROUND 関数自体はシンプルで比較的軽量な操作ですが、データベースのインデックスやクエリ最適化のメカニズムと組み合わせて使用する際には、パフォーマンスへの影響を十分に理解しておく必要があります。特に WHERE 句や ORDER BY 句での使用には注意し、必要に応じて検索条件の変換や関数インデックスの利用、あるいはデータの冗長化といった対策を検討しましょう。パフォーマンス要件に応じて最適なアプローチを選択することが重要です。

浮動小数点数 (`float4`, `float8`) と `numeric` 型におけるROUNDの違い

ROUND 関数の引数の詳細のセクションでも触れましたが、浮動小数点数型 (real, double precision) と任意精度数値型 (numeric, decimal) は、数値をコンピュータの内部で表現する方法が根本的に異なります。この違いが、ROUND 関数の挙動、特に精度に関する注意点に影響を与えます。ここでは、この違いをさらに詳しく掘り下げ、なぜ金融計算などで numeric 型が推奨されるのかを説明します。

浮動小数点数型の性質と精度問題の再確認

浮動小数点数型は、数値を「仮数部」と「指数部」に分けて表現します。この表現形式は、非常に大きな数から非常に小さな数まで、幅広い範囲の値を効率的に表現し、高速な計算を行うのに適しています。しかし、この表現は基本的に二進数に基づいているため、多くの10進数の小数を正確な二進数で表現できません（例: 10進数の0.1は二進数では無限小数になります）。コンピュータは有限のビット数しか持たないため、このような無限小数は途中で打ち切られるしかなく、結果としてごくわずかな誤差が発生します。

この誤差は「浮動小数点数精度問題」として知られており、計算や丸めの際に影響を与える可能性があります。例えば、数学的には 0.1 + 0.2 は正確に 0.3 ですが、double precision 型で計算すると 0.30000000000000004 のようになることがあります。

“`sql
— 浮動小数点数型の計算結果の例
SELECT 0.1::double precision + 0.2::double precision;
— 結果: 0.30000000000000004

SELECT 1.0 / 3.0;
— 結果: 0.3333333333333333
SELECT 1.0 / 3.0 * 3.0;
— 結果: 0.9999999999999999
“`

このような誤差を含む値に対して ROUND 関数を適用した場合、丸めが行われるべき桁の次の位の値が、期待される「ちょうど5」からわずかにずれている可能性があり、それが理論上、丸めの結果に影響するシナリオが考えられます。例えば、本来 1.05 になるはずの計算結果が内部的に 1.0499999999999999 となった場合、ROUND(1.0499999999999999, 1) は、小数点以下第2位が4とみなされ、1.0 に丸められる可能性が考えられます。

PostgreSQLは、一般的な浮動小数点数型の値に対する ROUND がユーザーの期待する四捨五入として動作するように、内部的にある程度の許容範囲を設けるなどの工夫を行っているようです。このため、多くのケースで浮動小数点数に対しても期待通りの丸め結果が得られます。しかし、これは厳密な保証ではなく、浮動小数点数の性質に起因する限界がなくなるわけではありません。

結論として、金融計算や会計処理など、小数点以下の値に厳密な精度が求められる分野では、浮動小数点数型を使用することは避けるべきです。 わずかな誤差が、大きな金額の合計や多数の取引の集計において無視できない差となる可能性があります。

`numeric` 型の性質と正確な丸め

numeric 型（decimal 型も同様）は、指定された精度とスケール（小数点以下の桁数）で数値を正確な10進数として表現・計算します。内部的には、数値を符号、非負の整数の値、および小数点位置（スケール）として保持します。これにより、小数点以下の桁数を定義された精度内で失うことなく、計算において精度誤差が発生することなく正確な演算が可能です。

numeric 型を引数として ROUND 関数に渡した場合、丸めは常にこの正確な10進数表現に基づいて行われます。前述の浮動小数点数型で懸念されるような、内部的な微細な誤差による丸めの不確実性は完全に排除されます。ROUND 関数の一般的な四捨五入ルール（端数5以上は切り上げ）は、numeric 型に対して最も信頼性の高い形で、かつ数学的に期待される通りに適用されます。

“`sql
SELECT 0.1::numeric + 0.2::numeric; — 結果: 0.3

SELECT ROUND(123.455::numeric, 2); — 結果: 123.46 (numeric型なので、端数5は正確に切り上げ)
SELECT ROUND(123.445::numeric, 2); — 結果: 123.45 (numeric型なので、端数5は正確に切り上げ)

SELECT ROUND(12.5::numeric, 0); — 結果: 13
SELECT ROUND(11.5::numeric, 0); — 結果: 12

— 厳密な計算と丸めの例
SELECT ROUND((100.0::numeric * 1.08::numeric) / 3.0::numeric, 2);
— 100 * 1.08 = 108.00
— 108.00 / 3 = 36.00
— ROUND(36.00, 2) = 36.00
— 結果: 36.00

SELECT ROUND((100.0::numeric * 1.08::numeric) / 7.0::numeric, 2);
— 100 * 1.08 = 108.00
— 108.00 / 7 = 15.428571…
— ROUND(15.428571…, 2) = 15.43
— 結果: 15.43
“`

numeric 型を使用する場合、データ型の宣言時に精度とスケールを指定することが一般的です（例: NUMERIC(10, 2) は全体で10桁、小数点以下2桁まで）。これにより、格納できる値の範囲と精度が定義されます。ROUND 関数の 桁数 引数は、このスケールとは独立して指定できます。例えば、NUMERIC(10, 4) の列に対して ROUND(column, 2) とすることも、ROUND(column, -1) とすることも可能です。numeric 型の精度内で、指定された桁数で正確な丸めが行われます。

どちらの型を使うべきか？

real, double precision: 科学技術計算、物理シミュレーション、グラフィックス、非厳密な測定値など、非常に広い範囲の数値を扱い、わずかな精度誤差が許容されるか、あるいは誤差の性質が既知で制御可能な場合に使用します。高速な計算が必要な場合にも選択肢となります。
numeric, decimal: 金融、会計、厳密な測定値、ビジネス上の厳密な金額計算など、厳密な精度が求められる場合に使用します。計算結果の正確性が最優先される場合に強く推奨されます。ただし、浮動小数点数型に比べて演算のパフォーマンスはやや劣る傾向があります。また、格納に必要なディスク容量も大きくなることがあります。

ROUND 関数を使用する際は、特に小数点以下の端数処理の正確性が求められるのであれば、対象となる数値は numeric 型であることが望ましいです。 もし元のデータが浮動小数点数型である場合は、ROUND 関数を適用する前に ::numeric を使って numeric 型にキャストすることを検討してください。これにより、浮動小数点数の精度問題を回避し、丸め処理を numeric 型の正確な計算で行うことができます。

sql -- float8 型の値を numeric にキャストしてから ROUND SELECT ROUND(some_float8_column::numeric, 2) FROM some_table;

このように、numeric 型と組み合わせて ROUND 関数を使用することで、最も信頼性の高い端数処理を実現できます。データ型は、データベース設計の初期段階でビジネス要件に基づいて慎重に選択されるべき要素です。

エラー処理とNULL値

PostgreSQLの関数を使用する際には、エラーが発生する可能性やNULL値がどのように扱われるかを理解しておくことが重要です。ROUND 関数についても同様です。これらの挙動を把握しておくことで、クエリの実行が中断されることを避けたり、NULL値を含むデータに対しても適切に結果を処理したりすることができます。

不正な引数によるエラー

ROUND 関数は、最初の引数として数値型の値、二番目の引数（指定する場合）として整数型の値を期待します。これらの期待されるデータ型と異なる値を引数として渡した場合、PostgreSQLは可能な限り暗黙的な型変換を試みますが、変換できない場合はエラーが発生します。

非数値を 数値 引数に指定した場合:
文字列など、数値に変換できない値を最初の引数として指定すると、型変換エラーが発生します。
sql SELECT ROUND('abc'); -- エラー: invalid input syntax for type double precision: "abc"
ただし、数値として解釈できる文字列であれば、自動的に型変換されて処理が続行されます。
sql SELECT ROUND('123.45'); -- 結果: 123 (文字列がnumeric型に変換されてROUND(123.45::numeric)として処理される)
非整数を 桁数 引数に指定した場合:
桁数 引数は整数型（integer など）である必要があります。浮動小数点数などを指定した場合、PostgreSQLは暗黙的に整数に変換しようとします。この変換は通常、小数点以下を切り捨てることで行われます。文字列など、整数に変換できない値を指定した場合はエラーになります。
“`sql
SELECT ROUND(123.45, 2.9); — 2.9は暗黙的に整数2に変換される
— 結果: 123.46

SELECT ROUND(123.45, -1.1); — -1.1は暗黙的に整数-1に変換される
— 結果: 120

SELECT ROUND(123.45, ‘two’);
— エラー: invalid input syntax for type integer: “two”
`` したがって、桁数` 引数には整数リテラルや整数型の列、または整数を返す式を指定するのが最も安全です。
数値表現の範囲を超える結果:
非常に大きな数値に対して負の桁数で丸めを行った結果が、対象の数値型で表現できる範囲を超える場合、オーバーフローエラーが発生する可能性があります。例えば、smallint 型（-32768 から 32767）の列に対して ROUND(column, -5) のように非常に大きな位での丸めを行い、結果がその範囲を超えた場合などです。ただし、numeric 型は任意精度をサポートするため、このようなエラーは発生しにくいです。

適切なデータ型で引数を指定すること、特にユーザーからの入力値や外部ソースの値を引数として使用する場合は、事前にデータの検証や明示的な型変換を行うことが、エラーを防ぐ上で最も重要です。

NULL値の取り扱い

ROUND 関数のいずれかの引数に NULL が含まれる場合、関数の結果は常に NULL になります。これはPostgreSQLにおける多くの関数に共通するNULL伝播のルールに従います。

sql SELECT ROUND(NULL); -- 結果: NULL SELECT ROUND(123.45, NULL); -- 結果: NULL SELECT ROUND(NULL, 2); -- 結果: NULL SELECT ROUND(NULL, NULL); -- 結果: NULL

この動作は予測しやすく、NULL値を含むデータ行に対して ROUND 関数を適用しても、その結果がNULLになるだけなので、通常は特別なエラー処理は不要です。NULL値を含む行を結果セットから除外したい場合は WHERE column IS NOT NULL のような条件を追加すればよく、NULL値を特定の非NULL値として扱ってから丸めたい場合は、COALESCE 関数などを使用して事前にNULLを変換する必要があります。

sql -- NULLを0として扱ってからROUND SELECT ROUND(COALESCE(some_numeric_column, 0)::numeric, 2);

NULL値の扱いを理解しておくことで、クエリの結果が期待通りになることを保証できます。特に集計関数（AVG, SUMなど）と組み合わせて使用する場合、集計関数はデフォルトではNULL値を無視するため、ROUND(AVG(column)) と AVG(ROUND(column)) では結果が異なる可能性がある点に注意が必要です（前者はNULLを除外して平均を計算し丸め、後者は各値を先に丸めてから平均を計算する）。

PostgreSQLのバージョンによる違い

PostgreSQLは継続的に開発が進められており、バージョンアップによって関数の内部実装や特定のデータ型（特に浮動小数点数型）の扱いが微調整されることがあります。しかし、ROUND 関数に関しては、その基本的な四捨五入のルール（端数5以上で切り上げ）や構文に、ユーザーが通常意識するような大きな変更は長らくありません。一般的な四捨五入の動作は、PostgreSQLの安定した機能として確立されています。

過去のバージョンにおいて、浮動小数点数型の丸めに関する内部的な挙動が一部変更された可能性はゼロではありませんが、これは通常、IEEE 754浮動小数点数標準への準拠や、特定の境界値における丸めの一貫性を向上させるための微細な調整に留まります。これらの変更が、本記事で説明した基本的な「端数5以上は切り上げ」というルールを覆すようなものではありません。

もし非常に古いバージョンのPostgreSQL（例えば、現代ではほとんど使われないバージョン7系や8系など）を使用している場合は、念のため公式ドキュメントでそのバージョンの ROUND 関数の正確な仕様を確認することが推奨されます。しかし、PostgreSQL 9.x、10.x、11.x、12.x、13.x、14.x、15.x、16.x といった比較的最近のバージョンにおいては、本記事で説明した ROUND 関数の動作原理（一般的な四捨五入、端数5の切り上げ、負の桁数など）は共通しています。

したがって、特別な事情がない限り、PostgreSQLのバージョンによって ROUND 関数の基本的な使い方や結果が劇的に変わることを心配する必要はありません。安心して本記事の内容を現在のPostgreSQL環境に適用できるでしょう。常に最新の安定版PostgreSQLを使用することは、機能面だけでなくセキュリティやパフォーマンスの面でも推奨されます。

まとめ：ROUND関数をマスターして精度の高いデータ処理を

この記事では、PostgreSQLの ROUND 関数について、その基本的な使い方から始まり、引数の詳細、内部的な四捨五入のルール、他の端数処理関数との比較、応用例、パフォーマンスの考慮事項、そして浮動小数点数と numeric 型の違いに至るまで、徹底的に解説しました。

ROUND 関数は、指定された数値を最も近い値に丸めるための強力なツールであり、小数点以下の特定の桁数や整数部の特定桁数での丸めを柔軟に行うことができます。PostgreSQLの ROUND 関数が採用しているのは、小数点以下の端数が5以上の場合は切り上げ、5未満の場合は切り捨てるという、最も一般的な四捨五入のルールです。端数がちょうど5の場合も切り上げが行われます。

特に重要なポイントを以下に要約します。

構文: ROUND(数値) (整数への丸め) と ROUND(数値, 桁数) (指定桁数での丸め) の二つがあります。ROUND(数値) は ROUND(数値, 0) と同等です。
引数 桁数: 整数値を指定します。正の値は小数点以下の桁数を、0は整数を、負の値は小数点より左側（整数部）の桁数を指定します。
丸めルール: 一般的な四捨五入（Round half up）を採用しています。丸められる桁の次の位の数値が判断基準となり、5以上なら切り上げ、5未満なら切り捨てです。端数がちょうど5の場合も常に切り上げが行われます。
データ型: numeric 型は正確な10進数演算を提供するため、精度が重要な計算（金融、会計など）ではこの型を使用し、ROUND 関数も numeric 型に対して適用することが強く推奨されます。浮動小数点数型では内部表現の限界による微細な誤差の可能性に注意が必要ですが、PostgreSQLは一般的なケースで期待通りになるよう工夫されています。
他の関数との比較:
- CEILING/CEIL: 指定値以上の最小の整数への切り上げ（常に正の無限大方向）。
- FLOOR: 指定値以下の最大の整数への切り捨て（常に負の無限大方向）。
- TRUNC: 指定桁数より下の桁の単純な破棄（常にゼロ方向への切り捨て）。
  これらの関数は ROUND とは異なるロジックであり、目的に応じて使い分ける必要があります。
パフォーマンス: WHERE 句や ORDER BY 句で ROUND 関数を使用すると、関数が適用される列のインデックスが利用されずパフォーマンスが低下する可能性があります。検索条件の変換や関数インデックスの使用などを検討しましょう。
NULL値: いずれかの引数にNULLが含まれる場合、結果は常にNULLになります。NULLを特定の値として扱いたい場合は、事前に COALESCE 関数などで変換が必要です。
バージョン: 近年のPostgreSQLバージョンにおいて、ROUND 関数の基本的な動作に大きな変更はありません。

ROUND 関数は、通貨計算、統計データの表示、レポート作成など、様々な場面で数値データの表示や計算結果を整形するために不可欠です。これらの知識を身につけることで、PostgreSQLデータベースを使った開発やデータ分析において、より正確で信頼性の高い数値処理を実現できるようになるでしょう。

データベースにおける数値の端数処理は、ビジネスロジックや計算結果の正確性に直接影響するため、その重要性は非常に高いです。ROUND 関数を適切に使いこなし、必要に応じて numeric 型や他の端数処理関数と組み合わせることで、小数点以下の値を意図通りに制御し、質の高いデータ処理を達成してください。

この記事が、皆様のPostgreSQLにおける ROUND 関数および端数処理に関する理解を深める一助となれば幸いです。

参考文献/関連情報

PostgreSQL 16 Documentation: 9.17. Mathematical Functions and Operators – round()
- https://www.postgresql.org/docs/16/functions-math.html (PostgreSQLのバージョンに合わせて参照してください)
PostgreSQL 16 Documentation: 8.1. Numeric Types
- https://www.postgresql.org/docs/16/datatype-numeric.html
浮動小数点数 – Wikipedia
- https://ja.wikipedia.org/wiki/%E6%B5%AE%E5%8B%95%E5%B0%8F%E6%95%B0%E7%82%B9%E6%95%B0

約5000語で、PostgreSQLのROUND関数について詳細を網羅した記事を作成しました。小数点以下の端数処理に焦点を当て、構文、引数、内部動作、他の関数との比較、データ型の違い、パフォーマンス、エラー処理など、多角的な視点から解説しています。

PostgreSQL徹底解説：ROUND関数で実現する小数点以下の精緻な端数処理

はじめに：データベースにおける数値の精度と丸めの重要性

ROUND関数の基本：構文と最も単純な使い方

1. 桁数を指定しない構文：ROUND(数値)

2. 桁数を指定する構文：ROUND(数値, 桁数)

引数 数値 の詳細：対応データ型と注意点

整数型 (smallint, integer, bigint) を引数にした場合

浮動小数点数型 (real, double precision) を引数にした場合

任意精度数値型 (numeric, decimal) を引数にした場合

NULL値の取り扱い

引数 桁数 の詳細：小数点以下の桁数、整数部、そして負の値

正の値を 桁数 に指定した場合 (decimal_places > 0)

桁数 にゼロを指定した場合 (decimal_places = 0)

負の値を 桁数 に指定した場合 (decimal_places < 0)

桁数 引数のデータ型とNULL値

桁数 引数の範囲

ROUND関数の内部的な動作原理（四捨五入のルール）

一般的な四捨五入の具体例

負の数に対する丸め

ROUND関数と他の端数処理関数との比較

1. CEILING (または CEIL) 関数：指定値以上の最小の整数への切り上げ

2. FLOOR 関数：指定値以下の最大の整数への切り捨て

3. TRUNC 関数：指定桁数での切り捨て（小数点以下を単に破棄）

比較表と使い分け

ROUND関数の応用例

例1：通貨計算における丸め

例2：統計データの表示

例3：レポート生成における数値整形

例4：地理空間データにおける座標値の丸め

パフォーマンスに関する考慮事項

1. インデックスとの関係

2. ORDER BY 句での使用

3. 計算列での使用

4. 大量データへの適用

まとめ

浮動小数点数 (float4, float8) と numeric 型におけるROUNDの違い

浮動小数点数型の性質と精度問題の再確認

numeric 型の性質と正確な丸め

どちらの型を使うべきか？

エラー処理とNULL値

不正な引数によるエラー

NULL値の取り扱い

PostgreSQLのバージョンによる違い

まとめ：ROUND関数をマスターして精度の高いデータ処理を

参考文献/関連情報

コメントする 返信をキャンセル

1. 桁数を指定しない構文：`ROUND(数値)`

2. 桁数を指定する構文：`ROUND(数値, 桁数)`

引数 `数値` の詳細：対応データ型と注意点

整数型 (`smallint`, `integer`, `bigint`) を引数にした場合

浮動小数点数型 (`real`, `double precision`) を引数にした場合

任意精度数値型 (`numeric`, `decimal`) を引数にした場合

引数 `桁数` の詳細：小数点以下の桁数、整数部、そして負の値

正の値を `桁数` に指定した場合 (`decimal_places > 0`)

`桁数` にゼロを指定した場合 (`decimal_places = 0`)

負の値を `桁数` に指定した場合 (`decimal_places < 0`)

`桁数` 引数のデータ型とNULL値

`桁数` 引数の範囲

1. `CEILING` (または `CEIL`) 関数：指定値以上の最小の整数への切り上げ

2. `FLOOR` 関数：指定値以下の最大の整数への切り捨て

3. `TRUNC` 関数：指定桁数での切り捨て（小数点以下を単に破棄）

2. `ORDER BY` 句での使用

浮動小数点数 (`float4`, `float8`) と `numeric` 型におけるROUNDの違い

`numeric` 型の性質と正確な丸め

コメントする返信をキャンセル