Re: Rewrite, normal execution vs. EXPLAIN ANALYZE

Hi,

From the code I understood that when executing a query "normally", in
READ COMMITTED mode, we take a new snapshot for every query that comes
out of rewrite. But in an EXPLAIN ANALYZE, we only update the CID of
the snapshot taken when the EXPLAIN started.

Did I misunderstand the code? And if I didn't, why do we do this
differently?

Regards,
Marko Tiikkaja

On Thu, Jul 22, 2010 at 08:43:35PM +0300, Marko Tiikkaja wrote:
> Hi,
>
> From the code I understood that when executing a query "normally",
> in READ COMMITTED mode, we take a new snapshot for every query that
> comes out of rewrite. But in an EXPLAIN ANALYZE, we only update the
> CID of the snapshot taken when the EXPLAIN started.
>
> Did I misunderstand the code? And if I didn't, why do we do this
> differently?

You mentioned in IRC that this was in aid of getting wCTEs going. How
are these things connected?

Cheers,
David.
--
David Fetter <david(at)fetter(dot)org> http://fetter.org/
Phone: +1 415 235 3778 AIM: dfetter666 Yahoo!: dfetter
Skype: davidfetter XMPP: david(dot)fetter(at)gmail(dot)com
iCal: webcal://www.tripit.com/feed/ical/people/david74/tripit.ics

Remember to vote!
Consider donating to Postgres: http://www.postgresql.org/about/donate

On 7/23/2010 8:52 PM, David Fetter wrote:
> On Thu, Jul 22, 2010 at 08:43:35PM +0300, Marko Tiikkaja wrote:
>> Did I misunderstand the code? And if I didn't, why do we do this
>> differently?
>
> You mentioned in IRC that this was in aid of getting wCTEs going. How
> are these things connected?

Currently, I'm trying to make wCTEs behave a bit like RULEs do. But if
every rewrite product takes a new snapshot, wCTEs will behave very
unpredictably.

But because EXPLAIN ANALYZE does *not* take a new snapshot for every
rewrite product, I'm starting to think that maybe this isn't the
behaviour we wanted to begin with?

Regards,
Marko Tiikkaja

On Fri, Jul 23, 2010 at 2:13 PM, Marko Tiikkaja
<marko(dot)tiikkaja(at)cs(dot)helsinki(dot)fi> wrote:
> On 7/23/2010 8:52 PM, David Fetter wrote:
>>
>> On Thu, Jul 22, 2010 at 08:43:35PM +0300, Marko Tiikkaja wrote:
>>>
>>> Did I misunderstand the code?  And if I didn't, why do we do this
>>> differently?
>>
>> You mentioned in IRC that this was in aid of getting wCTEs going.  How
>> are these things connected?
>
> Currently, I'm trying to make wCTEs behave a bit like RULEs do.  But if
> every rewrite product takes a new snapshot, wCTEs will behave very
> unpredictably.
>
> But because EXPLAIN ANALYZE does *not* take a new snapshot for every rewrite
> product, I'm starting to think that maybe this isn't the behaviour we wanted
> to begin with?

Where should I be looking in the code for this?

--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise Postgres Company

On 7/23/2010 10:00 PM, Robert Haas wrote:
> On Fri, Jul 23, 2010 at 2:13 PM, Marko Tiikkaja
> <marko(dot)tiikkaja(at)cs(dot)helsinki(dot)fi> wrote:
>> Currently, I'm trying to make wCTEs behave a bit like RULEs do. But if
>> every rewrite product takes a new snapshot, wCTEs will behave very
>> unpredictably.
>>
>> But because EXPLAIN ANALYZE does *not* take a new snapshot for every rewrite
>> product, I'm starting to think that maybe this isn't the behaviour we wanted
>> to begin with?
>
> Where should I be looking in the code for this?

ProcessQuery() and ExplainOnePlan(). ProcessQuery calls
PushActiveSnapshot(GetTransactionSnapshot()) for every statement while
ExplainOnePlan calls PushUpdatedSnapshot(GetActiveSnapshot()).

Regards,
Marko Tiikkaja

