On Thu, Feb 9, 2017 at 2:32 PM, Andres Freund <and...@anarazel.de> wrote:
> Except that the proposed names aren't remotely like that... ;).
> And I proposed documenting named parameters, and
> check_btree(performing_check_requiring_exclusive_locks => true) is just
> about as expressive.

I cannot think of an example, offhand, of where it isn't self-evident
what relation level locks will be acquired when a statement is
prepared. I guess you could say that VACUUM truncation is a bit like
that, but it's not the same IMV.

Maybe there is an easy compromise here. We can add an argument with a
default, "level". It's an "enum" of the style of pg_prewarm (i.e.,
it's actually a text argument). The default is 'medium' or something
like that. Maybe we don't add any other flags for now, or maybe we add
some generic ones that don't actually changed the behavior. Existing
names are retained.

Doesn't that address your concern about an inflexible API? I really
dislike the idea of having the lock strength be determined on the
basis of a function arguments value.

>> I don't agree with that.  The reason we keep relation locks until the
>> end of the transaction is to avoid surprising application code, not
>> because the system can't tolerate it.  But here it's more likely that
>> retaining the lock will surprise the user.

> There were other issues than this, but right of the top of my head I
> only remember:
> double
> IndexBuildHeapRangeScan(Relation heapRelation,
> ..
>                                         /*
>                                          * Since caller should hold ShareLock 
> or better, normally
>                                          * the only way to see this is if it 
> was inserted earlier
>                                          * in our own transaction.  However, 
> it can happen in
>                                          * system catalogs, since we tend to 
> release write lock
>                                          * before commit there.  Give a 
> warning if neither case
>                                          * applies.
>                                          */
>                                         xwait = 
> HeapTupleHeaderGetXmin(heapTuple->t_data);
>                                         if 
> (!TransactionIdIsCurrentTransactionId(xwait))
>                                         {
>                                                 if (!is_system_catalog)
>                                                         elog(WARNING, 
> "concurrent insert in progress within table \"%s\"",
> RelationGetRelationName(heapRelation));
> which isn't an issue here, but reinforces my point about the (badly
> documented) assumption that we don't release locks on user relations
> early.

You are right about the substantive issue, I assume, but I have a hard
time agreeing with the idea that it's even badly documented when there
are at least 10 counter-examples of blithely doing this. In any case,
I find it very confusing when you talk about things as established
practice/coding standards when they're very clearly not consistently
adhered to at all. You should at least say "let's not make a bad
situation any worse", or something, so that I don't need to spend 10
minutes pulling my hair out.

Peter Geoghegan

Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:

Reply via email to