open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Grab the low-hanging fruit from forcing USE_FLOAT8_BYVAL to true.

Browse Source 
Remove conditionally-compiled code for the other case.

Replace uses of FLOAT8PASSBYVAL with constant "true", mainly because
it was quite confusing in cases where the type we were dealing with
wasn't float8.

I left the associated pg_control and Pg_magic_struct fields in place.
Perhaps we should get rid of them, but it would save little, so it
doesn't seem worth thinking hard about the compatibility implications.
I just labeled them "vestigial" in places where that seemed helpful.

Author: Tom Lane <tgl@sss.pgh.pa.us>
Reviewed-by: Peter Eisentraut <peter@eisentraut.org>
Discussion: https://postgr.es/m/1749799.1752797397@sss.pgh.pa.us
pull/239/head
Tom Lane 4 months ago
parent 6aebedc384
commit ee54046601
22 changed files with 100 additions and 313 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 51
      contrib/btree_gist/btree_time.c
  2. 39
      contrib/btree_gist/btree_ts.c
  3. 2
      src/backend/access/common/tupdesc.c
  4. 5
      src/backend/access/index/indexam.c
  5. 20
      src/backend/access/transam/xlog.c
  6. 3
      src/backend/catalog/genbki.pl
  7. 2
      src/backend/optimizer/plan/planagg.c
  8. 4
      src/backend/optimizer/plan/planner.c
  9. 2
      src/backend/parser/parse_node.c
  10. 2
      src/backend/rewrite/rewriteSearchCycle.c
  11. 6
      src/backend/utils/adt/arrayfuncs.c
  12. 75
      src/backend/utils/adt/int8.c
  13. 74
      src/backend/utils/adt/numeric.c
  14. 2
      src/backend/utils/adt/orderedsetaggs.c
  15. 2
      src/backend/utils/adt/rangetypes_typanalyze.c
  16. 35
      src/backend/utils/fmgr/fmgr.c
  17. 3
      src/bin/initdb/initdb.c
  18. 2
      src/bin/pg_resetwal/pg_resetwal.c
  19. 8
      src/include/c.h
  20. 16
      src/include/catalog/pg_type.dat
  21. 2
      src/include/fmgr.h
  22. 58
      src/include/postgres.h

51
contrib/btree_gist/btree_time.c
Unescape View File

@ -31,13 +31,6 @@ PG_FUNCTION_INFO_V1(gbt_time_sortsupport);
PG_FUNCTION_INFO_V1(gbt_timetz_sortsupport); PG_FUNCTION_INFO_V1(gbt_timetz_sortsupport);
#ifdef USE_FLOAT8_BYVAL
#define TimeADTGetDatumFast(X) TimeADTGetDatum(X)
#else
#define TimeADTGetDatumFast(X) PointerGetDatum(&(X))
#endif
static bool static bool
gbt_timegt(const void *a, const void *b, FmgrInfo *flinfo) gbt_timegt(const void *a, const void *b, FmgrInfo *flinfo)
{ {
@ -45,8 +38,8 @@ gbt_timegt(const void *a, const void *b, FmgrInfo *flinfo)
const TimeADT *bb = (const TimeADT *) b; const TimeADT *bb = (const TimeADT *) b;
return DatumGetBool(DirectFunctionCall2(time_gt, return DatumGetBool(DirectFunctionCall2(time_gt,
TimeADTGetDatumFast(*aa), TimeADTGetDatum(*aa),
TimeADTGetDatumFast(*bb))); TimeADTGetDatum(*bb)));
} }
static bool static bool
@ -56,8 +49,8 @@ gbt_timege(const void *a, const void *b, FmgrInfo *flinfo)
const TimeADT *bb = (const TimeADT *) b; const TimeADT *bb = (const TimeADT *) b;
return DatumGetBool(DirectFunctionCall2(time_ge, return DatumGetBool(DirectFunctionCall2(time_ge,
TimeADTGetDatumFast(*aa), TimeADTGetDatum(*aa),
TimeADTGetDatumFast(*bb))); TimeADTGetDatum(*bb)));
} }
static bool static bool
@ -67,8 +60,8 @@ gbt_timeeq(const void *a, const void *b, FmgrInfo *flinfo)
const TimeADT *bb = (const TimeADT *) b; const TimeADT *bb = (const TimeADT *) b;
return DatumGetBool(DirectFunctionCall2(time_eq, return DatumGetBool(DirectFunctionCall2(time_eq,
TimeADTGetDatumFast(*aa), TimeADTGetDatum(*aa),
TimeADTGetDatumFast(*bb))); TimeADTGetDatum(*bb)));
} }
static bool static bool
@ -78,8 +71,8 @@ gbt_timele(const void *a, const void *b, FmgrInfo *flinfo)
const TimeADT *bb = (const TimeADT *) b; const TimeADT *bb = (const TimeADT *) b;
return DatumGetBool(DirectFunctionCall2(time_le, return DatumGetBool(DirectFunctionCall2(time_le,
TimeADTGetDatumFast(*aa), TimeADTGetDatum(*aa),
TimeADTGetDatumFast(*bb))); TimeADTGetDatum(*bb)));
} }
static bool static bool
@ -89,8 +82,8 @@ gbt_timelt(const void *a, const void *b, FmgrInfo *flinfo)
const TimeADT *bb = (const TimeADT *) b; const TimeADT *bb = (const TimeADT *) b;
return DatumGetBool(DirectFunctionCall2(time_lt, return DatumGetBool(DirectFunctionCall2(time_lt,
TimeADTGetDatumFast(*aa), TimeADTGetDatum(*aa),
TimeADTGetDatumFast(*bb))); TimeADTGetDatum(*bb)));
} }
static int static int
@ -100,9 +93,9 @@ gbt_timekey_cmp(const void *a, const void *b, FmgrInfo *flinfo)
timeKEY *ib = (timeKEY *) (((const Nsrt *) b)->t); timeKEY *ib = (timeKEY *) (((const Nsrt *) b)->t);
int res; int res;
res = DatumGetInt32(DirectFunctionCall2(time_cmp, TimeADTGetDatumFast(ia->lower), TimeADTGetDatumFast(ib->lower))); res = DatumGetInt32(DirectFunctionCall2(time_cmp, TimeADTGetDatum(ia->lower), TimeADTGetDatum(ib->lower)));
if (res == 0) if (res == 0)
return DatumGetInt32(DirectFunctionCall2(time_cmp, TimeADTGetDatumFast(ia->upper), TimeADTGetDatumFast(ib->upper))); return DatumGetInt32(DirectFunctionCall2(time_cmp, TimeADTGetDatum(ia->upper), TimeADTGetDatum(ib->upper)));
return res; return res;
} }
@ -115,8 +108,8 @@ gbt_time_dist(const void *a, const void *b, FmgrInfo *flinfo)
Interval *i; Interval *i;
i = DatumGetIntervalP(DirectFunctionCall2(time_mi_time, i = DatumGetIntervalP(DirectFunctionCall2(time_mi_time,
TimeADTGetDatumFast(*aa), TimeADTGetDatum(*aa),
TimeADTGetDatumFast(*bb))); TimeADTGetDatum(*bb)));
return fabs(INTERVAL_TO_SEC(i)); return fabs(INTERVAL_TO_SEC(i));
} }
@ -279,14 +272,14 @@ gbt_time_penalty(PG_FUNCTION_ARGS)
double res2; double res2;
intr = DatumGetIntervalP(DirectFunctionCall2(time_mi_time, intr = DatumGetIntervalP(DirectFunctionCall2(time_mi_time,
TimeADTGetDatumFast(newentry->upper), TimeADTGetDatum(newentry->upper),
TimeADTGetDatumFast(origentry->upper))); TimeADTGetDatum(origentry->upper)));
res = INTERVAL_TO_SEC(intr); res = INTERVAL_TO_SEC(intr);
res = Max(res, 0); res = Max(res, 0);
intr = DatumGetIntervalP(DirectFunctionCall2(time_mi_time, intr = DatumGetIntervalP(DirectFunctionCall2(time_mi_time,
TimeADTGetDatumFast(origentry->lower), TimeADTGetDatum(origentry->lower),
TimeADTGetDatumFast(newentry->lower))); TimeADTGetDatum(newentry->lower)));
res2 = INTERVAL_TO_SEC(intr); res2 = INTERVAL_TO_SEC(intr);
res2 = Max(res2, 0); res2 = Max(res2, 0);
@ -297,8 +290,8 @@ gbt_time_penalty(PG_FUNCTION_ARGS)
if (res > 0) if (res > 0)
{ {
intr = DatumGetIntervalP(DirectFunctionCall2(time_mi_time, intr = DatumGetIntervalP(DirectFunctionCall2(time_mi_time,
TimeADTGetDatumFast(origentry->upper), TimeADTGetDatum(origentry->upper),
TimeADTGetDatumFast(origentry->lower))); TimeADTGetDatum(origentry->lower)));
*result += FLT_MIN; *result += FLT_MIN;
*result += (float) (res / (res + INTERVAL_TO_SEC(intr))); *result += (float) (res / (res + INTERVAL_TO_SEC(intr)));
*result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1));
@ -334,8 +327,8 @@ gbt_timekey_ssup_cmp(Datum x, Datum y, SortSupport ssup)
/* for leaf items we expect lower == upper, so only compare lower */ /* for leaf items we expect lower == upper, so only compare lower */
return DatumGetInt32(DirectFunctionCall2(time_cmp, return DatumGetInt32(DirectFunctionCall2(time_cmp,
TimeADTGetDatumFast(arg1->lower), TimeADTGetDatum(arg1->lower),
TimeADTGetDatumFast(arg2->lower))); TimeADTGetDatum(arg2->lower)));
} }
Datum Datum