On 7/23/2010 10:06 PM, I wrote:
> ProcessQuery() and ExplainOnePlan(). ProcessQuery calls
> PushActiveSnapshot(GetTransactionSnapshot()) for every statement while
> ExplainOnePlan calls PushUpdatedSnapshot(GetActiveSnapshot()).

Here's a test case demonstrating the difference:

=# create table foo(a int);
CREATE TABLE
=# create table bar(a int);
CREATE TABLE
=# create table baz(a int);
CREATE TABLE

=# create rule foorule as on update to foo do instead (select
pg_sleep(5); insert into bar select * from baz);
CREATE RULE

=# insert into foo values(0);

no EXPLAIN:

=# truncate bar, baz;
TRUNCATE TABLE

T1=# begin; update foo set a=a;
BEGIN
-- sleeps..

T2=# insert into baz values(0);
INSERT 0 1

-- T1 returns
pg_sleep
----------

(1 row)

UPDATE 0

T1=# select * from bar;
a
---
0
(1 row)

EXPLAIN:

=# truncate bar, baz;
TRUNCATE TABLE

T1=# begin; explain analyze update foo set a=a;
BEGIN
-- sleeps..

T2=# insert into baz values(0);
INSERT 0 1

-- T1 returns
(QUERY PLAN)

T1=# select * from bar;
a
---
(0 rows)

This may be a bit hard to follow, but essentially what happens is that
in EXPLAIN ANALYZE, the INSERT in the rule does not see the changes made
by T2 to baz while in the regular execution scenario it does.

Regards,
Marko Tiikkaja

On Fri, Jul 23, 2010 at 3:19 PM, Marko Tiikkaja
<marko(dot)tiikkaja(at)cs(dot)helsinki(dot)fi> wrote:
> This may be a bit hard to follow, but essentially what happens is that in
> EXPLAIN ANALYZE, the INSERT in the rule does not see the changes made by T2
> to baz while in the regular execution scenario it does.

Well that's gotta be a bug, but in what I'm not sure.

--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise Postgres Company

On Fri, Jul 23, 2010 at 03:30:03PM -0400, Robert Haas wrote:
> On Fri, Jul 23, 2010 at 3:19 PM, Marko Tiikkaja
> <marko(dot)tiikkaja(at)cs(dot)helsinki(dot)fi> wrote:
> > This may be a bit hard to follow, but essentially what happens is
> > that in EXPLAIN ANALYZE, the INSERT in the rule does not see the
> > changes made by T2 to baz while in the regular execution scenario
> > it does.
>
> Well that's gotta be a bug, but in what I'm not sure.

I've said it before, and I'll say it again. User-accessible RULEs are
themselves a bug :P

Cheers,
David.
--
David Fetter <david(at)fetter(dot)org> http://fetter.org/
Phone: +1 415 235 3778 AIM: dfetter666 Yahoo!: dfetter
Skype: davidfetter XMPP: david(dot)fetter(at)gmail(dot)com
iCal: webcal://www.tripit.com/feed/ical/people/david74/tripit.ics

Remember to vote!
Consider donating to Postgres: http://www.postgresql.org/about/donate

On Fri, Jul 23, 2010 at 3:31 PM, David Fetter <david(at)fetter(dot)org> wrote:
> On Fri, Jul 23, 2010 at 03:30:03PM -0400, Robert Haas wrote:
>> On Fri, Jul 23, 2010 at 3:19 PM, Marko Tiikkaja
>> <marko(dot)tiikkaja(at)cs(dot)helsinki(dot)fi> wrote:
>> > This may be a bit hard to follow, but essentially what happens is
>> > that in EXPLAIN ANALYZE, the INSERT in the rule does not see the
>> > changes made by T2 to baz while in the regular execution scenario
>> > it does.
>>
>> Well that's gotta be a bug, but in what I'm not sure.
>
> I've said it before, and I'll say it again.  User-accessible RULEs are
> themselves a bug :P

Maybe so, but perhaps it would be more productive to concentrate on
solving the immediate problem first.

--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise Postgres Company

