Correctifs appliqués

Tom Lane a poussé :

  • Work around rounding misbehavior exposed by buildfarm.;a=commitdiff;h=4ba61a487e39eaf859cd9face9520b30127e6a91
  • Fix inline_set_returning_function() to preserve the invalItems list properly. This avoids a possible crash when inlining a SRF whose argument list contains a reference to an inline-able user function. The crash is quite reproducible with CLOBBER_FREED_MEMORY enabled, but would be less certain in a production build. Problem introduced in 9.0 by the named-arguments patch, which requires invoking eval_const_expressions() before we can try to inline a SRF. Per report from Brendan Jurd.;a=commitdiff;h=ef55e294e66725c412d55b9689328235141d816d
  • Fix overly-enthusiastic Assert in printing of Param reference expressions. A NestLoopParam's value can only be a Var or Aggref, but this isn't the case in general for SubPlan parameters, so print_parameter_expr had better be prepared to cope. Brain fade in my recent patch to print the referenced expression instead of just printing $N for PARAM_EXEC Params. Per report from Pavel Stehule.;a=commitdiff;h=c6873eac4c33720140240cdbd1a663fecc922c57
  • Fix up some oversights in psql's Unicode-escape support. Original patch failed to include new exclusive states in a switch that needed to include them; and also was guilty of very fuzzy thinking about how to handle error cases. Per bug #5729 from Alan Choi.;a=commitdiff;h=35d89401525677441824c6f2116b9f7d0cc3caac
  • Previous patch had no detectable virtue other than being a one-liner. Try to make the code look self-consistent again, so it doesn't confuse future developers.;a=commitdiff;h=e6721c6e1617a0fc8b4bce8eacba8b5a381f1f21
  • Fix plpgsql's handling of "simple" expression evaluation. In general, expression execution state trees aren't re-entrantly usable, since functions can store private state information in them. For efficiency reasons, plpgsql tries to cache and reuse state trees for "simple" expressions. It can get away with that most of the time, but it can fail if the state tree is dirty from a previous failed execution (as in an example from Alvaro) or is being used recursively (as noted by me). Fix by tracking whether a state tree is in use, and falling back to the "non-simple" code path if so. This results in a pretty considerable speed hit when the non-simple path is taken, but the available alternatives seem even more unpleasant because they add overhead in the simple path. Per idea from Heikki Linnakangas. Back-patch to all supported branches.;a=commitdiff;h=8ce22dd4c51b6e8155889653c0116cad13877512
  • Save a few cycles in plpgsql simple-expression initialization. Instead of using ExecPrepareExpr, call ExecInitExpr. The net change here is that we don't apply expression_planner() to the expression tree. There is no need to do so, because that tree is extracted from a fully planned plancache entry, so all the needed work is already done. This reduces the setup costs by about a factor of 2 according to some simple tests. Oversight noted while fooling around with the simple-expression code for previous fix.;a=commitdiff;h=37e0a016547abb3526b685d7aacbd0a4d57f6937
  • In psql, make \? output of \dg and \du the same. The previous wording might have suggested that \du only showed login roles and \dg only group roles, but that is no longer the case. Proposed by Josh Kupershmidt.;a=commitdiff;h=299591d1a293e737d72d57aa8545c6c00d19db1d
  • In psql, add tab completion for psql \dg and \z. Josh Kupershmidt.;a=commitdiff;h=a3d40e9fb51f8aab9cde5d5018be5e46332275fd
  • Avoid creation of useless EquivalenceClasses during planning. Zoltan Boszormenyi exhibited a test case in which planning time was dominated by construction of EquivalenceClasses and PathKeys that had no actual relevance to the query (and in fact got discarded immediately). This happened because we generated PathKeys describing the sort ordering of every index on every table in the query, and only after that checked to see if the sort ordering was relevant. The Emmanuel Cecchet/PK construction code is O(N2) in the number of ECs, which is all right for the intended number of such objects, but it gets out of hand if there are ECs for lots of irrelevant indexes. To fix, twiddle the handling of mergeclauses a little bit to ensure that every interesting Emmanuel Cecchet is created before we begin path generation. (This doesn't cost anything --- in fact I think it's a bit cheaper than before --- since we always eventually created those ECs anyway.) Then, if an index column can't be found in any pre-existing Emmanuel Cecchet, we know that that sort ordering is irrelevant for the query. Instead of creating a useless Emmanuel Cecchet, we can just not build a pathkey for the index column in the first place. The index will still be considered if it's useful for non-order-related reasons, but we will think of its output as unsorted.;a=commitdiff;h=14231a41a94b2345cc679ff67dbee1bf7dac7029
  • Oops, missed one fix for EquivalenceClass rearrangement. Now that we're expecting a mergeclause's left_ec/right_ec to persist from the initial assignments, we can't just blithely zero these out when transforming such a clause in adjust_appendrel_attrs. But really it should be okay to keep the parent's values, since a child table's derived Var ought to be equivalent to the parent Var for all EquivalenceClass purposes. (Indeed, I'm wondering whether we couldn't find a way to dispense with add_child_rel_equivalences altogether. But this is wrong in any case.);a=commitdiff;h=48a1fb23900d73e7d9cb2dc0408c745cd03597a7
  • Fix comparisons of pointers with zero to compare with NULL instead. Per C standard, these are semantically the same thing; but saying NULL when you mean NULL is good for readability. Marti Raudsepp, per results of INRIA's Coccinelle.;a=commitdiff;h=bfd3f37be309c3647844aed937e6a66aad5fd3cb
  • Provide hashing support for arrays. The core of this patch is hash_array() and associated typcache infrastructure, which works just about exactly like the existing support for array comparison. In addition I did some work to ensure that the planner won't think that an array type is hashable unless its element type is hashable, and similarly for sorting. This includes adding a datatype parameter to op_hashjoinable and op_mergejoinable, and adding an explicit "hashable" flag to SortGroupClause. The lack of a cross-check on the element type was a pre-existing bug in mergejoin support --- but it didn't matter so much before, because if you couldn't sort the element type there wasn't any good alternative to failing anyhow. Now that we have the alternative of hashing the array type, there are cases where we can avoid a failure by being picky at the planner stage, so it's time to be picky. The issue of exactly how to combine the per-element hash values to produce an array hash is still open for discussion, but the rest of this is pretty solid, so I'll commit it as-is.;a=commitdiff;h=186cbbda8f8dc5e42f68fc7892f206a76d56a20f
  • Revert removal of trigger flag from plperl function hash key. As noted by Jan Urbanski, this flag is in fact needed to ensure that the function's input/result conversion functions are set up as expected. Add a regression test to discourage anyone from making same mistake in future.;a=commitdiff;h=76b12e0af765b2ca2eeddcabdd5e7c22eda164da