39
contrib/btree_gist/btree_ts.c
Unescape View File

@ -33,13 +33,6 @@ PG_FUNCTION_INFO_V1(gbt_ts_same);
PG_FUNCTION_INFO_V1(gbt_ts_sortsupport); PG_FUNCTION_INFO_V1(gbt_ts_sortsupport);
#ifdef USE_FLOAT8_BYVAL
#define TimestampGetDatumFast(X) TimestampGetDatum(X)
#else
#define TimestampGetDatumFast(X) PointerGetDatum(&(X))
#endif
/* define for comparison */ /* define for comparison */
static bool static bool
@ -49,8 +42,8 @@ gbt_tsgt(const void *a, const void *b, FmgrInfo *flinfo)
const Timestamp *bb = (const Timestamp *) b; const Timestamp *bb = (const Timestamp *) b;
return DatumGetBool(DirectFunctionCall2(timestamp_gt, return DatumGetBool(DirectFunctionCall2(timestamp_gt,
TimestampGetDatumFast(*aa), TimestampGetDatum(*aa),
TimestampGetDatumFast(*bb))); TimestampGetDatum(*bb)));
} }
static bool static bool
@ -60,8 +53,8 @@ gbt_tsge(const void *a, const void *b, FmgrInfo *flinfo)
const Timestamp *bb = (const Timestamp *) b; const Timestamp *bb = (const Timestamp *) b;
return DatumGetBool(DirectFunctionCall2(timestamp_ge, return DatumGetBool(DirectFunctionCall2(timestamp_ge,
TimestampGetDatumFast(*aa), TimestampGetDatum(*aa),
TimestampGetDatumFast(*bb))); TimestampGetDatum(*bb)));
} }
static bool static bool
@ -71,8 +64,8 @@ gbt_tseq(const void *a, const void *b, FmgrInfo *flinfo)
const Timestamp *bb = (const Timestamp *) b; const Timestamp *bb = (const Timestamp *) b;
return DatumGetBool(DirectFunctionCall2(timestamp_eq, return DatumGetBool(DirectFunctionCall2(timestamp_eq,
TimestampGetDatumFast(*aa), TimestampGetDatum(*aa),
TimestampGetDatumFast(*bb))); TimestampGetDatum(*bb)));
} }
static bool static bool
@ -82,8 +75,8 @@ gbt_tsle(const void *a, const void *b, FmgrInfo *flinfo)
const Timestamp *bb = (const Timestamp *) b; const Timestamp *bb = (const Timestamp *) b;
return DatumGetBool(DirectFunctionCall2(timestamp_le, return DatumGetBool(DirectFunctionCall2(timestamp_le,
TimestampGetDatumFast(*aa), TimestampGetDatum(*aa),
TimestampGetDatumFast(*bb))); TimestampGetDatum(*bb)));
} }
static bool static bool
@ -93,8 +86,8 @@ gbt_tslt(const void *a, const void *b, FmgrInfo *flinfo)
const Timestamp *bb = (const Timestamp *) b; const Timestamp *bb = (const Timestamp *) b;
return DatumGetBool(DirectFunctionCall2(timestamp_lt, return DatumGetBool(DirectFunctionCall2(timestamp_lt,
TimestampGetDatumFast(*aa), TimestampGetDatum(*aa),
TimestampGetDatumFast(*bb))); TimestampGetDatum(*bb)));
} }
static int static int
@ -104,9 +97,9 @@ gbt_tskey_cmp(const void *a, const void *b, FmgrInfo *flinfo)
tsKEY *ib = (tsKEY *) (((const Nsrt *) b)->t); tsKEY *ib = (tsKEY *) (((const Nsrt *) b)->t);
int res; int res;
res = DatumGetInt32(DirectFunctionCall2(timestamp_cmp, TimestampGetDatumFast(ia->lower), TimestampGetDatumFast(ib->lower))); res = DatumGetInt32(DirectFunctionCall2(timestamp_cmp, TimestampGetDatum(ia->lower), TimestampGetDatum(ib->lower)));
if (res == 0) if (res == 0)
return DatumGetInt32(DirectFunctionCall2(timestamp_cmp, TimestampGetDatumFast(ia->upper), TimestampGetDatumFast(ib->upper))); return DatumGetInt32(DirectFunctionCall2(timestamp_cmp, TimestampGetDatum(ia->upper), TimestampGetDatum(ib->upper)));
return res; return res;
} }
@ -122,8 +115,8 @@ gbt_ts_dist(const void *a, const void *b, FmgrInfo *flinfo)
return get_float8_infinity(); return get_float8_infinity();
i = DatumGetIntervalP(DirectFunctionCall2(timestamp_mi, i = DatumGetIntervalP(DirectFunctionCall2(timestamp_mi,
TimestampGetDatumFast(*aa), TimestampGetDatum(*aa),
TimestampGetDatumFast(*bb))); TimestampGetDatum(*bb)));
return fabs(INTERVAL_TO_SEC(i)); return fabs(INTERVAL_TO_SEC(i));
} }
@ -404,8 +397,8 @@ gbt_ts_ssup_cmp(Datum x, Datum y, SortSupport ssup)
/* for leaf items we expect lower == upper, so only compare lower */ /* for leaf items we expect lower == upper, so only compare lower */
return DatumGetInt32(DirectFunctionCall2(timestamp_cmp, return DatumGetInt32(DirectFunctionCall2(timestamp_cmp,
TimestampGetDatumFast(arg1->lower), TimestampGetDatum(arg1->lower),
TimestampGetDatumFast(arg2->lower))); TimestampGetDatum(arg2->lower)));
} }
Datum Datum

