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

Code review for protransform patches.

Browse Source 
Fix loss of previous expression-simplification work when a transform
function fires: we must not simply revert to untransformed input tree.
Instead build a dummy FuncExpr node to pass to the transform function.
This has the additional advantage of providing a simpler, more uniform
API for transform functions.

Move documentation to a somewhat less buried spot, relocate some
poorly-placed code, be more wary of null constants and invalid typmod
values, add an opr_sanity check on protransform function signatures,
and some other minor cosmetic adjustments.

Note: although this patch touches pg_proc.h, no need for catversion
bump, because the changes are cosmetic and don't actually change the
intended catalog contents.
pull/3/head
Tom Lane 14 years ago
parent e08b4101e1
commit 0339047bc9
15 changed files with 205 additions and 172 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. 3
      doc/src/sgml/catalogs.sgml
  2. 34
      doc/src/sgml/xfunc.sgml
  3. 29
      src/backend/nodes/nodeFuncs.c
  4. 115
      src/backend/optimizer/util/clauses.c
  5. 22
      src/backend/parser/parse_clause.c
  6. 29
      src/backend/utils/adt/datetime.c
  7. 23
      src/backend/utils/adt/numeric.c
  8. 30
      src/backend/utils/adt/timestamp.c
  9. 23
      src/backend/utils/adt/varbit.c
  10. 26
      src/backend/utils/adt/varchar.c
  11. 23
      src/include/catalog/pg_proc.h
  12. 1
      src/include/nodes/nodeFuncs.h
  13. 2
      src/include/parser/parse_clause.h
  14. 10
      src/test/regress/expected/opr_sanity.out
  15. 7
      src/test/regress/sql/opr_sanity.sql

3
doc/src/sgml/catalogs.sgml
Unescape View File

@ -4398,7 +4398,8 @@
<entry><structfield>protransform</structfield></entry> <entry><structfield>protransform</structfield></entry>
<entry><type>regproc</type></entry> <entry><type>regproc</type></entry>
<entry><literal><link linkend="catalog-pg-proc"><structname>pg_proc</structname></link>.oid</literal></entry> <entry><literal><link linkend="catalog-pg-proc"><structname>pg_proc</structname></link>.oid</literal></entry>
<entry>Calls to function can be simplified by this other function</entry> <entry>Calls to this function can be simplified by this other function
(see <xref linkend="xfunc-transform-functions">)</entry>
</row> </row>
<row> <row>

34
doc/src/sgml/xfunc.sgml
Unescape View File

@ -3177,6 +3177,40 @@ CREATE FUNCTION make_array(anyelement) RETURNS anyarray
</para> </para>
</sect2> </sect2>
<sect2 id="xfunc-transform-functions">
<title>Transform Functions</title>
<para>
Some function calls can be simplified during planning based on
properties specific to the function. For example,
<literal>int4mul(n, 1)</> could be simplified to just <literal>n</>.
To define such function-specific optimizations, write a
<firstterm>transform function</> and place its OID in the
<structfield>protransform</> field of the primary function's
<structname>pg_proc</> entry. The transform function must have the SQL
signature <literal>protransform(internal) RETURNS internal</>. The
argument, actually <type>FuncExpr *</>, is a dummy node representing a
call to the primary function. If the transform function's study of the
expression tree proves that a simplified expression tree can substitute
for all possible concrete calls represented thereby, build and return
that simplified expression. Otherwise, return a <literal>NULL</>
pointer (<emphasis>not</> a SQL null).
</para>
<para>
We make no guarantee that <productname>PostgreSQL</> will never call the
primary function in cases that the transform function could simplify.
Ensure rigorous equivalence between the simplified expression and an
actual call to the primary function.
</para>
<para>
Currently, this facility is not exposed to users at the SQL level
because of security concerns, so it is only practical to use for
optimizing built-in functions.
</para>
</sect2>
<sect2> <sect2>
<title>Shared Memory and LWLocks</title> <title>Shared Memory and LWLocks</title>

29
src/backend/nodes/nodeFuncs.c
Unescape View File