On Fri, Jul 23, 2010 at 03:30:03PM -0400, Robert Haas wrote:
> On Fri, Jul 23, 2010 at 3:19 PM, Marko Tiikkaja
> <marko(dot)tiikkaja(at)cs(dot)helsinki(dot)fi> wrote:
> > This may be a bit hard to follow, but essentially what happens is that in
> > EXPLAIN ANALYZE, the INSERT in the rule does not see the changes made by T2
> > to baz while in the regular execution scenario it does.
>
> Well that's gotta be a bug, but in what I'm not sure.
One could argue that its less of a semantic change changing explain's
behaviour than the normal executors way of working...

Andres

On 7/23/2010 10:46 PM, Andres Freund wrote:
> On Fri, Jul 23, 2010 at 03:30:03PM -0400, Robert Haas wrote:
>> On Fri, Jul 23, 2010 at 3:19 PM, Marko Tiikkaja
>> <marko(dot)tiikkaja(at)cs(dot)helsinki(dot)fi> wrote:
>>> This may be a bit hard to follow, but essentially what happens is that in
>>> EXPLAIN ANALYZE, the INSERT in the rule does not see the changes made by T2
>>> to baz while in the regular execution scenario it does.
>>
>> Well that's gotta be a bug, but in what I'm not sure.
> One could argue that its less of a semantic change changing explain's
> behaviour than the normal executors way of working...

One could also argue that people usually test their code with EXPLAIN
ANALYZE and could've made the opposite conclusion based on its output. ;-)

But I really have no idea what we should do about this. It seems to me
that EXPLAIN ANALYZE's behaviour is less surprising (that's actually
what I, before yesterday, always thought happens), but I'm not too sure
about that either.

Regards,
Marko Tiikkaja

Excerpts from Marko Tiikkaja's message of vie jul 23 14:13:18 -0400 2010:
> On 7/23/2010 8:52 PM, David Fetter wrote:
> > On Thu, Jul 22, 2010 at 08:43:35PM +0300, Marko Tiikkaja wrote:
> >> Did I misunderstand the code? And if I didn't, why do we do this
> >> differently?
> >
> > You mentioned in IRC that this was in aid of getting wCTEs going. How
> > are these things connected?
>
> Currently, I'm trying to make wCTEs behave a bit like RULEs do. But if
> every rewrite product takes a new snapshot, wCTEs will behave very
> unpredictably.

I don't think it's fair game to change the behavior of multiple-output
rules at this point. However, I also think that it's unwise to base
wCTEs on the behavior of rules -- rules are widely considered broken and
unusable for nontrivial cases.

Also, I think that having a moving snapshot for the different parts of a
wCTE is going to mean they're unpredictable. For predictable usage
you'll be forcing the user to always wrap them in SERIALIZABLE
transactions.

In short I think a wCTE should only advance the CID, not get a whole new
snapshot.

Alvaro Herrera <alvherre(at)commandprompt(dot)com> wrote:

> In short I think a wCTE should only advance the CID, not get a
> whole new snapshot.

Even after unblocking from a write conflict at the READ COMMITTED
isolation level?

-Kevin

On 7/24/10 12:37 AM +0300, Alvaro Herrera wrote:
> Excerpts from Marko Tiikkaja's message of vie jul 23 14:13:18 -0400 2010:
>> On 7/23/2010 8:52 PM, David Fetter wrote:
>>> On Thu, Jul 22, 2010 at 08:43:35PM +0300, Marko Tiikkaja wrote:
>>>> Did I misunderstand the code? And if I didn't, why do we do this
>>>> differently?
>>>
>>> You mentioned in IRC that this was in aid of getting wCTEs going. How
>>> are these things connected?
>>
>> Currently, I'm trying to make wCTEs behave a bit like RULEs do. But if
>> every rewrite product takes a new snapshot, wCTEs will behave very
>> unpredictably.
>
> I don't think it's fair game to change the behavior of multiple-output
> rules at this point. However, I also think that it's unwise to base
> wCTEs on the behavior of rules -- rules are widely considered broken and
> unusable for nontrivial cases.

I don't want to change the behaviour either, but we have two different
behaviours right now. We need to change at least the other.