2
src/backend/access/common/tupdesc.c
Unescape View File

@ -993,7 +993,7 @@ TupleDescInitBuiltinEntry(TupleDesc desc,
case INT8OID: case INT8OID:
att->attlen = 8; att->attlen = 8;
att->attbyval = FLOAT8PASSBYVAL; att->attbyval = true;
att->attalign = TYPALIGN_DOUBLE; att->attalign = TYPALIGN_DOUBLE;
att->attstorage = TYPSTORAGE_PLAIN; att->attstorage = TYPSTORAGE_PLAIN;
att->attcompression = InvalidCompressionMethod; att->attcompression = InvalidCompressionMethod;

5
src/backend/access/index/indexam.c
Unescape View File

@ -986,11 +986,6 @@ index_store_float8_orderby_distances(IndexScanDesc scan, Oid *orderByTypes,
{ {
if (orderByTypes[i] == FLOAT8OID) if (orderByTypes[i] == FLOAT8OID)
{ {
#ifndef USE_FLOAT8_BYVAL
/* must free any old value to avoid memory leakage */
if (!scan->xs_orderbynulls[i])
pfree(DatumGetPointer(scan->xs_orderbyvals[i]));
#endif
if (distances && !distances[i].isnull) if (distances && !distances[i].isnull)
{ {
scan->xs_orderbyvals[i] = Float8GetDatum(distances[i].value); scan->xs_orderbyvals[i] = Float8GetDatum(distances[i].value);

20
src/backend/access/transam/xlog.c
Unescape View File

@ -4390,7 +4390,7 @@ WriteControlFile(void)
ControlFile->toast_max_chunk_size = TOAST_MAX_CHUNK_SIZE; ControlFile->toast_max_chunk_size = TOAST_MAX_CHUNK_SIZE;
ControlFile->loblksize = LOBLKSIZE; ControlFile->loblksize = LOBLKSIZE;
ControlFile->float8ByVal = FLOAT8PASSBYVAL; ControlFile->float8ByVal = true; /* vestigial */
/* /*
* Initialize the default 'char' signedness. * Initialize the default 'char' signedness.
@ -4651,23 +4651,7 @@ ReadControlFile(void)
"LOBLKSIZE", (int) LOBLKSIZE), "LOBLKSIZE", (int) LOBLKSIZE),
errhint("It looks like you need to recompile or initdb."))); errhint("It looks like you need to recompile or initdb.")));
#ifdef USE_FLOAT8_BYVAL Assert(ControlFile->float8ByVal); /* vestigial, not worth an error msg */
if (ControlFile->float8ByVal != true)
ereport(FATAL,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("database files are incompatible with server"),
errdetail("The database cluster was initialized without USE_FLOAT8_BYVAL"
" but the server was compiled with USE_FLOAT8_BYVAL."),
errhint("It looks like you need to recompile or initdb.")));
#else
if (ControlFile->float8ByVal != false)
ereport(FATAL,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("database files are incompatible with server"),
errdetail("The database cluster was initialized with USE_FLOAT8_BYVAL"
" but the server was compiled without USE_FLOAT8_BYVAL."),
errhint("It looks like you need to recompile or initdb.")));
#endif
wal_segment_size = ControlFile->xlog_seg_size; wal_segment_size = ControlFile->xlog_seg_size;

3
src/backend/catalog/genbki.pl
Unescape View File

@ -1054,8 +1054,7 @@ sub morph_row_for_schemapg
} }
# Expand booleans from 'f'/'t' to 'false'/'true'. # Expand booleans from 'f'/'t' to 'false'/'true'.
# Some values might be other macros (eg FLOAT8PASSBYVAL), # Some values might be other macros, if so don't change.
# don't change.
elsif ($atttype eq 'bool') elsif ($atttype eq 'bool')
{ {
$row->{$attname} = 'true' if $row->{$attname} eq 't'; $row->{$attname} = 'true' if $row->{$attname} eq 't';

2
src/backend/optimizer/plan/planagg.c
Unescape View File

@ -410,7 +410,7 @@ build_minmax_path(PlannerInfo *root, MinMaxAggInfo *mminfo,
parse->limitCount = (Node *) makeConst(INT8OID, -1, InvalidOid, parse->limitCount = (Node *) makeConst(INT8OID, -1, InvalidOid,
sizeof(int64), sizeof(int64),
Int64GetDatum(1), false, Int64GetDatum(1), false,
FLOAT8PASSBYVAL); true);
/* /*
* Generate the best paths for this query, telling query_planner that we * Generate the best paths for this query, telling query_planner that we

4
src/backend/optimizer/plan/planner.c
Unescape View File

@ -4915,7 +4915,7 @@ create_partial_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel,
limitCount = (Node *) makeConst(INT8OID, -1, InvalidOid, limitCount = (Node *) makeConst(INT8OID, -1, InvalidOid,
sizeof(int64), sizeof(int64),
Int64GetDatum(1), false, Int64GetDatum(1), false,
FLOAT8PASSBYVAL); true);
/* /*
* Apply a LimitPath onto the partial path to restrict the * Apply a LimitPath onto the partial path to restrict the
@ -5118,7 +5118,7 @@ create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel,
limitCount = (Node *) makeConst(INT8OID, -1, InvalidOid, limitCount = (Node *) makeConst(INT8OID, -1, InvalidOid,
sizeof(int64), sizeof(int64),
Int64GetDatum(1), false, Int64GetDatum(1), false,
FLOAT8PASSBYVAL); true);
/* /*
* If the query already has a LIMIT clause, then we could * If the query already has a LIMIT clause, then we could

2
src/backend/parser/parse_node.c
Unescape View File

@ -408,7 +408,7 @@ make_const(ParseState *pstate, A_Const *aconst)
typeid = INT8OID; typeid = INT8OID;
typelen = sizeof(int64); typelen = sizeof(int64);
typebyval = FLOAT8PASSBYVAL; /* int8 and float8 alike */ typebyval = true;
} }
} }
else else

2
src/backend/rewrite/rewriteSearchCycle.c
Unescape View File

@ -320,7 +320,7 @@ rewriteSearchAndCycle(CommonTableExpr *cte)
if (cte->search_clause->search_breadth_first) if (cte->search_clause->search_breadth_first)
{ {
search_col_rowexpr->args = lcons(makeConst(INT8OID, -1, InvalidOid, sizeof(int64), search_col_rowexpr->args = lcons(makeConst(INT8OID, -1, InvalidOid, sizeof(int64),
Int64GetDatum(0), false, FLOAT8PASSBYVAL), Int64GetDatum(0), false, true),
search_col_rowexpr->args); search_col_rowexpr->args);
search_col_rowexpr->colnames = lcons(makeString("*DEPTH*"), search_col_rowexpr->colnames); search_col_rowexpr->colnames = lcons(makeString("*DEPTH*"), search_col_rowexpr->colnames);
texpr = (Expr *) search_col_rowexpr; texpr = (Expr *) search_col_rowexpr;

6
src/backend/utils/adt/arrayfuncs.c
Unescape View File

@ -3406,7 +3406,7 @@ construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
case FLOAT8OID: case FLOAT8OID:
elmlen = sizeof(float8); elmlen = sizeof(float8);
elmbyval = FLOAT8PASSBYVAL; elmbyval = true;
elmalign = TYPALIGN_DOUBLE; elmalign = TYPALIGN_DOUBLE;
break; break;
@ -3424,7 +3424,7 @@ construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
case INT8OID: case INT8OID:
elmlen = sizeof(int64); elmlen = sizeof(int64);
elmbyval = FLOAT8PASSBYVAL; elmbyval = true;
elmalign = TYPALIGN_DOUBLE; elmalign = TYPALIGN_DOUBLE;
break; break;
@ -3718,7 +3718,7 @@ deconstruct_array_builtin(ArrayType *array,
case FLOAT8OID: case FLOAT8OID:
elmlen = sizeof(float8); elmlen = sizeof(float8);
elmbyval = FLOAT8PASSBYVAL; elmbyval = true;
elmalign = TYPALIGN_DOUBLE; elmalign = TYPALIGN_DOUBLE;
break; break;

75
src/backend/utils/adt/int8.c
Unescape View File

@ -718,76 +718,29 @@ int8lcm(PG_FUNCTION_ARGS)
Datum Datum
int8inc(PG_FUNCTION_ARGS) int8inc(PG_FUNCTION_ARGS)
{ {
/* int64 arg = PG_GETARG_INT64(0);
* When int8 is pass-by-reference, we provide this special case to avoid int64 result;
* palloc overhead for COUNT(): when called as an aggregate, we know that
* the argument is modifiable local storage, so just update it in-place.
* (If int8 is pass-by-value, then of course this is useless as well as
* incorrect, so just ifdef it out.)
*/
#ifndef USE_FLOAT8_BYVAL /* controls int8 too */
if (AggCheckCallContext(fcinfo, NULL))
{
int64 *arg = (int64 *) PG_GETARG_POINTER(0);
if (unlikely(pg_add_s64_overflow(*arg, 1, arg)))
ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("bigint out of range")));
PG_RETURN_POINTER(arg);
}
else
#endif
{
/* Not called as an aggregate, so just do it the dumb way */
int64 arg = PG_GETARG_INT64(0);
int64 result;
if (unlikely(pg_add_s64_overflow(arg, 1, &result))) if (unlikely(pg_add_s64_overflow(arg, 1, &result)))
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("bigint out of range"))); errmsg("bigint out of range")));
PG_RETURN_INT64(result); PG_RETURN_INT64(result);
}
} }
Datum Datum
int8dec(PG_FUNCTION_ARGS) int8dec(PG_FUNCTION_ARGS)
{ {
/* int64 arg = PG_GETARG_INT64(0);
* When int8 is pass-by-reference, we provide this special case to avoid int64 result;
* palloc overhead for COUNT(): when called as an aggregate, we know that
* the argument is modifiable local storage, so just update it in-place.
* (If int8 is pass-by-value, then of course this is useless as well as
* incorrect, so just ifdef it out.)
*/
#ifndef USE_FLOAT8_BYVAL /* controls int8 too */
if (AggCheckCallContext(fcinfo, NULL))
{
int64 *arg = (int64 *) PG_GETARG_POINTER(0);
if (unlikely(pg_sub_s64_overflow(*arg, 1, arg)))
ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("bigint out of range")));
PG_RETURN_POINTER(arg);
}
else
#endif
{
/* Not called as an aggregate, so just do it the dumb way */
int64 arg = PG_GETARG_INT64(0);
int64 result;
if (unlikely(pg_sub_s64_overflow(arg, 1, &result))) if (unlikely(pg_sub_s64_overflow(arg, 1, &result)))
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("bigint out of range"))); errmsg("bigint out of range")));
PG_RETURN_INT64(result); PG_RETURN_INT64(result);
}
} }