Alvaro Herrera a poussé :

Peter Eisentraut a poussé :

ITAGAKI Takahiro a poussé :

Heikki Linnakangas a poussé :

Robert Haas a poussé :

Andrew Dunstan a poussé :

Correctifs rejetés (à ce jour)

  • Pas de déception cette semaine :-)

Correctifs en attente

  • Shigeru HANADA sent in another revision of the patch to add SQL/MED with simple wrappers.
  • ITAGAKI Takahiro sent in two revisions of a patch to add executor nodes, which will help with, among other things, SQL/MED.
  • Alvaro Herrera sent in a patch atop the patch to add EXTENSIONs.
  • David Fetter sent in two revisions of a patch to add tab completion in psql for views made writeable by triggers.
  • Dimitri Fontaine sent in another patch for EXTENSIONs.
  • Zoltan Boszormenyi, Heikki Linnakangas and Tom Lane traded patches to speed up planning times for queries on tables with large numbers of partitions.
  • Alvaro Herrera sent in a patch to add "ALTER TYPE...ADD ELEMENT" to enums.
  • Steve Singer sent in a patch to modify TRUNCATE ... RESTART IDENTITY so that when the transaction rolls back, the restart of the sequence also rolls back.
  • Robert Haas sent in a patch to help explain about sdparm's effects on WAL durability.
  • Alvaro Herrera sent in a patch to change ALTER TYPE...ENUM... to include ADD LABEL [BEFORE|AFTER]. The LABEL is new.
  • Zoltan Boszormenyi sent in a patch for ECPG to get WHERE CURRENT OF to accept dynamic cursor names.
  • Heikki Linnakangas sent in a patch to allow tracking the latest timeline in standby mode.
  • Marti Raudsepp sent in a patch to change places where pointers were compared to 0 to compare them to NULL.
  • Alexander Korotkov sent in a patch to fix the GiST picksplit method implementation in contrib/cube.
  • Andres Freund sent in another revision of the patch to cancel IIT backends.
  • Marti Raudsepp sent in some more fixes based on Coccinelli runs.
  • Dimitri Fontaine sent in a patch to add ALTER...SET SCHEMA... to those object types that don't already have it.
  • Peter Eisentraut sent in a patch to avoid passing around type OID + typmod (+ collation) separately all over the place. Instead, there is a new struct TypeInfo that contains these fields, and only a pointer is passed around.
  • Alex Hunsaker sent in a patch to fix another issue with PL/Perl trigger functions.
  • Andres Freund sent in a patch to improve the performance of int32- and int64-to-text conversions by creating a custom converter rather than using the standard itoa functions.