wCTEs are not going to be based on any of the broken behaviour of rules,
that's for sure. What I meant is expanding a single query into multiple
queries and running the executor separately for all of them.

> Also, I think that having a moving snapshot for the different parts of a
> wCTE is going to mean they're unpredictable. For predictable usage
> you'll be forcing the user to always wrap them in SERIALIZABLE
> transactions.

That is *not* what has been discussed for wCTEs. A wCTE will only
modify the CID of the snapshot in any isolation mode.

> In short I think a wCTE should only advance the CID, not get a whole new
> snapshot.

Agreed.

Regards,
Marko Tiikkaja

On 7/24/10 12:42 AM +0300, Kevin Grittner wrote:
> Alvaro Herrera<alvherre(at)commandprompt(dot)com> wrote:
>
>> In short I think a wCTE should only advance the CID, not get a
>> whole new snapshot.
>
> Even after unblocking from a write conflict at the READ COMMITTED
> isolation level?

I'm not sure what you mean by this; UPDATE and DELETE can take a look at
the new tuple but that's completely separate from the snapshot.

Regards,
Marko Tiikkaja

Excerpts from Marko Tiikkaja's message of vie jul 23 17:44:21 -0400 2010:
> On 7/24/10 12:37 AM +0300, Alvaro Herrera wrote:
> > Excerpts from Marko Tiikkaja's message of vie jul 23 14:13:18 -0400 2010:

> > I don't think it's fair game to change the behavior of multiple-output
> > rules at this point. However, I also think that it's unwise to base
> > wCTEs on the behavior of rules -- rules are widely considered broken and
> > unusable for nontrivial cases.
>
> I don't want to change the behaviour either, but we have two different
> behaviours right now. We need to change at least the other.

It seems like it's EXPLAIN ANALYZE that needs fixing.

> wCTEs are not going to be based on any of the broken behaviour of rules,
> that's for sure. What I meant is expanding a single query into multiple
> queries and running the executor separately for all of them.

Is a wCTE going to be expanded into multiple queries?

If not, it sounds like we're all agreed.

On 7/24/10 1:20 AM +0300, Alvaro Herrera wrote:
> Excerpts from Marko Tiikkaja's message of vie jul 23 17:44:21 -0400 2010:
>> wCTEs are not going to be based on any of the broken behaviour of rules,
>> that's for sure. What I meant is expanding a single query into multiple
>> queries and running the executor separately for all of them.
>
> Is a wCTE going to be expanded into multiple queries?
>
> If not, it sounds like we're all agreed.

Yes, it will have to be. I tried to make it work for 9.0 by not
expanding, and it didn't work out too well.

Regards,
Marko Tiikkaja

On 7/24/10 1:20 AM +0300, Alvaro Herrera wrote:
> It seems like it's EXPLAIN ANALYZE that needs fixing.

Yeah, looks like it. I see SQL functions also take a new snapshot for
every query.

Regards,
Marko Tiikkaja

On Fri, Jul 23, 2010 at 6:20 PM, Alvaro Herrera
<alvherre(at)commandprompt(dot)com> wrote:
> Excerpts from Marko Tiikkaja's message of vie jul 23 17:44:21 -0400 2010:
>> On 7/24/10 12:37 AM +0300, Alvaro Herrera wrote:
>> > Excerpts from Marko Tiikkaja's message of vie jul 23 14:13:18 -0400 2010:
>
>> > I don't think it's fair game to change the behavior of multiple-output
>> > rules at this point.  However, I also think that it's unwise to base
>> > wCTEs on the behavior of rules -- rules are widely considered broken and
>> > unusable for nontrivial cases.
>>
>> I don't want to change the behaviour either, but we have two different
>> behaviours right now.  We need to change at least the other.
>
> It seems like it's EXPLAIN ANALYZE that needs fixing.

I would suggest that if we're going to change this, we back-patch it
to 9.0 before beta4.

--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise Postgres Company

Marko Tiikkaja <marko(dot)tiikkaja(at)cs(dot)helsinki(dot)fi> wrote:

> I'm not sure what you mean by this; UPDATE and DELETE can take a
> look at the new tuple but that's completely separate from the
> snapshot.