74
src/backend/utils/adt/numeric.c
Unescape View File

@ -6362,6 +6362,7 @@ numeric_poly_stddev_pop(PG_FUNCTION_ARGS)
Datum Datum
int2_sum(PG_FUNCTION_ARGS) int2_sum(PG_FUNCTION_ARGS)
{ {
int64 oldsum;
int64 newval; int64 newval;
if (PG_ARGISNULL(0)) if (PG_ARGISNULL(0))
@ -6374,43 +6375,22 @@ int2_sum(PG_FUNCTION_ARGS)
PG_RETURN_INT64(newval); PG_RETURN_INT64(newval);
} }
/* oldsum = PG_GETARG_INT64(0);
* If we're invoked as an aggregate, we can cheat and modify our first
* parameter in-place to avoid palloc overhead. If not, we need to return
* the new value of the transition variable. (If int8 is pass-by-value,
* then of course this is useless as well as incorrect, so just ifdef it
* out.)
*/
#ifndef USE_FLOAT8_BYVAL /* controls int8 too */
if (AggCheckCallContext(fcinfo, NULL))
{
int64 *oldsum = (int64 *) PG_GETARG_POINTER(0);
/* Leave the running sum unchanged in the new input is null */ /* Leave sum unchanged if new input is null. */
if (!PG_ARGISNULL(1)) if (PG_ARGISNULL(1))
*oldsum = *oldsum + (int64) PG_GETARG_INT16(1); PG_RETURN_INT64(oldsum);
PG_RETURN_POINTER(oldsum);
}
else
#endif
{
int64 oldsum = PG_GETARG_INT64(0);
/* Leave sum unchanged if new input is null. */
if (PG_ARGISNULL(1))
PG_RETURN_INT64(oldsum);
/* OK to do the addition. */ /* OK to do the addition. */
newval = oldsum + (int64) PG_GETARG_INT16(1); newval = oldsum + (int64) PG_GETARG_INT16(1);
PG_RETURN_INT64(newval); PG_RETURN_INT64(newval);
}
} }
Datum Datum
int4_sum(PG_FUNCTION_ARGS) int4_sum(PG_FUNCTION_ARGS)
{ {
int64 oldsum;
int64 newval; int64 newval;
if (PG_ARGISNULL(0)) if (PG_ARGISNULL(0))
@ -6423,38 +6403,16 @@ int4_sum(PG_FUNCTION_ARGS)
PG_RETURN_INT64(newval); PG_RETURN_INT64(newval);
} }
/* oldsum = PG_GETARG_INT64(0);
* If we're invoked as an aggregate, we can cheat and modify our first
* parameter in-place to avoid palloc overhead. If not, we need to return
* the new value of the transition variable. (If int8 is pass-by-value,
* then of course this is useless as well as incorrect, so just ifdef it
* out.)
*/
#ifndef USE_FLOAT8_BYVAL /* controls int8 too */
if (AggCheckCallContext(fcinfo, NULL))
{
int64 *oldsum = (int64 *) PG_GETARG_POINTER(0);
/* Leave the running sum unchanged in the new input is null */ /* Leave sum unchanged if new input is null. */
if (!PG_ARGISNULL(1)) if (PG_ARGISNULL(1))
*oldsum = *oldsum + (int64) PG_GETARG_INT32(1); PG_RETURN_INT64(oldsum);
PG_RETURN_POINTER(oldsum);
}
else
#endif
{
int64 oldsum = PG_GETARG_INT64(0);
/* Leave sum unchanged if new input is null. */
if (PG_ARGISNULL(1))
PG_RETURN_INT64(oldsum);
/* OK to do the addition. */ /* OK to do the addition. */
newval = oldsum + (int64) PG_GETARG_INT32(1); newval = oldsum + (int64) PG_GETARG_INT32(1);
PG_RETURN_INT64(newval); PG_RETURN_INT64(newval);
}
} }
/* /*

2
src/backend/utils/adt/orderedsetaggs.c
Unescape View File

@ -1007,7 +1007,7 @@ percentile_cont_float8_multi_final(PG_FUNCTION_ARGS)
FLOAT8OID, FLOAT8OID,
/* hard-wired info on type float8 */ /* hard-wired info on type float8 */
sizeof(float8), sizeof(float8),
FLOAT8PASSBYVAL, true,
TYPALIGN_DOUBLE, TYPALIGN_DOUBLE,
float8_lerp); float8_lerp);
} }

