On Mon, May 17, 2010 at 2:15 PM, Jim Nasby <[email protected]> wrote:
> On May 6, 2010, at 4:29 PM, Merlin Moncure wrote:
>> On Thu, May 6, 2010 at 3:23 PM, Andrew Dunstan <[email protected]> wrote:
>>> And many places regard "select *" in anything other than throw-away queries
>>> as bad practice anyway. I have seen people get bitten by it over and over
>>> again, and I have worked at companies where it is explicitly forbidden in
>>> coding standards.
>>
>> In terms of application queries I generally agree. However, I think
>> this rule does not apply to server side definitions, especially in
>> regards to views and/or composite types. There are cases where you
>> _want_ the view to be define as 'all fields of x'...In fact, it's
>> pretty typical IMNSHO. It may be possible to expose this behavior.
>>
>> I'd like to see:
>> select * from foo
>> -- and --
>> select (foo).*
>> exhibit different behaviors -- ().* is more a type operator, returning
>> all the fields of foo, than a field list expression. This gives us a
>> cool loophole to exploit for views that really want to be defined with
>> *:
>> create view particular_foos as select (foo).* from foo where something =
>> true;
>> create view something_complex as select (foo).*, (func(foo.field)).*;
>> -- execute func() just one time please!
>>
>> The something_complex case above is a real problem in how it behaves
>> currently -- sometimes without a hassle free workaround. Am I off my
>> rocker? :-) I've made this point many times (prob got annoying a long
>> time ago) but I'm curious if you guys agree...
>
> What you're suggesting makes sense to me.
>
> What is the composite type workaround you mentioned? This is definitely an
> issue I face at work and would love a more elegant solution than drop and
> re-create the view.
Well, the workaround I was specifically talking about was dealing with
the problem of composite type return from functions executing the
function multiple times:
select (func()).*;
This gets expanded to select func().f1, func().f2, etc. This is the
behavior I think has to go.
if func returns foo and foo has 6 columns, func gets executed 6 times
for each row. The workaround is this:
select (q).f.* from (select func() as f) q;
the problem here is that forcing the function call into a subquery can
be awkward in non trival queries -- it causes other problems.
What you are probably looking for is to be able to add columns to a
view without recreating it:
create table foo(...);
create view v as select foo from foo;
now you can just do:
select (foo).* from v;
small disclaimer: I don't actually do this much, it might cause other
issues. postgres is pretty smart about detecting how composite type
changes cascade to other structures. This is an exception!
postgres=# create table foo(a int, b int, c int);
CREATE TABLE
postgres=# create view v as select foo from foo;
CREATE VIEW
postgres=# create view vv as select (v).foo.c;
CREATE VIEW
postgres=# insert into foo select 1,2,3;
INSERT 0 1
postgres=# insert into foo select 2,4,6;
INSERT 0 1
alter table foo drop column c; -- uh oh
ALTER TABLE
postgres=# select * from v; -- this seems ok
foo
-------
(1,2)
(2,4)
postgres=# select * from vv; -- urk!
postgres=# \d+ vv
View "public.vv"
Column | Type | Modifiers | Storage | Description
--------+---------+-----------+---------+-------------
c | integer | | plain |
View definition:
SELECT (v.foo)."........pg.dropped.3........" AS c
FROM v;
I don't actually mind this so much TBH...feature not bug. I hesitated
fixing this because I was terrified someone might actually fix it.
merlin
--
Sent via pgsql-hackers mailing list ([email protected])
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