Never mind -- I remembered that those could operate against tuples
not in the original snapshot, but forgot that they did it without
generating an actual fresh snapshot.

-Kevin

On 7/24/2010 1:43 AM, Robert Haas wrote:
> On Fri, Jul 23, 2010 at 6:20 PM, Alvaro Herrera
> <alvherre(at)commandprompt(dot)com> wrote:
>> It seems like it's EXPLAIN ANALYZE that needs fixing.
>
> I would suggest that if we're going to change this, we back-patch it
> to 9.0 before beta4.

I did some digging and found the commit that changed the behaviour:
http://archives.postgresql.org/pgsql-committers/2004-09/msg00155.php and
then later Tom fixed a bug in it:
http://archives.postgresql.org/pgsql-committers/2005-10/msg00316.php

According to the latter commit, not updating the snapshot could be
preferable for EXPLAIN ANALYZE, but I don't see why this is. Maybe we
should wait until we hear from Tom?

Regards,
Marko Tiikkaja

Marko Tiikkaja <marko(dot)tiikkaja(at)cs(dot)helsinki(dot)fi> writes:
> According to the latter commit, not updating the snapshot could be
> preferable for EXPLAIN ANALYZE, but I don't see why this is. Maybe we
> should wait until we hear from Tom?

Sorry for not catching up on my email sooner. On the whole I'm in
agreement with the argument that wCTEs should *not* take whole new
snapshots between queries, but only advance the CID. The points
that sway me that way are:

1. To do otherwise will decrease the predictability of wCTE results.

2. The argument for taking a new snapshot seems to be mostly
"because that's what rules do"; but it's agreed that rules have a
lot of surprising and undesirable behavior, and it's not clear that
this isn't part of that.

3. In particular I don't agree with the argument that functions taking
new snapshots between queries should be a precedent for this. In
a function, the user thinks of the successive lines as separate queries,
and it's reasonable for them to act similarly to what would happen if
they were issued as separate top-level commands. I do not see that that
argument applies to wCTEs, which by definition are parts of a single
command.

In any case the behavior is going to have to be documented, but I vote
for advance-CID-only so far as wCTEs are concerned.

The other thing that was being argued was whether rules should be
changed to act that way too, and if not whether EXPLAIN ANALYZE should
be fixed to make sure it emulates rule execution better. Personally
I'd be in favor of changing rule execution and leaving EXPLAIN ANALYZE
alone, though I'm not sure if that position can command a consensus.
I seriously doubt that there are many applications out there that are
actually depending on this aspect of rule execution; if anything, there
are probably more that will see it as a bug.

regards, tom lane

On Wed, Aug 4, 2010 at 2:45 PM, Tom Lane <tgl(at)sss(dot)pgh(dot)pa(dot)us> wrote:
> The other thing that was being argued was whether rules should be
> changed to act that way too, and if not whether EXPLAIN ANALYZE should
> be fixed to make sure it emulates rule execution better.  Personally
> I'd be in favor of changing rule execution and leaving EXPLAIN ANALYZE
> alone, though I'm not sure if that position can command a consensus.
> I seriously doubt that there are many applications out there that are
> actually depending on this aspect of rule execution; if anything, there
> are probably more that will see it as a bug.

Changing EXPLAIN ANALYZE seems a bit less likely to break things for
anyone depending on current behavior; but, on the other hand, it seems
there's a broad consensus that the best thing to do about rule
execution is deprecate it, so maybe it doesn't really matter.

--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise Postgres Company

On 8/4/2010 10:26 PM, Robert Haas wrote:
> On Wed, Aug 4, 2010 at 2:45 PM, Tom Lane<tgl(at)sss(dot)pgh(dot)pa(dot)us> wrote:
>> The other thing that was being argued was whether rules should be
>> changed to act that way too, and if not whether EXPLAIN ANALYZE should
>> be fixed to make sure it emulates rule execution better. Personally
>> I'd be in favor of changing rule execution and leaving EXPLAIN ANALYZE
>> alone, though I'm not sure if that position can command a consensus.
>> I seriously doubt that there are many applications out there that are
>> actually depending on this aspect of rule execution; if anything, there
>> are probably more that will see it as a bug.
>
> Changing EXPLAIN ANALYZE seems a bit less likely to break things for
> anyone depending on current behavior; but, on the other hand, it seems
> there's a broad consensus that the best thing to do about rule
> execution is deprecate it, so maybe it doesn't really matter.