2
src/backend/utils/adt/rangetypes_typanalyze.c
Unescape View File

@ -397,7 +397,7 @@ compute_range_stats(VacAttrStats *stats, AnalyzeAttrFetchFunc fetchfunc,
stats->numvalues[slot_idx] = num_hist; stats->numvalues[slot_idx] = num_hist;
stats->statypid[slot_idx] = FLOAT8OID; stats->statypid[slot_idx] = FLOAT8OID;
stats->statyplen[slot_idx] = sizeof(float8); stats->statyplen[slot_idx] = sizeof(float8);
stats->statypbyval[slot_idx] = FLOAT8PASSBYVAL; stats->statypbyval[slot_idx] = true;
stats->statypalign[slot_idx] = 'd'; stats->statypalign[slot_idx] = 'd';
/* Store the fraction of empty ranges */ /* Store the fraction of empty ranges */

35
src/backend/utils/fmgr/fmgr.c
Unescape View File

@ -1788,41 +1788,6 @@ OidSendFunctionCall(Oid functionId, Datum val)
} }
/*-------------------------------------------------------------------------
* Support routines for standard maybe-pass-by-reference datatypes
*
* int8 and float8 can be passed by value if Datum is wide enough.
* (For backwards-compatibility reasons, we allow pass-by-ref to be chosen
* at compile time even if pass-by-val is possible.)
*
* Note: there is only one switch controlling the pass-by-value option for
* both int8 and float8; this is to avoid making things unduly complicated
* for the timestamp types, which might have either representation.
*-------------------------------------------------------------------------
*/
#ifndef USE_FLOAT8_BYVAL /* controls int8 too */
Datum
Int64GetDatum(int64 X)
{
int64 *retval = (int64 *) palloc(sizeof(int64));
*retval = X;
return PointerGetDatum(retval);
}
Datum
Float8GetDatum(float8 X)
{
float8 *retval = (float8 *) palloc(sizeof(float8));
*retval = X;
return PointerGetDatum(retval);
}
#endif /* USE_FLOAT8_BYVAL */
/*------------------------------------------------------------------------- /*-------------------------------------------------------------------------
* Support routines for toastable datatypes * Support routines for toastable datatypes
*------------------------------------------------------------------------- *-------------------------------------------------------------------------

3
src/bin/initdb/initdb.c
Unescape View File

@ -1580,9 +1580,6 @@ bootstrap_template1(void)
bki_lines = replace_token(bki_lines, "ALIGNOF_POINTER", bki_lines = replace_token(bki_lines, "ALIGNOF_POINTER",
(sizeof(Pointer) == 4) ? "i" : "d"); (sizeof(Pointer) == 4) ? "i" : "d");
bki_lines = replace_token(bki_lines, "FLOAT8PASSBYVAL",
FLOAT8PASSBYVAL ? "true" : "false");
bki_lines = replace_token(bki_lines, "POSTGRES", bki_lines = replace_token(bki_lines, "POSTGRES",
escape_quotes_bki(username)); escape_quotes_bki(username));

2
src/bin/pg_resetwal/pg_resetwal.c
Unescape View File

@ -719,7 +719,7 @@ GuessControlValues(void)
ControlFile.indexMaxKeys = INDEX_MAX_KEYS; ControlFile.indexMaxKeys = INDEX_MAX_KEYS;
ControlFile.toast_max_chunk_size = TOAST_MAX_CHUNK_SIZE; ControlFile.toast_max_chunk_size = TOAST_MAX_CHUNK_SIZE;
ControlFile.loblksize = LOBLKSIZE; ControlFile.loblksize = LOBLKSIZE;
ControlFile.float8ByVal = FLOAT8PASSBYVAL; ControlFile.float8ByVal = true; /* vestigial */
/* /*
* XXX eventually, should try to grovel through old XLOG to develop more * XXX eventually, should try to grovel through old XLOG to develop more

8
src/include/c.h
Unescape View File

@ -609,11 +609,11 @@ typedef signed int Offset;
typedef float float4; typedef float float4;
typedef double float8; typedef double float8;
#ifdef USE_FLOAT8_BYVAL /*
* float8, int8, and related datatypes are now always pass-by-value.
* We keep this symbol to avoid breaking extension code that may use it.
*/
#define FLOAT8PASSBYVAL true #define FLOAT8PASSBYVAL true
#else
#define FLOAT8PASSBYVAL false
#endif
/* /*
* Oid, RegProcedure, TransactionId, SubTransactionId, MultiXactId, * Oid, RegProcedure, TransactionId, SubTransactionId, MultiXactId,

16
src/include/catalog/pg_type.dat
Unescape View File

@ -54,7 +54,7 @@
typcollation => 'C' }, typcollation => 'C' },
{ oid => '20', array_type_oid => '1016', { oid => '20', array_type_oid => '1016',
descr => '~18 digit integer, 8-byte storage', descr => '~18 digit integer, 8-byte storage',
typname => 'int8', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', typname => 'int8', typlen => '8', typbyval => 't',
typcategory => 'N', typinput => 'int8in', typoutput => 'int8out', typcategory => 'N', typinput => 'int8in', typoutput => 'int8out',
typreceive => 'int8recv', typsend => 'int8send', typalign => 'd' }, typreceive => 'int8recv', typsend => 'int8send', typalign => 'd' },
{ oid => '21', array_type_oid => '1005', { oid => '21', array_type_oid => '1005',
@ -172,7 +172,7 @@
typoutput => 'pg_ddl_command_out', typreceive => 'pg_ddl_command_recv', typoutput => 'pg_ddl_command_out', typreceive => 'pg_ddl_command_recv',
typsend => 'pg_ddl_command_send', typalign => 'ALIGNOF_POINTER' }, typsend => 'pg_ddl_command_send', typalign => 'ALIGNOF_POINTER' },
{ oid => '5069', array_type_oid => '271', descr => 'full transaction id', { oid => '5069', array_type_oid => '271', descr => 'full transaction id',
typname => 'xid8', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', typname => 'xid8', typlen => '8', typbyval => 't',
typcategory => 'U', typinput => 'xid8in', typoutput => 'xid8out', typcategory => 'U', typinput => 'xid8in', typoutput => 'xid8out',
typreceive => 'xid8recv', typsend => 'xid8send', typalign => 'd' }, typreceive => 'xid8recv', typsend => 'xid8send', typalign => 'd' },
@ -222,7 +222,7 @@
typsend => 'float4send', typalign => 'i' }, typsend => 'float4send', typalign => 'i' },
{ oid => '701', array_type_oid => '1022', { oid => '701', array_type_oid => '1022',
descr => 'double-precision floating point number, 8-byte storage', descr => 'double-precision floating point number, 8-byte storage',
typname => 'float8', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', typname => 'float8', typlen => '8', typbyval => 't',
typcategory => 'N', typispreferred => 't', typinput => 'float8in', typcategory => 'N', typispreferred => 't', typinput => 'float8in',
typoutput => 'float8out', typreceive => 'float8recv', typsend => 'float8send', typoutput => 'float8out', typreceive => 'float8recv', typsend => 'float8send',
typalign => 'd' }, typalign => 'd' },
@ -237,7 +237,7 @@
typreceive => 'circle_recv', typsend => 'circle_send', typalign => 'd' }, typreceive => 'circle_recv', typsend => 'circle_send', typalign => 'd' },
{ oid => '790', array_type_oid => '791', { oid => '790', array_type_oid => '791',
descr => 'monetary amounts, $d,ddd.cc', descr => 'monetary amounts, $d,ddd.cc',
typname => 'money', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', typname => 'money', typlen => '8', typbyval => 't',
typcategory => 'N', typinput => 'cash_in', typoutput => 'cash_out', typcategory => 'N', typinput => 'cash_in', typoutput => 'cash_out',
typreceive => 'cash_recv', typsend => 'cash_send', typalign => 'd' }, typreceive => 'cash_recv', typsend => 'cash_send', typalign => 'd' },
@ -290,7 +290,7 @@
typinput => 'date_in', typoutput => 'date_out', typreceive => 'date_recv', typinput => 'date_in', typoutput => 'date_out', typreceive => 'date_recv',
typsend => 'date_send', typalign => 'i' }, typsend => 'date_send', typalign => 'i' },
{ oid => '1083', array_type_oid => '1183', descr => 'time of day', { oid => '1083', array_type_oid => '1183', descr => 'time of day',
typname => 'time', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', typname => 'time', typlen => '8', typbyval => 't',
typcategory => 'D', typinput => 'time_in', typoutput => 'time_out', typcategory => 'D', typinput => 'time_in', typoutput => 'time_out',
typreceive => 'time_recv', typsend => 'time_send', typmodin => 'timetypmodin', typreceive => 'time_recv', typsend => 'time_send', typmodin => 'timetypmodin',
typmodout => 'timetypmodout', typalign => 'd' }, typmodout => 'timetypmodout', typalign => 'd' },
@ -298,14 +298,14 @@
# OIDS 1100 - 1199 # OIDS 1100 - 1199
{ oid => '1114', array_type_oid => '1115', descr => 'date and time', { oid => '1114', array_type_oid => '1115', descr => 'date and time',
typname => 'timestamp', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', typname => 'timestamp', typlen => '8', typbyval => 't',
typcategory => 'D', typinput => 'timestamp_in', typoutput => 'timestamp_out', typcategory => 'D', typinput => 'timestamp_in', typoutput => 'timestamp_out',
typreceive => 'timestamp_recv', typsend => 'timestamp_send', typreceive => 'timestamp_recv', typsend => 'timestamp_send',
typmodin => 'timestamptypmodin', typmodout => 'timestamptypmodout', typmodin => 'timestamptypmodin', typmodout => 'timestamptypmodout',
typalign => 'd' }, typalign => 'd' },
{ oid => '1184', array_type_oid => '1185', { oid => '1184', array_type_oid => '1185',
descr => 'date and time with time zone', descr => 'date and time with time zone',
typname => 'timestamptz', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', typname => 'timestamptz', typlen => '8', typbyval => 't',
typcategory => 'D', typispreferred => 't', typinput => 'timestamptz_in', typcategory => 'D', typispreferred => 't', typinput => 'timestamptz_in',
typoutput => 'timestamptz_out', typreceive => 'timestamptz_recv', typoutput => 'timestamptz_out', typreceive => 'timestamptz_recv',
typsend => 'timestamptz_send', typmodin => 'timestamptztypmodin', typsend => 'timestamptz_send', typmodin => 'timestamptztypmodin',
@ -413,7 +413,7 @@
# pg_lsn # pg_lsn
{ oid => '3220', array_type_oid => '3221', descr => 'PostgreSQL LSN', { oid => '3220', array_type_oid => '3221', descr => 'PostgreSQL LSN',
typname => 'pg_lsn', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', typname => 'pg_lsn', typlen => '8', typbyval => 't',
typcategory => 'U', typinput => 'pg_lsn_in', typoutput => 'pg_lsn_out', typcategory => 'U', typinput => 'pg_lsn_in', typoutput => 'pg_lsn_out',
typreceive => 'pg_lsn_recv', typsend => 'pg_lsn_send', typalign => 'd' }, typreceive => 'pg_lsn_recv', typsend => 'pg_lsn_send', typalign => 'd' },

2
src/include/fmgr.h
Unescape View File

@ -469,7 +469,7 @@ typedef struct
int funcmaxargs; /* FUNC_MAX_ARGS */ int funcmaxargs; /* FUNC_MAX_ARGS */
int indexmaxkeys; /* INDEX_MAX_KEYS */ int indexmaxkeys; /* INDEX_MAX_KEYS */
int namedatalen; /* NAMEDATALEN */ int namedatalen; /* NAMEDATALEN */
int float8byval; /* FLOAT8PASSBYVAL */ int float8byval; /* FLOAT8PASSBYVAL (now vestigial) */
char abi_extra[32]; /* see pg_config_manual.h */ char abi_extra[32]; /* see pg_config_manual.h */
} Pg_abi_values; } Pg_abi_values;