@ -17,6 +17,7 @@
#include "catalog/pg_collation.h" #include "catalog/pg_collation.h"
#include "catalog/pg_type.h" #include "catalog/pg_type.h"
#include "miscadmin.h" #include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h" #include "nodes/nodeFuncs.h"
#include "nodes/relation.h" #include "nodes/relation.h"
#include "utils/builtins.h" #include "utils/builtins.h"
@ -547,6 +548,30 @@ exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod)
return false; return false;
} }
/*
* relabel_to_typmod
* Add a RelabelType node that changes just the typmod of the expression.
*
* This is primarily intended to be used during planning. Therefore, it
* strips any existing RelabelType nodes to maintain the planner's invariant
* that there are not adjacent RelabelTypes, and it uses COERCE_DONTCARE
* which would typically be inappropriate earlier.
*/
Node *
relabel_to_typmod(Node *expr, int32 typmod)
{
Oid type = exprType(expr);
Oid coll = exprCollation(expr);
/* Strip any existing RelabelType node(s) */
while (expr && IsA(expr, RelabelType))
expr = (Node *) ((RelabelType *) expr)->arg;
/* Apply new typmod, preserving the previous exposed type and collation */
return (Node *) makeRelabelType((Expr *) expr, type, typmod, coll,
COERCE_DONTCARE);
}
/* /*
* expression_returns_set * expression_returns_set
* Test whether an expression returns a set result. * Test whether an expression returns a set result.
@ -2694,7 +2719,9 @@ query_or_expression_tree_mutator(Node *node,
* that could appear under it, but not other statement types. * that could appear under it, but not other statement types.
*/ */
bool bool
raw_expression_tree_walker(Node *node, bool (*walker) (), void *context) raw_expression_tree_walker(Node *node,
bool (*walker) (),
void *context)
{ {
ListCell *temp; ListCell *temp;

115
src/backend/optimizer/util/clauses.c
Unescape View File

@ -107,11 +107,11 @@ static List *simplify_and_arguments(List *args,
eval_const_expressions_context *context, eval_const_expressions_context *context,
bool *haveNull, bool *forceFalse); bool *haveNull, bool *forceFalse);
static Node *simplify_boolean_equality(Oid opno, List *args); static Node *simplify_boolean_equality(Oid opno, List *args);
static Expr *simplify_function(Expr *oldexpr, Oid funcid, static Expr *simplify_function(Oid funcid,
Oid result_type, int32 result_typmod, Oid result_collid, Oid result_type, int32 result_typmod,
Oid input_collid, List **args, Oid result_collid, Oid input_collid, List **args,
bool has_named_args, bool has_named_args,
bool allow_inline, bool allow_non_const,
eval_const_expressions_context *context); eval_const_expressions_context *context);
static List *reorder_function_arguments(List *args, Oid result_type, static List *reorder_function_arguments(List *args, Oid result_type,
HeapTuple func_tuple, HeapTuple func_tuple,
@ -2332,8 +2332,7 @@ eval_const_expressions_mutator(Node *node,
* length coercion; we want to preserve the typmod in the * length coercion; we want to preserve the typmod in the
* eventual Const if so. * eventual Const if so.
*/ */
simple = simplify_function((Expr *) expr, simple = simplify_function(expr->funcid,
expr->funcid,
expr->funcresulttype, expr->funcresulttype,
exprTypmod(node), exprTypmod(node),
expr->funccollid, expr->funccollid,
@ -2389,8 +2388,7 @@ eval_const_expressions_mutator(Node *node,
* Code for op/func reduction is pretty bulky, so split it out * Code for op/func reduction is pretty bulky, so split it out
* as a separate function. * as a separate function.
*/ */
simple = simplify_function((Expr *) expr, simple = simplify_function(expr->opfuncid,
expr->opfuncid,
expr->opresulttype, -1, expr->opresulttype, -1,
expr->opcollid, expr->opcollid,
expr->inputcollid, expr->inputcollid,
@ -2491,8 +2489,7 @@ eval_const_expressions_mutator(Node *node,
* Code for op/func reduction is pretty bulky, so split it * Code for op/func reduction is pretty bulky, so split it
* out as a separate function. * out as a separate function.
*/ */
simple = simplify_function((Expr *) expr, simple = simplify_function(expr->opfuncid,
expr->opfuncid,
expr->opresulttype, -1, expr->opresulttype, -1,
expr->opcollid, expr->opcollid,
expr->inputcollid, expr->inputcollid,
@ -2698,8 +2695,7 @@ eval_const_expressions_mutator(Node *node,
getTypeInputInfo(expr->resulttype, getTypeInputInfo(expr->resulttype,
&infunc, &intypioparam); &infunc, &intypioparam);
simple = simplify_function(NULL, simple = simplify_function(outfunc,
outfunc,
CSTRINGOID, -1, CSTRINGOID, -1,
InvalidOid, InvalidOid,
InvalidOid, InvalidOid,
@ -2728,8 +2724,7 @@ eval_const_expressions_mutator(Node *node,
false, false,
true)); true));
simple = simplify_function(NULL, simple = simplify_function(infunc,
infunc,
expr->resulttype, -1, expr->resulttype, -1,
expr->resultcollid, expr->resultcollid,
InvalidOid, InvalidOid,
@ -3581,15 +3576,11 @@ simplify_boolean_equality(Oid opno, List *args)
* Subroutine for eval_const_expressions: try to simplify a function call * Subroutine for eval_const_expressions: try to simplify a function call
* (which might originally have been an operator; we don't care) * (which might originally have been an operator; we don't care)
* *
* Inputs are the original expression (can be NULL), function OID, actual * Inputs are the function OID, actual result type OID (which is needed for
* result type OID (which is needed for polymorphic functions), result typmod, * polymorphic functions), result typmod, result collation,
* result collation, the input collation to use for the function, the * the input collation to use for the function,
* pre-simplified argument list, and some flags; also the context data for * the pre-simplified argument list, and some flags;
* eval_const_expressions. In common cases, several of the arguments could be * also the context data for eval_const_expressions.
* derived from the original expression. Sending them separately avoids
* duplicating NodeTag-specific knowledge, and it's necessary for CoerceViaIO.
* A NULL original expression disables use of transform functions while
* retaining all other behaviors.
* *
* Returns a simplified expression if successful, or NULL if cannot * Returns a simplified expression if successful, or NULL if cannot
* simplify the function call. * simplify the function call.
@ -3601,28 +3592,32 @@ simplify_boolean_equality(Oid opno, List *args)
* pass-by-reference, and it may get modified even if simplification fails. * pass-by-reference, and it may get modified even if simplification fails.
*/ */
static Expr * static Expr *
simplify_function(Expr *oldexpr, Oid funcid, simplify_function(Oid funcid, Oid result_type, int32 result_typmod,
Oid result_type, int32 result_typmod, Oid result_collid, Oid result_collid, Oid input_collid, List **args,
Oid input_collid, List **args,
bool has_named_args, bool has_named_args,
bool allow_inline, bool allow_non_const,
eval_const_expressions_context *context) eval_const_expressions_context *context)
{ {
HeapTuple func_tuple; HeapTuple func_tuple;
Form_pg_proc func_form;
Expr *newexpr; Expr *newexpr;
Oid transform;
/* /*
* We have three strategies for simplification: execute the function to * We have three strategies for simplification: execute the function to
* deliver a constant result, use a transform function to generate a * deliver a constant result, use a transform function to generate a
* substitute node tree, or expand in-line the body of the function * substitute node tree, or expand in-line the body of the function
* definition (which only works for simple SQL-language functions, but * definition (which only works for simple SQL-language functions, but
* that is a common case). Each needs access to the function's pg_proc * that is a common case). Each case needs access to the function's
* tuple, so fetch it just once. * pg_proc tuple, so fetch it just once.
*
* Note: the allow_non_const flag suppresses both the second and third
* strategies; so if !allow_non_const, simplify_function can only return
* a Const or NULL. Argument-list rewriting happens anyway, though.
*/ */
func_tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid)); func_tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
if (!HeapTupleIsValid(func_tuple)) if (!HeapTupleIsValid(func_tuple))
elog(ERROR, "cache lookup failed for function %u", funcid); elog(ERROR, "cache lookup failed for function %u", funcid);
func_form = (Form_pg_proc) GETSTRUCT(func_tuple);
/* /*
* While we have the tuple, reorder named arguments and add default * While we have the tuple, reorder named arguments and add default
@ -3631,48 +3626,38 @@ simplify_function(Expr *oldexpr, Oid funcid,
if (has_named_args) if (has_named_args)
*args = reorder_function_arguments(*args, result_type, func_tuple, *args = reorder_function_arguments(*args, result_type, func_tuple,
context); context);
else if (((Form_pg_proc) GETSTRUCT(func_tuple))->pronargs > list_length(*args)) else if (func_form->pronargs > list_length(*args))
*args = add_function_defaults(*args, result_type, func_tuple, context); *args = add_function_defaults(*args, result_type, func_tuple, context);
newexpr = evaluate_function(funcid, result_type, result_typmod, newexpr = evaluate_function(funcid, result_type, result_typmod,
result_collid, input_collid, *args, result_collid, input_collid, *args,
func_tuple, context); func_tuple, context);
/* if (!newexpr && allow_non_const && OidIsValid(func_form->protransform))
* Some functions calls can be simplified at plan time based on properties {
* specific to the function. For example, "varchar(s::varchar(4), 8, /*
* true)" simplifies to "s::varchar(4)", and "int4mul(n, 1)" could * Build a dummy FuncExpr node containing the simplified arg list. We
* simplify to "n". To define such function-specific optimizations, write * use this approach to present a uniform interface to the transform
* a "transform function" and store its OID in the pg_proc.protransform of * function regardless of how the function is actually being invoked.
* the primary function. Give each transform function the signature */
* "protransform(internal) RETURNS internal". The argument, internally an FuncExpr fexpr;
* Expr *, is the node representing a call to the primary function. If
* the transform function's study of that node proves that a simplified fexpr.xpr.type = T_FuncExpr;
* Expr substitutes for all possible concrete calls represented thereby, fexpr.funcid = funcid;
* return that simplified Expr. Otherwise, return the NULL pointer. fexpr.funcresulttype = result_type;
* fexpr.funcretset = func_form->proretset;
* Currently, the specific Expr nodetag can be FuncExpr, OpExpr or fexpr.funcformat = COERCE_DONTCARE;
* DistinctExpr. This list may change in the future. The function should fexpr.funccollid = result_collid;
* check the nodetag and return the NULL pointer for unexpected inputs. fexpr.inputcollid = input_collid;
* fexpr.args = *args;
* We make no guarantee that PostgreSQL will never call the primary fexpr.location = -1;
* function in cases that the transform function would simplify. Ensure
* rigorous equivalence between the simplified expression and an actual newexpr = (Expr *)
* call to the primary function. DatumGetPointer(OidFunctionCall1(func_form->protransform,
* PointerGetDatum(&fexpr)));
* Currently, this facility is undocumented and not exposed to users at }
* the SQL level. Core length coercion casts use it to avoid calls
* guaranteed to return their input unchanged. This in turn allows ALTER
* TABLE ALTER TYPE to avoid rewriting tables for some typmod changes. In
* the future, this facility may find other applications, like simplifying
* x*0, x*1, and x+0.
*/
transform = ((Form_pg_proc) GETSTRUCT(func_tuple))->protransform;
if (!newexpr && OidIsValid(transform) && oldexpr)
newexpr = (Expr *) DatumGetPointer(OidFunctionCall1(transform,
PointerGetDatum(oldexpr)));
if (!newexpr && allow_inline) if (!newexpr && allow_non_const)
newexpr = inline_function(funcid, result_type, result_collid, newexpr = inline_function(funcid, result_type, result_collid,
input_collid, *args, input_collid, *args,
func_tuple, context); func_tuple, context);

22
src/backend/parser/parse_clause.c
Unescape View File

@ -2271,25 +2271,3 @@ transformFrameOffset(ParseState *pstate, int frameOptions, Node *clause)
return node; return node;
} }
/*
* relabel_to_typmod
* Add a RelabelType node that changes just the typmod, and remove all
* now-superfluous RelabelType nodes beneath it.
*/
Node *
relabel_to_typmod(Node *expr, int32 typmod)
{
Oid type = exprType(expr);
Oid coll = exprCollation(expr);
/*
* Strip any existing RelabelType, then add one. This is to preserve the
* invariant of no redundant RelabelTypes.
*/
while (IsA(expr, RelabelType))
expr = (Node *) ((RelabelType *) expr)->arg;
return (Node *) makeRelabelType((Expr *) expr, type, typmod, coll,
COERCE_DONTCARE);
}

29
src/backend/utils/adt/datetime.c
Unescape View File

@ -24,7 +24,6 @@
#include "funcapi.h" #include "funcapi.h"
#include "miscadmin.h" #include "miscadmin.h"
#include "nodes/nodeFuncs.h" #include "nodes/nodeFuncs.h"
#include "parser/parse_clause.h"
#include "utils/builtins.h" #include "utils/builtins.h"
#include "utils/date.h" #include "utils/date.h"
#include "utils/datetime.h" #include "utils/datetime.h"
@ -4153,32 +4152,34 @@ CheckDateTokenTables(void)
} }
/* /*
* Helper for temporal protransform functions. Types time, timetz, timestamp * Common code for temporal protransform functions. Types time, timetz,
* and timestamptz each have a range of allowed precisions. An unspecified * timestamp and timestamptz each have a range of allowed precisions. An
* precision is rigorously equivalent to the highest specifiable precision. * unspecified precision is rigorously equivalent to the highest specifiable
* precision.
*
* Note: timestamp_scale throws an error when the typmod is out of range, but
* we can't get there from a cast: our typmodin will have caught it already.
*/ */
Node * Node *
TemporalTransform(int32 max_precis, Node *node) TemporalTransform(int32 max_precis, Node *node)
{ {
FuncExpr *expr = (FuncExpr *) node; FuncExpr *expr = (FuncExpr *) node;
Node *typmod;
Node *ret = NULL; Node *ret = NULL;
Node *typmod;
if (!IsA(expr, FuncExpr)) Assert(IsA(expr, FuncExpr));
return ret; Assert(list_length(expr->args) >= 2);
Assert(list_length(expr->args) == 2); typmod = (Node *) lsecond(expr->args);
typmod = lsecond(expr->args);
if (IsA(typmod, Const)) if (IsA(typmod, Const) && !((Const *) typmod)->constisnull)
{ {
Node *source = linitial(expr->args); Node *source = (Node *) linitial(expr->args);
int32 old_precis = exprTypmod(source); int32 old_precis = exprTypmod(source);
int32 new_precis = DatumGetInt32(((Const *) typmod)->constvalue); int32 new_precis = DatumGetInt32(((Const *) typmod)->constvalue);
if (new_precis == -1 || if (new_precis < 0 || new_precis == max_precis ||
new_precis == max_precis || (old_precis >= 0 && new_precis >= old_precis))
(old_precis != -1 && new_precis >= old_precis))
ret = relabel_to_typmod(source, new_precis); ret = relabel_to_typmod(source, new_precis);
} }

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

@ -31,7 +31,6 @@
#include "libpq/pqformat.h" #include "libpq/pqformat.h"
#include "miscadmin.h" #include "miscadmin.h"
#include "nodes/nodeFuncs.h" #include "nodes/nodeFuncs.h"
#include "parser/parse_clause.h"
#include "utils/array.h" #include "utils/array.h"
#include "utils/builtins.h" #include "utils/builtins.h"
#include "utils/int8.h" #include "utils/int8.h"
@ -717,7 +716,7 @@ numeric_send(PG_FUNCTION_ARGS)
/* /*
* numeric_transform() - * numeric_transform() -
* *
* Flatten calls to our length coercion function that solely represent * Flatten calls to numeric's length coercion function that solely represent
* increases in allowable precision. Scale changes mutate every datum, so * increases in allowable precision. Scale changes mutate every datum, so
* they are unoptimizable. Some values, e.g. 1E-1001, can only fit into an * they are unoptimizable. Some values, e.g. 1E-1001, can only fit into an
* unconstrained numeric, so a change from an unconstrained numeric to any * unconstrained numeric, so a change from an unconstrained numeric to any
@ -727,18 +726,17 @@ Datum
numeric_transform(PG_FUNCTION_ARGS) numeric_transform(PG_FUNCTION_ARGS)
{ {
FuncExpr *expr = (FuncExpr *) PG_GETARG_POINTER(0); FuncExpr *expr = (FuncExpr *) PG_GETARG_POINTER(0);
Node *typmod;
Node *ret = NULL; Node *ret = NULL;
Node *typmod;
if (!IsA(expr, FuncExpr)) Assert(IsA(expr, FuncExpr));
PG_RETURN_POINTER(ret); Assert(list_length(expr->args) >= 2);
Assert(list_length(expr->args) == 2); typmod = (Node *) lsecond(expr->args);
typmod = lsecond(expr->args);
if (IsA(typmod, Const)) if (IsA(typmod, Const) && !((Const *) typmod)->constisnull)
{ {
Node *source = linitial(expr->args); Node *source = (Node *) linitial(expr->args);
int32 old_typmod = exprTypmod(source); int32 old_typmod = exprTypmod(source);
int32 new_typmod = DatumGetInt32(((Const *) typmod)->constvalue); int32 new_typmod = DatumGetInt32(((Const *) typmod)->constvalue);
int32 old_scale = (old_typmod - VARHDRSZ) & 0xffff; int32 old_scale = (old_typmod - VARHDRSZ) & 0xffff;
@ -748,11 +746,12 @@ numeric_transform(PG_FUNCTION_ARGS)
/* /*
* If new_typmod < VARHDRSZ, the destination is unconstrained; that's * If new_typmod < VARHDRSZ, the destination is unconstrained; that's
* always OK. If old_typmod >= VARHDRSZ, the source is constrained. * always OK. If old_typmod >= VARHDRSZ, the source is constrained,
* and we're OK if the scale is unchanged and the precison is not * and we're OK if the scale is unchanged and the precision is not
* decreasing. See further notes in function header comment. * decreasing. See further notes in function header comment.
*/ */
if (new_typmod < VARHDRSZ || (old_typmod >= VARHDRSZ && if (new_typmod < (int32) VARHDRSZ ||
(old_typmod >= (int32) VARHDRSZ &&
new_scale == old_scale && new_precision >= old_precision)) new_scale == old_scale && new_precision >= old_precision))
ret = relabel_to_typmod(source, new_typmod); ret = relabel_to_typmod(source, new_typmod);
} }

30
src/backend/utils/adt/timestamp.c
Unescape View File

@ -28,7 +28,6 @@
#include "libpq/pqformat.h" #include "libpq/pqformat.h"
#include "miscadmin.h" #include "miscadmin.h"
#include "nodes/nodeFuncs.h" #include "nodes/nodeFuncs.h"
#include "parser/parse_clause.h"
#include "parser/scansup.h" #include "parser/scansup.h"
#include "utils/array.h" #include "utils/array.h"
#include "utils/builtins.h" #include "utils/builtins.h"
@ -316,10 +315,6 @@ timestamptypmodout(PG_FUNCTION_ARGS)
Datum Datum
timestamp_transform(PG_FUNCTION_ARGS) timestamp_transform(PG_FUNCTION_ARGS)
{ {
/*
* timestamp_scale throws an error when the typmod is out of range, but we
* can't get there from a cast: our typmodin will have caught it already.
*/
PG_RETURN_POINTER(TemporalTransform(MAX_TIMESTAMP_PRECISION, PG_RETURN_POINTER(TemporalTransform(MAX_TIMESTAMP_PRECISION,
(Node *) PG_GETARG_POINTER(0))); (Node *) PG_GETARG_POINTER(0)));
} }
@ -937,18 +932,17 @@ Datum
interval_transform(PG_FUNCTION_ARGS) interval_transform(PG_FUNCTION_ARGS)
{ {
FuncExpr *expr = (FuncExpr *) PG_GETARG_POINTER(0); FuncExpr *expr = (FuncExpr *) PG_GETARG_POINTER(0);
Node *typmod;
Node *ret = NULL; Node *ret = NULL;
Node *typmod;
if (!IsA(expr, FuncExpr)) Assert(IsA(expr, FuncExpr));
PG_RETURN_POINTER(ret); Assert(list_length(expr->args) >= 2);
Assert(list_length(expr->args) == 2); typmod = (Node *) lsecond(expr->args);
typmod = lsecond(expr->args);
if (IsA(typmod, Const)) if (IsA(typmod, Const) && !((Const *) typmod)->constisnull)
{ {
Node *source = linitial(expr->args); Node *source = (Node *) linitial(expr->args);
int32 old_typmod = exprTypmod(source); int32 old_typmod = exprTypmod(source);
int32 new_typmod = DatumGetInt32(((Const *) typmod)->constvalue); int32 new_typmod = DatumGetInt32(((Const *) typmod)->constvalue);
int old_range; int old_range;
@ -958,7 +952,7 @@ interval_transform(PG_FUNCTION_ARGS)
int new_range_fls; int new_range_fls;
int old_range_fls; int old_range_fls;
if (old_typmod == -1) if (old_typmod < 0)
{ {
old_range = INTERVAL_FULL_RANGE; old_range = INTERVAL_FULL_RANGE;
old_precis = INTERVAL_FULL_PRECISION; old_precis = INTERVAL_FULL_PRECISION;
@ -978,11 +972,9 @@ interval_transform(PG_FUNCTION_ARGS)
*/ */
new_range_fls = fls(new_range); new_range_fls = fls(new_range);
old_range_fls = fls(old_range); old_range_fls = fls(old_range);
if (new_typmod == -1 || if (new_typmod < 0 ||
((new_range_fls >= SECOND || ((new_range_fls >= SECOND || new_range_fls >= old_range_fls) &&
new_range_fls >= old_range_fls) && (old_range_fls < SECOND || new_precis >= MAX_INTERVAL_PRECISION ||
(old_range_fls < SECOND ||
new_precis >= MAX_INTERVAL_PRECISION ||
new_precis >= old_precis))) new_precis >= old_precis)))
ret = relabel_to_typmod(source, new_typmod); ret = relabel_to_typmod(source, new_typmod);
} }
@ -1068,7 +1060,7 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
* can't do it consistently. (We cannot enforce a range limit on the * can't do it consistently. (We cannot enforce a range limit on the
* highest expected field, since we do not have any equivalent of * highest expected field, since we do not have any equivalent of
* SQL's <interval leading field precision>.) If we ever decide to * SQL's <interval leading field precision>.) If we ever decide to
* revisit this, interval_transform will likely requite adjusting. * revisit this, interval_transform will likely require adjusting.
* *
* Note: before PG 8.4 we interpreted a limited set of fields as * Note: before PG 8.4 we interpreted a limited set of fields as
* actually causing a "modulo" operation on a given value, potentially * actually causing a "modulo" operation on a given value, potentially

23
src/backend/utils/adt/varbit.c
Unescape View File

@ -19,7 +19,6 @@
#include "access/htup.h" #include "access/htup.h"
#include "libpq/pqformat.h" #include "libpq/pqformat.h"
#include "nodes/nodeFuncs.h" #include "nodes/nodeFuncs.h"
#include "parser/parse_clause.h"
#include "utils/array.h" #include "utils/array.h"
#include "utils/varbit.h" #include "utils/varbit.h"
@ -649,31 +648,31 @@ varbit_send(PG_FUNCTION_ARGS)
/* /*
* varbit_transform() * varbit_transform()
* Flatten calls to our length coercion function that leave the new maximum * Flatten calls to varbit's length coercion function that set the new maximum
* length >= the previous maximum length. We ignore the isExplicit argument, * length >= the previous maximum length. We can ignore the isExplicit
* which only affects truncation. * argument, since that only affects truncation cases.
*/ */
Datum Datum
varbit_transform(PG_FUNCTION_ARGS) varbit_transform(PG_FUNCTION_ARGS)
{ {
FuncExpr *expr = (FuncExpr *) PG_GETARG_POINTER(0); FuncExpr *expr = (FuncExpr *) PG_GETARG_POINTER(0);
Node *typmod;
Node *ret = NULL; Node *ret = NULL;
Node *typmod;
if (!IsA(expr, FuncExpr)) Assert(IsA(expr, FuncExpr));
PG_RETURN_POINTER(ret); Assert(list_length(expr->args) >= 2);
Assert(list_length(expr->args) == 3); typmod = (Node *) lsecond(expr->args);
typmod = lsecond(expr->args);
if (IsA(typmod, Const)) if (IsA(typmod, Const) && !((Const *) typmod)->constisnull)
{ {
Node *source = linitial(expr->args); Node *source = (Node *) linitial(expr->args);
int32 new_typmod = DatumGetInt32(((Const *) typmod)->constvalue); int32 new_typmod = DatumGetInt32(((Const *) typmod)->constvalue);
int32 old_max = exprTypmod(source); int32 old_max = exprTypmod(source);
int32 new_max = new_typmod; int32 new_max = new_typmod;
if (new_max <= 0 || (old_max >= 0 && old_max <= new_max)) /* Note: varbit() treats typmod 0 as invalid, so we do too */
if (new_max <= 0 || (old_max > 0 && old_max <= new_max))
ret = relabel_to_typmod(source, new_typmod); ret = relabel_to_typmod(source, new_typmod);
} }

26
src/backend/utils/adt/varchar.c
Unescape View File

@ -19,7 +19,6 @@
#include "access/tuptoaster.h" #include "access/tuptoaster.h"
#include "libpq/pqformat.h" #include "libpq/pqformat.h"
#include "nodes/nodeFuncs.h" #include "nodes/nodeFuncs.h"
#include "parser/parse_clause.h"
#include "utils/array.h" #include "utils/array.h"
#include "utils/builtins.h" #include "utils/builtins.h"
#include "mb/pg_wchar.h" #include "mb/pg_wchar.h"
@ -551,31 +550,32 @@ varcharsend(PG_FUNCTION_ARGS)
/* /*
* Flatten calls to our length coercion function that leave the new maximum * varchar_transform()
* length >= the previous maximum length. We ignore the isExplicit argument, * Flatten calls to varchar's length coercion function that set the new maximum
* which only affects truncation. * length >= the previous maximum length. We can ignore the isExplicit
* argument, since that only affects truncation cases.
*/ */
Datum Datum
varchar_transform(PG_FUNCTION_ARGS) varchar_transform(PG_FUNCTION_ARGS)
{ {
FuncExpr *expr = (FuncExpr *) PG_GETARG_POINTER(0); FuncExpr *expr = (FuncExpr *) PG_GETARG_POINTER(0);
Node *typmod;
Node *ret = NULL; Node *ret = NULL;
Node *typmod;
if (!IsA(expr, FuncExpr)) Assert(IsA(expr, FuncExpr));
PG_RETURN_POINTER(ret); Assert(list_length(expr->args) >= 2);
Assert(list_length(expr->args) == 3); typmod = (Node *) lsecond(expr->args);
typmod = lsecond(expr->args);
if (IsA(typmod, Const)) if (IsA(typmod, Const) && !((Const *) typmod)->constisnull)
{ {
Node *source = linitial(expr->args); Node *source = (Node *) linitial(expr->args);
int32 old_typmod = exprTypmod(source);
int32 new_typmod = DatumGetInt32(((Const *) typmod)->constvalue); int32 new_typmod = DatumGetInt32(((Const *) typmod)->constvalue);
int32 old_max = exprTypmod(source) - VARHDRSZ; int32 old_max = old_typmod - VARHDRSZ;
int32 new_max = new_typmod - VARHDRSZ; int32 new_max = new_typmod - VARHDRSZ;
if (new_max < 0 || (old_max >= 0 && old_max <= new_max)) if (new_typmod < 0 || (old_typmod >= 0 && old_max <= new_max))
ret = relabel_to_typmod(source, new_typmod); ret = relabel_to_typmod(source, new_typmod);
} }

23
src/include/catalog/pg_proc.h
Unescape View File

@ -767,7 +767,7 @@ DATA(insert OID = 668 ( bpchar PGNSP PGUID 12 1 0 0 0 f f f f t f i 3 0 10
DESCR("adjust char() to typmod length"); DESCR("adjust char() to typmod length");
DATA(insert OID = 3097 ( varchar_transform PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2281 "2281" _null_ _null_ _null_ _null_ varchar_transform _null_ _null_ _null_ )); DATA(insert OID = 3097 ( varchar_transform PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2281 "2281" _null_ _null_ _null_ _null_ varchar_transform _null_ _null_ _null_ ));
DESCR("transform a varchar length coercion"); DESCR("transform a varchar length coercion");
DATA(insert OID = 669 ( varchar PGNSP PGUID 12 1 0 0 3097 f f f f t f i 3 0 1043 "1043 23 16" _null_ _null_ _null_ _null_ varchar _null_ _null_ _null_ )); DATA(insert OID = 669 ( varchar PGNSP PGUID 12 1 0 0 varchar_transform f f f f t f i 3 0 1043 "1043 23 16" _null_ _null_ _null_ _null_ varchar _null_ _null_ _null_ ));
DESCR("adjust varchar() to typmod length"); DESCR("adjust varchar() to typmod length");
DATA(insert OID = 676 ( mktinterval PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 704 "702 702" _null_ _null_ _null_ _null_ mktinterval _null_ _null_ _null_ )); DATA(insert OID = 676 ( mktinterval PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 704 "702 702" _null_ _null_ _null_ _null_ mktinterval _null_ _null_ _null_ ));
@ -1267,7 +1267,7 @@ DESCR("date difference preserving months and years");
DATA(insert OID = 3918 ( interval_transform PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2281 "2281" _null_ _null_ _null_ _null_ interval_transform _null_ _null_ _null_ )); DATA(insert OID = 3918 ( interval_transform PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2281 "2281" _null_ _null_ _null_ _null_ interval_transform _null_ _null_ _null_ ));
DESCR("transform an interval length coercion"); DESCR("transform an interval length coercion");
DATA(insert OID = 1200 ( interval PGNSP PGUID 12 1 0 0 3918 f f f f t f i 2 0 1186 "1186 23" _null_ _null_ _null_ _null_ interval_scale _null_ _null_ _null_ )); DATA(insert OID = 1200 ( interval PGNSP PGUID 12 1 0 0 interval_transform f f f f t f i 2 0 1186 "1186 23" _null_ _null_ _null_ _null_ interval_scale _null_ _null_ _null_ ));
DESCR("adjust interval precision"); DESCR("adjust interval precision");
DATA(insert OID = 1215 ( obj_description PGNSP PGUID 14 100 0 0 0 f f f f t f s 2 0 25 "26 19" _null_ _null_ _null_ _null_ "select description from pg_catalog.pg_description where objoid = $1 and classoid = (select oid from pg_catalog.pg_class where relname = $2 and relnamespace = PGNSP) and objsubid = 0" _null_ _null_ _null_ )); DATA(insert OID = 1215 ( obj_description PGNSP PGUID 14 100 0 0 0 f f f f t f s 2 0 25 "26 19" _null_ _null_ _null_ _null_ "select description from pg_catalog.pg_description where objoid = $1 and classoid = (select oid from pg_catalog.pg_class where relname = $2 and relnamespace = PGNSP) and objsubid = 0" _null_ _null_ _null_ ));
@ -2023,7 +2023,7 @@ DATA(insert OID = 1685 ( bit PGNSP PGUID 12 1 0 0 0 f f f f t f i 3 0 1560
DESCR("adjust bit() to typmod length"); DESCR("adjust bit() to typmod length");
DATA(insert OID = 3158 ( varbit_transform PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2281 "2281" _null_ _null_ _null_ _null_ varbit_transform _null_ _null_ _null_ )); DATA(insert OID = 3158 ( varbit_transform PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2281 "2281" _null_ _null_ _null_ _null_ varbit_transform _null_ _null_ _null_ ));
DESCR("transform a varbit length coercion"); DESCR("transform a varbit length coercion");
DATA(insert OID = 1687 ( varbit PGNSP PGUID 12 1 0 0 3158 f f f f t f i 3 0 1562 "1562 23 16" _null_ _null_ _null_ _null_ varbit _null_ _null_ _null_ )); DATA(insert OID = 1687 ( varbit PGNSP PGUID 12 1 0 0 varbit_transform f f f f t f i 3 0 1562 "1562 23 16" _null_ _null_ _null_ _null_ varbit _null_ _null_ _null_ ));
DESCR("adjust varbit() to typmod length"); DESCR("adjust varbit() to typmod length");
DATA(insert OID = 1698 ( position PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 23 "1560 1560" _null_ _null_ _null_ _null_ bitposition _null_ _null_ _null_ )); DATA(insert OID = 1698 ( position PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 23 "1560 1560" _null_ _null_ _null_ _null_ bitposition _null_ _null_ _null_ ));
@ -2156,10 +2156,10 @@ DATA(insert OID = 2917 ( numerictypmodin PGNSP PGUID 12 1 0 0 0 f f f f t f i
DESCR("I/O typmod"); DESCR("I/O typmod");
DATA(insert OID = 2918 ( numerictypmodout PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2275 "23" _null_ _null_ _null_ _null_ numerictypmodout _null_ _null_ _null_ )); DATA(insert OID = 2918 ( numerictypmodout PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2275 "23" _null_ _null_ _null_ _null_ numerictypmodout _null_ _null_ _null_ ));
DESCR("I/O typmod"); DESCR("I/O typmod");
DATA(insert OID = 1703 ( numeric PGNSP PGUID 12 1 0 0 3157 f f f f t f i 2 0 1700 "1700 23" _null_ _null_ _null_ _null_ numeric _null_ _null_ _null_ ));
DESCR("adjust numeric to typmod precision/scale");
DATA(insert OID = 3157 ( numeric_transform PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2281 "2281" _null_ _null_ _null_ _null_ numeric_transform _null_ _null_ _null_ )); DATA(insert OID = 3157 ( numeric_transform PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2281 "2281" _null_ _null_ _null_ _null_ numeric_transform _null_ _null_ _null_ ));
DESCR("transform a numeric length coercion"); DESCR("transform a numeric length coercion");
DATA(insert OID = 1703 ( numeric PGNSP PGUID 12 1 0 0 numeric_transform f f f f t f i 2 0 1700 "1700 23" _null_ _null_ _null_ _null_ numeric _null_ _null_ _null_ ));
DESCR("adjust numeric to typmod precision/scale");
DATA(insert OID = 1704 ( numeric_abs PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ numeric_abs _null_ _null_ _null_ )); DATA(insert OID = 1704 ( numeric_abs PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ numeric_abs _null_ _null_ _null_ ));
DATA(insert OID = 1705 ( abs PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ numeric_abs _null_ _null_ _null_ )); DATA(insert OID = 1705 ( abs PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ numeric_abs _null_ _null_ _null_ ));
DESCR("absolute value"); DESCR("absolute value");
@ -2746,7 +2746,10 @@ DESCR("less-equal-greater");
DATA(insert OID = 3917 ( timestamp_transform PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2281 "2281" _null_ _null_ _null_ _null_ timestamp_transform _null_ _null_ _null_ )); DATA(insert OID = 3917 ( timestamp_transform PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2281 "2281" _null_ _null_ _null_ _null_ timestamp_transform _null_ _null_ _null_ ));
DESCR("transform a timestamp length coercion"); DESCR("transform a timestamp length coercion");
DATA(insert OID = 1961 ( timestamp PGNSP PGUID 12 1 0 0 3917 f f f f t f i 2 0 1114 "1114 23" _null_ _null_ _null_ _null_ timestamp_scale _null_ _null_ _null_ )); DATA(insert OID = 3944 ( time_transform PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2281 "2281" _null_ _null_ _null_ _null_ time_transform _null_ _null_ _null_ ));
DESCR("transform a time length coercion");
DATA(insert OID = 1961 ( timestamp PGNSP PGUID 12 1 0 0 timestamp_transform f f f f t f i 2 0 1114 "1114 23" _null_ _null_ _null_ _null_ timestamp_scale _null_ _null_ _null_ ));
DESCR("adjust timestamp precision"); DESCR("adjust timestamp precision");
DATA(insert OID = 1965 ( oidlarger PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 26 "26 26" _null_ _null_ _null_ _null_ oidlarger _null_ _null_ _null_ )); DATA(insert OID = 1965 ( oidlarger PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 26 "26 26" _null_ _null_ _null_ _null_ oidlarger _null_ _null_ _null_ ));
@ -2754,13 +2757,11 @@ DESCR("larger of two");
DATA(insert OID = 1966 ( oidsmaller PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 26 "26 26" _null_ _null_ _null_ _null_ oidsmaller _null_ _null_ _null_ )); DATA(insert OID = 1966 ( oidsmaller PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 26 "26 26" _null_ _null_ _null_ _null_ oidsmaller _null_ _null_ _null_ ));
DESCR("smaller of two"); DESCR("smaller of two");
DATA(insert OID = 1967 ( timestamptz PGNSP PGUID 12 1 0 0 3917 f f f f t f i 2 0 1184 "1184 23" _null_ _null_ _null_ _null_ timestamptz_scale _null_ _null_ _null_ )); DATA(insert OID = 1967 ( timestamptz PGNSP PGUID 12 1 0 0 timestamp_transform f f f f t f i 2 0 1184 "1184 23" _null_ _null_ _null_ _null_ timestamptz_scale _null_ _null_ _null_ ));
DESCR("adjust timestamptz precision"); DESCR("adjust timestamptz precision");
DATA(insert OID = 3944 ( time_transform PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2281 "2281" _null_ _null_ _null_ _null_ time_transform _null_ _null_ _null_ )); DATA(insert OID = 1968 ( time PGNSP PGUID 12 1 0 0 time_transform f f f f t f i 2 0 1083 "1083 23" _null_ _null_ _null_ _null_ time_scale _null_ _null_ _null_ ));
DESCR("transform a time length coercion");
DATA(insert OID = 1968 ( time PGNSP PGUID 12 1 0 0 3944 f f f f t f i 2 0 1083 "1083 23" _null_ _null_ _null_ _null_ time_scale _null_ _null_ _null_ ));
DESCR("adjust time precision"); DESCR("adjust time precision");
DATA(insert OID = 1969 ( timetz PGNSP PGUID 12 1 0 0 3944 f f f f t f i 2 0 1266 "1266 23" _null_ _null_ _null_ _null_ timetz_scale _null_ _null_ _null_ )); DATA(insert OID = 1969 ( timetz PGNSP PGUID 12 1 0 0 time_transform f f f f t f i 2 0 1266 "1266 23" _null_ _null_ _null_ _null_ timetz_scale _null_ _null_ _null_ ));
DESCR("adjust time with time zone precision"); DESCR("adjust time with time zone precision");
DATA(insert OID = 2003 ( textanycat PGNSP PGUID 14 1 0 0 0 f f f f t f s 2 0 25 "25 2776" _null_ _null_ _null_ _null_ "select $1 || $2::pg_catalog.text" _null_ _null_ _null_ )); DATA(insert OID = 2003 ( textanycat PGNSP PGUID 14 1 0 0 0 f f f f t f s 2 0 25 "25 2776" _null_ _null_ _null_ _null_ "select $1 || $2::pg_catalog.text" _null_ _null_ _null_ ));

1
src/include/nodes/nodeFuncs.h
Unescape View File

@ -29,6 +29,7 @@
extern Oid exprType(const Node *expr); extern Oid exprType(const Node *expr);
extern int32 exprTypmod(const Node *expr); extern int32 exprTypmod(const Node *expr);
extern bool exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod); extern bool exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod);
extern Node *relabel_to_typmod(Node *expr, int32 typmod);
extern bool expression_returns_set(Node *clause); extern bool expression_returns_set(Node *clause);
extern Oid exprCollation(const Node *expr); extern Oid exprCollation(const Node *expr);

2
src/include/parser/parse_clause.h
Unescape View File

@ -44,6 +44,4 @@ extern List *transformDistinctOnClause(ParseState *pstate, List *distinctlist,
extern Index assignSortGroupRef(TargetEntry *tle, List *tlist); extern Index assignSortGroupRef(TargetEntry *tle, List *tlist);
extern bool targetIsInSortList(TargetEntry *tle, Oid sortop, List *sortList); extern bool targetIsInSortList(TargetEntry *tle, Oid sortop, List *sortList);
extern Node *relabel_to_typmod(Node *expr, int32 typmod);
#endif /* PARSE_CLAUSE_H */ #endif /* PARSE_CLAUSE_H */

10
src/test/regress/expected/opr_sanity.out
Unescape View File

@ -330,6 +330,16 @@ WHERE proargmodes IS NOT NULL AND proargnames IS NOT NULL AND
-----+--------- -----+---------
(0 rows) (0 rows)
-- Check for protransform functions with the wrong signature
SELECT p1.oid, p1.proname, p2.oid, p2.proname
FROM pg_proc AS p1, pg_proc AS p2
WHERE p2.oid = p1.protransform AND
(p2.prorettype != 'internal'::regtype OR p2.proretset OR p2.pronargs != 1
OR p2.proargtypes[0] != 'internal'::regtype);
oid | proname | oid | proname
-----+---------+-----+---------
(0 rows)
-- Insist that all built-in pg_proc entries have descriptions -- Insist that all built-in pg_proc entries have descriptions
SELECT p1.oid, p1.proname SELECT p1.oid, p1.proname
FROM pg_proc as p1 LEFT JOIN pg_description as d FROM pg_proc as p1 LEFT JOIN pg_description as d

7
src/test/regress/sql/opr_sanity.sql
Unescape View File

@ -256,6 +256,13 @@ FROM pg_proc as p1
WHERE proargmodes IS NOT NULL AND proargnames IS NOT NULL AND WHERE proargmodes IS NOT NULL AND proargnames IS NOT NULL AND
array_length(proargmodes,1) <> array_length(proargnames,1); array_length(proargmodes,1) <> array_length(proargnames,1);
-- Check for protransform functions with the wrong signature
SELECT p1.oid, p1.proname, p2.oid, p2.proname
FROM pg_proc AS p1, pg_proc AS p2
WHERE p2.oid = p1.protransform AND
(p2.prorettype != 'internal'::regtype OR p2.proretset OR p2.pronargs != 1
OR p2.proargtypes[0] != 'internal'::regtype);
-- Insist that all built-in pg_proc entries have descriptions -- Insist that all built-in pg_proc entries have descriptions
SELECT p1.oid, p1.proname SELECT p1.oid, p1.proname
FROM pg_proc as p1 LEFT JOIN pg_description as d FROM pg_proc as p1 LEFT JOIN pg_description as d

Write Preview
Loading…
Cancel
Save