I'm having a hard time imagining that anyone would depend on a behaviour
like this.

Regards,
Marko Tiikkaja

Robert Haas <robertmhaas(at)gmail(dot)com> writes:
> On Wed, Aug 4, 2010 at 2:45 PM, Tom Lane <tgl(at)sss(dot)pgh(dot)pa(dot)us> wrote:
>> I seriously doubt that there are many applications out there that are
>> actually depending on this aspect of rule execution; if anything, there
>> are probably more that will see it as a bug.

> Changing EXPLAIN ANALYZE seems a bit less likely to break things for
> anyone depending on current behavior;

Well, the point I was trying to make is that there may well be fewer
people depending on the current behavior than there are people for whom
the current behavior is wrong, only they don't know it because they've
not seen a failure (or not seen one often enough to diagnose what's
happening).

This is of course merest speculation either way. But I don't feel that
we need to necessarily treat rule behavior as graven in stone.

regards, tom lane

Hi,

I looked at fixing this inconsistency by making all query list snapshot
handling work like EXPLAIN ANALYZE's code does. The only reason I went
this way was that implementing wCTEs on top of this behaviour is a lot
easier.

There were three places that needed fixing. The SPI and portal logic
changes were quite straightforward, but the SQL language function code
previously didn't know what query trees of the execution_state list
belonged to which query so there was no way to tell when we actually
needed to take a new snapshot. The approach I took was to change the
representation of the SQL function cache to a list of execution_state
lists, and grab a new snapshot between the lists.

The patch needs a bit more comments and some cleaning up, but I thought
I'd get your input first. Thoughts?

Regards,
Marko Tiikkaja

On 2010-08-31 12:07 AM +0300, I wrote:
> I looked at fixing this..

The previous patch had a bug in fmgr_sql() our regression tests didn't
catch. Fixed version attached.

Regards,
Marko Tiikkaja

On Mon, Aug 30, 2010 at 5:30 PM, Marko Tiikkaja
<marko(dot)tiikkaja(at)cs(dot)helsinki(dot)fi> wrote:
> On 2010-08-31 12:07 AM +0300, I wrote:
>>
>> I looked at fixing this..
>
> The previous patch had a bug in fmgr_sql() our regression tests didn't
> catch.  Fixed version attached.

It would probably be a good idea to add this to the currently open CommitFest.

https://commitfest.postgresql.org/action/commitfest_view/open

--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise Postgres Company

On 2010-08-31 12:07 AM +0300, I wrote:
> The patch needs a bit more comments and some cleaning up ..

Here's a cleaned up version with a bit more comments.

This patch still silently breaks pg_parse_and_rewrite(). We only use it
in our source code for SQL-language functions, so I think we should
deprecate it in favor of a function which would do the right thing for
SQL functions. Thoughts?

Regards,
Marko Tiikkaja

Tom Lane wrote:
> Robert Haas <robertmhaas(at)gmail(dot)com> writes:
> > On Wed, Aug 4, 2010 at 2:45 PM, Tom Lane <tgl(at)sss(dot)pgh(dot)pa(dot)us> wrote:
> >> I seriously doubt that there are many applications out there that are
> >> actually depending on this aspect of rule execution; if anything, there
> >> are probably more that will see it as a bug.
>
> > Changing EXPLAIN ANALYZE seems a bit less likely to break things for
> > anyone depending on current behavior;
>
> Well, the point I was trying to make is that there may well be fewer
> people depending on the current behavior than there are people for whom
> the current behavior is wrong, only they don't know it because they've
> not seen a failure (or not seen one often enough to diagnose what's
> happening).
>
> This is of course merest speculation either way. But I don't feel that
> we need to necessarily treat rule behavior as graven in stone.