58
src/include/postgres.h
Unescape View File

@ -388,68 +388,41 @@ NameGetDatum(const NameData *X)
/* /*
* DatumGetInt64 * DatumGetInt64
* Returns 64-bit integer value of a datum. * Returns 64-bit integer value of a datum.
*
* Note: this function hides whether int64 is pass by value or by reference.
*/ */
static inline int64 static inline int64
DatumGetInt64(Datum X) DatumGetInt64(Datum X)
{ {
#ifdef USE_FLOAT8_BYVAL
return (int64) X; return (int64) X;
#else
return *((int64 *) DatumGetPointer(X));
#endif
} }
/* /*
* Int64GetDatum * Int64GetDatum
* Returns datum representation for a 64-bit integer. * Returns datum representation for a 64-bit integer.
*
* Note: if int64 is pass by reference, this function returns a reference
* to palloc'd space.
*/ */
#ifdef USE_FLOAT8_BYVAL
static inline Datum static inline Datum
Int64GetDatum(int64 X) Int64GetDatum(int64 X)
{ {
return (Datum) X; return (Datum) X;
} }
#else
extern Datum Int64GetDatum(int64 X);
#endif
/* /*
* DatumGetUInt64 * DatumGetUInt64
* Returns 64-bit unsigned integer value of a datum. * Returns 64-bit unsigned integer value of a datum.
*
* Note: this function hides whether int64 is pass by value or by reference.
*/ */
static inline uint64 static inline uint64
DatumGetUInt64(Datum X) DatumGetUInt64(Datum X)
{ {
#ifdef USE_FLOAT8_BYVAL
return (uint64) X; return (uint64) X;
#else
return *((uint64 *) DatumGetPointer(X));
#endif
} }
/* /*
* UInt64GetDatum * UInt64GetDatum
* Returns datum representation for a 64-bit unsigned integer. * Returns datum representation for a 64-bit unsigned integer.
*
* Note: if int64 is pass by reference, this function returns a reference
* to palloc'd space.
*/ */
static inline Datum static inline Datum
UInt64GetDatum(uint64 X) UInt64GetDatum(uint64 X)
{ {
#ifdef USE_FLOAT8_BYVAL
return (Datum) X; return (Datum) X;
#else
return Int64GetDatum((int64) X);
#endif
} }
/* /*
@ -497,13 +470,10 @@ Float4GetDatum(float4 X)
/* /*
* DatumGetFloat8 * DatumGetFloat8
* Returns 8-byte floating point value of a datum. * Returns 8-byte floating point value of a datum.
*
* Note: this function hides whether float8 is pass by value or by reference.
*/ */
static inline float8 static inline float8
DatumGetFloat8(Datum X) DatumGetFloat8(Datum X)
{ {
#ifdef USE_FLOAT8_BYVAL
union union
{ {
int64 value; int64 value;
@ -512,19 +482,12 @@ DatumGetFloat8(Datum X)
myunion.value = DatumGetInt64(X); myunion.value = DatumGetInt64(X);
return myunion.retval; return myunion.retval;
#else
return *((float8 *) DatumGetPointer(X));
#endif
} }
/* /*
* Float8GetDatum * Float8GetDatum
* Returns datum representation for an 8-byte floating point number. * Returns datum representation for an 8-byte floating point number.
*
* Note: if float8 is pass by reference, this function returns a reference
* to palloc'd space.
*/ */
#ifdef USE_FLOAT8_BYVAL
static inline Datum static inline Datum
Float8GetDatum(float8 X) Float8GetDatum(float8 X)
{ {
@ -537,35 +500,22 @@ Float8GetDatum(float8 X)
myunion.value = X; myunion.value = X;
return Int64GetDatum(myunion.retval); return Int64GetDatum(myunion.retval);
} }
#else
extern Datum Float8GetDatum(float8 X);
#endif
/* /*
* Int64GetDatumFast * Int64GetDatumFast
* Float8GetDatumFast * Float8GetDatumFast
* *
* These macros are intended to allow writing code that does not depend on * These macros were intended to allow writing code that does not depend on
* whether int64 and float8 are pass-by-reference types, while not * whether int64 and float8 are pass-by-reference types, while not
* sacrificing performance when they are. The argument must be a variable * sacrificing performance when they are. They are no longer different
* that will exist and have the same value for as long as the Datum is needed. * from the regular functions, though we keep the assertions to protect
* In the pass-by-ref case, the address of the variable is taken to use as * code that might get back-patched into older branches.
* the Datum. In the pass-by-val case, these are the same as the non-Fast
* functions, except for asserting that the variable is of the correct type.
*/ */
#ifdef USE_FLOAT8_BYVAL
#define Int64GetDatumFast(X) \ #define Int64GetDatumFast(X) \
(AssertVariableIsOfTypeMacro(X, int64), Int64GetDatum(X)) (AssertVariableIsOfTypeMacro(X, int64), Int64GetDatum(X))
#define Float8GetDatumFast(X) \ #define Float8GetDatumFast(X) \
(AssertVariableIsOfTypeMacro(X, double), Float8GetDatum(X)) (AssertVariableIsOfTypeMacro(X, double), Float8GetDatum(X))
#else
#define Int64GetDatumFast(X) \
(AssertVariableIsOfTypeMacro(X, int64), PointerGetDatum(&(X)))
#define Float8GetDatumFast(X) \
(AssertVariableIsOfTypeMacro(X, double), PointerGetDatum(&(X)))
#endif
/* ---------------------------------------------------------------- /* ----------------------------------------------------------------

Write Preview
Loading…
Cancel
Save