Where are we on this? It seems it is an issue independent of writable
common table expressions (wCTEs).

--
Bruce Momjian <bruce(at)momjian(dot)us> http://momjian.us
EnterpriseDB http://enterprisedb.com

+ It's impossible for everything to be true. +

On Thu, Feb 17, 2011 at 1:04 PM, Bruce Momjian <bruce(at)momjian(dot)us> wrote:
> Tom Lane wrote:
>> Robert Haas <robertmhaas(at)gmail(dot)com> writes:
>> > On Wed, Aug 4, 2010 at 2:45 PM, Tom Lane <tgl(at)sss(dot)pgh(dot)pa(dot)us> wrote:
>> >> I seriously doubt that there are many applications out there that are
>> >> actually depending on this aspect of rule execution; if anything, there
>> >> are probably more that will see it as a bug.
>>
>> > Changing EXPLAIN ANALYZE seems a bit less likely to break things for
>> > anyone depending on current behavior;
>>
>> Well, the point I was trying to make is that there may well be fewer
>> people depending on the current behavior than there are people for whom
>> the current behavior is wrong, only they don't know it because they've
>> not seen a failure (or not seen one often enough to diagnose what's
>> happening).
>>
>> This is of course merest speculation either way.  But I don't feel that
>> we need to necessarily treat rule behavior as graven in stone.
>
> Where are we on this?  It seems it is an issue independent of writable
> common table expressions (wCTEs).

I believe that it's the same issue as this patch:

https://commitfest.postgresql.org/action/patch_view?id=377

The status of that patch is that Tom promised to look at it two months
ago and hasn't. It would be nice if someone else could pick it up.
It's not good for our community to ignore patches that people have
taken the trouble to write and submit.

--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company

Robert Haas wrote:
> On Thu, Feb 17, 2011 at 1:04 PM, Bruce Momjian <bruce(at)momjian(dot)us> wrote:
> > Tom Lane wrote:
> >> Robert Haas <robertmhaas(at)gmail(dot)com> writes:
> >> > On Wed, Aug 4, 2010 at 2:45 PM, Tom Lane <tgl(at)sss(dot)pgh(dot)pa(dot)us> wrote:
> >> >> I seriously doubt that there are many applications out there that are
> >> >> actually depending on this aspect of rule execution; if anything, there
> >> >> are probably more that will see it as a bug.
> >>
> >> > Changing EXPLAIN ANALYZE seems a bit less likely to break things for
> >> > anyone depending on current behavior;
> >>
> >> Well, the point I was trying to make is that there may well be fewer
> >> people depending on the current behavior than there are people for whom
> >> the current behavior is wrong, only they don't know it because they've
> >> not seen a failure (or not seen one often enough to diagnose what's
> >> happening).
> >>
> >> This is of course merest speculation either way. ?But I don't feel that
> >> we need to necessarily treat rule behavior as graven in stone.
> >
> > Where are we on this? ?It seems it is an issue independent of writable
> > common table expressions (wCTEs).
>
> I believe that it's the same issue as this patch:
>
> https://commitfest.postgresql.org/action/patch_view?id=377
>
> The status of that patch is that Tom promised to look at it two months
> ago and hasn't. It would be nice if someone else could pick it up.
> It's not good for our community to ignore patches that people have
> taken the trouble to write and submit.

Oh, at least it is in the current commit-fest and was not lost.

--
Bruce Momjian <bruce(at)momjian(dot)us> http://momjian.us
EnterpriseDB http://enterprisedb.com

+ It's impossible for everything to be true. +

Robert Haas <robertmhaas(at)gmail(dot)com> writes:
> The status of that patch is that Tom promised to look at it two months
> ago and hasn't. It would be nice if someone else could pick it up.

I'm pedaling as fast as I can, honestly.

regards, tom lane

On Feb 17, 2011, at 11:28 AM, Tom Lane wrote:

>> The status of that patch is that Tom promised to look at it two months
>> ago and hasn't. It would be nice if someone else could pick it up.
>
> I'm pedaling as fast as I can, honestly

Tom leaves everything on the road.

http://en.wiktionary.org/wiki/leave_everything_on_the_road

David