Thread: Re: FWD: Re: Updated backslash consistency patch
> 2. the help.c patch no longer applies > > 3. the help.c patch breaks alignment of the help output Attached is a patch to fix problems 2 and 3: help.c clean application and formatting of the output therein. I also put \z right after \dp and removed the duplicate wording, to make it fit better, per comments in this thread. -- Greg Sabino Mullane
Attachment
> Here's an updated version of the psql backslash patch that should > apply cleanly to the current HEAD. To recap, this makes all the \dX > commands (most importantly to most: \df) work like \dt does, in that it > requires a \dXS to see system items. See the archives for much more > discussion on the issue. Patch applied, thanks. --------------------------------------------------------------------------- Greg Sabino Mullane wrote: -- Start of PGP signed section. > > > 2. the help.c patch no longer applies > > > > 3. the help.c patch breaks alignment of the help output > > Attached is a patch to fix problems 2 and 3: help.c clean application and > formatting of the output therein. I also put \z right after \dp and removed > the duplicate wording, to make it fit better, per comments in this thread. > > -- > Greg Sabino Mullane [ Attachment, skipping... ] -- End of PGP section, PGP failed! -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
Bruce Momjian wrote: >> Here's an updated version of the psql backslash patch that should >> apply cleanly to the current HEAD. To recap, this makes all the \dX >> commands (most importantly to most: \df) work like \dt does, in that it >> requires a \dXS to see system items. See the archives for much more >> discussion on the issue. > > Patch applied, thanks. This patch has annoyed me twice in two days now, and similarly with other people I know. Having to type \dfS now is about the worst loss of usability in psql that I can recall. Can we reconsider or revert this?
--On Donnerstag, Januar 15, 2009 17:51:35 +0200 Peter Eisentraut
<peter_e@gmx.net> wrote:
> This patch has annoyed me twice in two days now, and similarly with other
> people I know. Having to type \dfS now is about the worst loss of
> usability in psql that I can recall. Can we reconsider or revert this?
I'd like to second this. It makes looking for specific functions and/or
other objects really awful, especially if you accidently forgot the S and
you're getting to think this function doesn't even exist....
-- Thanks
Bernd
Peter Eisentraut wrote: > Bruce Momjian wrote: > >> Here's an updated version of the psql backslash patch that should > >> apply cleanly to the current HEAD. To recap, this makes all the \dX > >> commands (most importantly to most: \df) work like \dt does, in that it > >> requires a \dXS to see system items. See the archives for much more > >> discussion on the issue. > > > > Patch applied, thanks. > > This patch has annoyed me twice in two days now, and similarly with > other people I know. Having to type \dfS now is about the worst loss of > usability in psql that I can recall. Can we reconsider or revert this? Well, \dT is even worse. ;-) (How many users have user-defined types?) The basic goal of the patch was to make 'S' consistent for all \d backslash commands, and we had a lot of discussion about it, and many people asked for it (I can't find my user functions). It is hard to argue that our previous behavior was logical (though perhaps useful). The only thing I can suggest at this point is some kind of setting that defaults to 'S' for psql \d commands, but that is going to affect \dt as well. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
Peter Eisentraut <peter_e@gmx.net> writes:
> This patch has annoyed me twice in two days now, and similarly with
> other people I know. Having to type \dfS now is about the worst loss of
> usability in psql that I can recall. Can we reconsider or revert this?
I agree, this change mostly sucks, and particularly with respect to \df.
regards, tom lane
Bruce Momjian wrote: > Peter Eisentraut wrote: >> Bruce Momjian wrote: >>>> Here's an updated version of the psql backslash patch that should >>>> apply cleanly to the current HEAD. To recap, this makes all the \dX >>>> commands (most importantly to most: \df) work like \dt does, in that it >>>> requires a \dXS to see system items. See the archives for much more >>>> discussion on the issue. >>> Patch applied, thanks. >> This patch has annoyed me twice in two days now, and similarly with >> other people I know. Having to type \dfS now is about the worst loss of >> usability in psql that I can recall. Can we reconsider or revert this? > > Well, \dT is even worse. ;-) (How many users have user-defined types?) > > The basic goal of the patch was to make 'S' consistent for all \d > backslash commands, and we had a lot of discussion about it, and many > people asked for it (I can't find my user functions). It is hard to > argue that our previous behavior was logical (though perhaps useful). Consistency is nice, but I'm used to typing \df pg_foobar() as well. Could we make plain "\df" list only user functions, but "\df XXX" search for system functions as well? And the same for all \d* commands, for the consistency. -- Heikki Linnakangas EnterpriseDB http://www.enterprisedb.com
Heikki Linnakangas wrote: > Bruce Momjian wrote: > > Peter Eisentraut wrote: > >> Bruce Momjian wrote: > >>>> Here's an updated version of the psql backslash patch that should > >>>> apply cleanly to the current HEAD. To recap, this makes all the \dX > >>>> commands (most importantly to most: \df) work like \dt does, in that it > >>>> requires a \dXS to see system items. See the archives for much more > >>>> discussion on the issue. > >>> Patch applied, thanks. > >> This patch has annoyed me twice in two days now, and similarly with > >> other people I know. Having to type \dfS now is about the worst loss of > >> usability in psql that I can recall. Can we reconsider or revert this? > > > > Well, \dT is even worse. ;-) (How many users have user-defined types?) > > > > The basic goal of the patch was to make 'S' consistent for all \d > > backslash commands, and we had a lot of discussion about it, and many > > people asked for it (I can't find my user functions). It is hard to > > argue that our previous behavior was logical (though perhaps useful). > > Consistency is nice, but I'm used to typing \df pg_foobar() as well. > Could we make plain "\df" list only user functions, but "\df XXX" search > for system functions as well? And the same for all \d* commands, for the > consistency. That makes sense; let me work on that. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
Bruce Momjian <bruce@momjian.us> writes:
> The basic goal of the patch was to make 'S' consistent for all \d
> backslash commands, and we had a lot of discussion about it, and many
> people asked for it (I can't find my user functions).
I think this falls in the category of "be careful what you wish for,
you might get it". It is now blindingly obvious that the folks asking
for that had not actually lived with the behavior for any period of
time.
Personally I think we should just revert the patch and go back to the
behavior we've had for umpteen years. However, if you cannot bear to
leave well enough alone, how about *reversing* the sense --- that is,
default behavior is to show everything and there is an extra character
to omit system objects?
regards, tom lane
Tom Lane wrote: > Bruce Momjian <bruce@momjian.us> writes: > > The basic goal of the patch was to make 'S' consistent for all \d > > backslash commands, and we had a lot of discussion about it, and many > > people asked for it (I can't find my user functions). > > I think this falls in the category of "be careful what you wish for, > you might get it". It is now blindingly obvious that the folks asking > for that had not actually lived with the behavior for any period of > time. > > Personally I think we should just revert the patch and go back to the > behavior we've had for umpteen years. However, if you cannot bear to > leave well enough alone, how about *reversing* the sense --- that is, > default behavior is to show everything and there is an extra character > to omit system objects? I got several emails thanking me for applying the patch, so there is clearly user-demand for 'S'. I think _we_ as developers look at the system stuff a lot but in user-land, they would rather not see it by default. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
-----BEGIN PGP SIGNED MESSAGE----- Hash: RIPEMD160 > This patch has annoyed me twice in two days now, and similarly with > other people I know. Having to type \dfS now is about the worst loss of > usability in psql that I can recall. Can we reconsider or revert this? The problem is that you, me, and the people we know are the only ones who actually use \df to see system functions. 99.99% of users don't care, or don't even know, about the system functions - but they do care about being able to view /their/ functions. So from a usability perspective, asking a small minority of users to learn to type an extra character is a small price to pay for a great leap in usability for everyone else. Frankly, the previous behavior was simply broken: there was no way to see all your functions (unless they happened to live in a single schema, then you could do the non-intuituve and annoying \df schemaname.) For the record, many of the people *I* know, including many 'hackers', like this change a lot. - -- Greg Sabino Mullane greg@turnstep.com End Point Corporation PGP Key: 0x14964AC8 200901151139 http://biglumber.com/x/web?pk=2529DF6AB8F79407E94445B4BC9B906714964AC8 -----BEGIN PGP SIGNATURE----- iEYEAREDAAYFAklvaAkACgkQvJuQZxSWSshpJQCbB5LbrjuP1Q9CcYAkdh6xLnoC kSsAoLvXVnGqJLi1RfnmIgzn/VRVjF9B =Twyv -----END PGP SIGNATURE-----
Tom Lane wrote: > Bruce Momjian <bruce@momjian.us> writes: >> The basic goal of the patch was to make 'S' consistent for all \d >> backslash commands, and we had a lot of discussion about it, and many >> people asked for it (I can't find my user functions). > > I think this falls in the category of "be careful what you wish for, > you might get it". It is now blindingly obvious that the folks asking > for that had not actually lived with the behavior for any period of > time. > > Personally I think we should just revert the patch and go back to the > behavior we've had for umpteen years. However, if you cannot bear to > leave well enough alone, how about *reversing* the sense --- that is, > default behavior is to show everything and there is an extra character > to omit system objects? (apologies if I didn't read the thread carefully enough to realize what it was about - it may be that we're talking about a different behavior than I'm referring to here...) Are you saying that "\dt" should include all system tables, for example? I'd find that a very bad thing... In fact, just to chime in on the opposite side of people here, I think that having "\df" just return the user defined functions is a *good* thing, one that I've wanted. Now, if I do "\df pg_something", I'd still like it to include system ones.. But finding your own user function in the plain \df list is horrible. //Magnus
On Thu, 2009-01-15 at 11:45 -0500, Bruce Momjian wrote: > Tom Lane wrote: > > Bruce Momjian <bruce@momjian.us> writes: > > I got several emails thanking me for applying the patch, so there is > clearly user-demand for 'S'. I think _we_ as developers look at the > system stuff a lot but in user-land, they would rather not see it by > default. +1. Joshua D. Drake > > -- > Bruce Momjian <bruce@momjian.us> http://momjian.us > EnterpriseDB http://enterprisedb.com > > + If your life is a hard drive, Christ can be your backup. + > -- PostgreSQL - XMPP: jdrake@jabber.postgresql.org Consulting, Development, Support, Training 503-667-4564 - http://www.commandprompt.com/ The PostgreSQL Company, serving since 1997
Bruce Momjian <bruce@momjian.us> writes:
> Tom Lane wrote:
>> I think this falls in the category of "be careful what you wish for,
>> you might get it". It is now blindingly obvious that the folks asking
>> for that had not actually lived with the behavior for any period of
>> time.
> I got several emails thanking me for applying the patch, so there is
> clearly user-demand for 'S'.
Were any of them from people who had actually *used* the patch for more
than five minutes? I think this is clearly a case of allowing abstract
consistency considerations to override usability.
The real problem here is that the 'S' suffix for \dt is a bad precedent
for everything else. If you want consistency then we need to change
that end of things. I think that the idea of a switch to omit system
objects, rather than include them, might work.
regards, tom lane
Tom Lane wrote: > Bruce Momjian <bruce@momjian.us> writes: > > Tom Lane wrote: > >> I think this falls in the category of "be careful what you wish for, > >> you might get it". It is now blindingly obvious that the folks asking > >> for that had not actually lived with the behavior for any period of > >> time. > > > I got several emails thanking me for applying the patch, so there is > > clearly user-demand for 'S'. > > Were any of them from people who had actually *used* the patch for more > than five minutes? I think this is clearly a case of allowing abstract > consistency considerations to override usability. > > The real problem here is that the 'S' suffix for \dt is a bad precedent > for everything else. If you want consistency then we need to change > that end of things. I think that the idea of a switch to omit system > objects, rather than include them, might work. Please test the attached patch; it reverts to pre-8.4 behavior if any pattern is present for psql \d commands, including just a simple '*'. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. + Index: src/bin/psql/describe.c =================================================================== RCS file: /cvsroot/pgsql/src/bin/psql/describe.c,v retrieving revision 1.195 diff -c -c -r1.195 describe.c *** src/bin/psql/describe.c 6 Jan 2009 23:01:57 -0000 1.195 --- src/bin/psql/describe.c 15 Jan 2009 16:50:45 -0000 *************** *** 94,100 **** "WHERE p.proisagg\n", gettext_noop("Description")); ! if (!showSystem) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, --- 94,100 ---- "WHERE p.proisagg\n", gettext_noop("Description")); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, *************** *** 281,287 **** " AND p.proargtypes[0] IS DISTINCT FROM 'pg_catalog.cstring'::pg_catalog.regtype\n" " AND NOT p.proisagg\n"); ! if (!showSystem) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, --- 281,287 ---- " AND p.proargtypes[0] IS DISTINCT FROM 'pg_catalog.cstring'::pg_catalog.regtype\n" " AND NOT p.proisagg\n"); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, *************** *** 372,378 **** else appendPQExpBuffer(&buf, " AND t.typname !~ '^_'\n"); ! if (!showSystem) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); /* Match name pattern against either internal or external name */ --- 372,378 ---- else appendPQExpBuffer(&buf, " AND t.typname !~ '^_'\n"); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); /* Match name pattern against either internal or external name */ *************** *** 427,436 **** gettext_noop("Result type"), gettext_noop("Description")); ! if (!showSystem) appendPQExpBuffer(&buf, " WHERE n.nspname <> 'pg_catalog'\n"); ! processSQLNamePattern(pset.db, &buf, pattern, !showSystem, true, "n.nspname", "o.oprname", NULL, "pg_catalog.pg_operator_is_visible(o.oid)"); --- 427,436 ---- gettext_noop("Result type"), gettext_noop("Description")); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " WHERE n.nspname <> 'pg_catalog'\n"); ! processSQLNamePattern(pset.db, &buf, pattern, !showSystem && !pattern, true, "n.nspname", "o.oprname", NULL, "pg_catalog.pg_operator_is_visible(o.oid)"); *************** *** 620,626 **** " WHERE p.proisagg\n", gettext_noop("aggregate")); ! if (!showSystem) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, --- 620,626 ---- " WHERE p.proisagg\n", gettext_noop("aggregate")); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, *************** *** 643,649 **** " AND NOT p.proisagg\n", gettext_noop("function")); ! if (!showSystem) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, --- 643,649 ---- " AND NOT p.proisagg\n", gettext_noop("function")); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, *************** *** 661,670 **** " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = o.oprnamespace\n", gettext_noop("operator")); ! if (!showSystem) appendPQExpBuffer(&buf, " WHERE n.nspname <> 'pg_catalog'\n"); ! processSQLNamePattern(pset.db, &buf, pattern, !showSystem, false, "n.nspname", "o.oprname", NULL, "pg_catalog.pg_operator_is_visible(o.oid)"); --- 661,670 ---- " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = o.oprnamespace\n", gettext_noop("operator")); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " WHERE n.nspname <> 'pg_catalog'\n"); ! processSQLNamePattern(pset.db, &buf, pattern, !showSystem && !pattern, false, "n.nspname", "o.oprname", NULL, "pg_catalog.pg_operator_is_visible(o.oid)"); *************** *** 679,688 **** " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n", gettext_noop("data type")); ! if (!showSystem) appendPQExpBuffer(&buf, " WHERE n.nspname <> 'pg_catalog'\n"); ! processSQLNamePattern(pset.db, &buf, pattern, !showSystem, false, "n.nspname", "pg_catalog.format_type(t.oid, NULL)", NULL, "pg_catalog.pg_type_is_visible(t.oid)"); --- 679,688 ---- " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n", gettext_noop("data type")); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " WHERE n.nspname <> 'pg_catalog'\n"); ! processSQLNamePattern(pset.db, &buf, pattern, !showSystem && !pattern, false, "n.nspname", "pg_catalog.format_type(t.oid, NULL)", NULL, "pg_catalog.pg_type_is_visible(t.oid)"); *************** *** 703,709 **** gettext_noop("view"), gettext_noop("index"), gettext_noop("sequence")); ! if (!showSystem) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, --- 703,709 ---- gettext_noop("view"), gettext_noop("index"), gettext_noop("sequence")); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, *************** *** 723,729 **** " WHERE r.rulename != '_RETURN'\n", gettext_noop("rule")); ! if (!showSystem) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); /* XXX not sure what to do about visibility rule here? */ --- 723,729 ---- " WHERE r.rulename != '_RETURN'\n", gettext_noop("rule")); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); /* XXX not sure what to do about visibility rule here? */ *************** *** 742,752 **** " JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid\n" " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n", gettext_noop("trigger")); ! if (!showSystem) appendPQExpBuffer(&buf, " WHERE n.nspname <> 'pg_catalog'\n"); /* XXX not sure what to do about visibility rule here? */ ! processSQLNamePattern(pset.db, &buf, pattern, !showSystem, false, "n.nspname", "t.tgname", NULL, "pg_catalog.pg_table_is_visible(c.oid)"); --- 742,752 ---- " JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid\n" " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n", gettext_noop("trigger")); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " WHERE n.nspname <> 'pg_catalog'\n"); /* XXX not sure what to do about visibility rule here? */ ! processSQLNamePattern(pset.db, &buf, pattern, !showSystem && !pattern, false, "n.nspname", "t.tgname", NULL, "pg_catalog.pg_table_is_visible(c.oid)"); *************** *** 1961,1967 **** appendPQExpBuffer(&buf, "'i',"); if (showSeq) appendPQExpBuffer(&buf, "'S',"); ! if (showSystem && showTables) appendPQExpBuffer(&buf, "'s',"); appendPQExpBuffer(&buf, "''"); /* dummy */ appendPQExpBuffer(&buf, ")\n"); --- 1961,1967 ---- appendPQExpBuffer(&buf, "'i',"); if (showSeq) appendPQExpBuffer(&buf, "'S',"); ! if ((showSystem || pattern) && showTables) appendPQExpBuffer(&buf, "'s',"); appendPQExpBuffer(&buf, "''"); /* dummy */ appendPQExpBuffer(&buf, ")\n"); *************** *** 1971,1983 **** * pg_catalog). Otherwise, suppress system objects, including those in * pg_catalog and pg_toast. (We don't want to hide temp tables though.) */ ! if (showSystem) ! appendPQExpBuffer(&buf, ! " AND n.nspname = 'pg_catalog'\n"); ! else ! appendPQExpBuffer(&buf, ! " AND n.nspname <> 'pg_catalog'\n" ! " AND n.nspname !~ '^pg_toast'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, "n.nspname", "c.relname", NULL, --- 1971,1986 ---- * pg_catalog). Otherwise, suppress system objects, including those in * pg_catalog and pg_toast. (We don't want to hide temp tables though.) */ ! if (!pattern) ! { ! if (showSystem) ! appendPQExpBuffer(&buf, ! " AND n.nspname = 'pg_catalog'\n"); ! else ! appendPQExpBuffer(&buf, ! " AND n.nspname <> 'pg_catalog'\n" ! " AND n.nspname !~ '^pg_toast'\n"); ! } processSQLNamePattern(pset.db, &buf, pattern, true, false, "n.nspname", "c.relname", NULL, *************** *** 2046,2052 **** gettext_noop("Modifier"), gettext_noop("Check")); ! if (!showSystem) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, --- 2049,2055 ---- gettext_noop("Modifier"), gettext_noop("Check")); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, *************** *** 2101,2107 **** gettext_noop("yes"), gettext_noop("no"), gettext_noop("Default?")); ! if (!showSystem) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false, --- 2104,2110 ---- gettext_noop("yes"), gettext_noop("no"), gettext_noop("Default?")); ! if (!showSystem && !pattern) appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"); processSQLNamePattern(pset.db, &buf, pattern, true, false,
On Fri, Jan 16, 2009 at 3:45 AM, Greg Sabino Mullane <greg@turnstep.com> wrote: > The problem is that you, me, and the people we know are the only ones > who actually use \df to see system functions. 99.99% of users don't care, > or don't even know, about the system functions - but they do care about > being able to view /their/ functions. So from a usability perspective, > asking a small minority of users to learn to type an extra character is > a small price to pay for a great leap in usability for everyone else. > +1. Most people wanting to learn about which system functions are available will be surely be going to the manual, not using \df? For example if you wanted to know what functions were around for doing stuff with dates, \df date* is almost useless. Most of the functions listed are operator and index support stuff. I can't imagine anyone in userland wanting date_ne_timestamptz(), say, to show up as a result of \df. I have ocassionally used things like \do to search for the more obscure operators, but honestly most of the time when I use a \d command, all I want to see is my user-defined stuff. Cheers, BJ
>> > The basic goal of the patch was to make 'S' consistent for all \d >> > backslash commands, and we had a lot of discussion about it, and many >> > people asked for it (I can't find my user functions). >> >> I think this falls in the category of "be careful what you wish for, >> you might get it". It is now blindingly obvious that the folks asking >> for that had not actually lived with the behavior for any period of >> time. >> >> Personally I think we should just revert the patch and go back to the >> behavior we've had for umpteen years. However, if you cannot bear to >> leave well enough alone, how about *reversing* the sense --- that is, >> default behavior is to show everything and there is an extra character >> to omit system objects? > > I got several emails thanking me for applying the patch, so there is > clearly user-demand for 'S'. I think _we_ as developers look at the > system stuff a lot but in user-land, they would rather not see it by > default. +1. It is seriously annoying that there is no easy way to see the functions that you've defined without seeing all the, ahem, crap in the system catalogs. Now maybe there should be a way to toggle the behavior, but please let's not think that everyone cares to see RI_FKey_noaction_del every time they hit \df. Noooo! ...Robert
I would settle for just following the search path as set by the user.
If you explicitly include pg_catalog in the search path, then you should see those settings.
If you do not explicitly include pg_catalog on the search_path, then it should not find those items.
Right now pg_catalog sneaks its way onto the search_path for everybody. That is fine for execution but information listing like this should probably ignore those additions.
If you explicitly include pg_catalog in the search path, then you should see those settings.
If you do not explicitly include pg_catalog on the search_path, then it should not find those items.
Right now pg_catalog sneaks its way onto the search_path for everybody. That is fine for execution but information listing like this should probably ignore those additions.
On Thu, Jan 15, 2009 at 11:50 AM, Tom Lane <tgl@sss.pgh.pa.us> wrote:
Bruce Momjian <bruce@momjian.us> writes:> Tom Lane wrote:
>> I think this falls in the category of "be careful what you wish for,
>> you might get it". It is now blindingly obvious that the folks asking
>> for that had not actually lived with the behavior for any period of
>> time.> I got several emails thanking me for applying the patch, so there isWere any of them from people who had actually *used* the patch for more
> clearly user-demand for 'S'.
than five minutes? I think this is clearly a case of allowing abstract
consistency considerations to override usability.
The real problem here is that the 'S' suffix for \dt is a bad precedent
for everything else. If you want consistency then we need to change
that end of things. I think that the idea of a switch to omit system
objects, rather than include them, might work.
regards, tom lane
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
On Fri, Jan 16, 2009 at 03:59:47AM +1100, Brendan Jurd wrote: > Most people wanting to learn about which system functions are > available will be surely be going to the manual, not using \df? Presently the only way you'll get a list of functions that operate on large objects is to use \df. They mirror the client side API[1] quite closely so using a combination of \df and the manual works reasonably well. -- Sam http://samason.me.uk/ [1] http://www.postgresql.org/docs/8.3/static/lo-interfaces.html
"Brendan Jurd" <direvus@gmail.com> writes:
> Most people wanting to learn about which system functions are
> available will be surely be going to the manual, not using \df?
I think people use \df all the time to check the argument list, verify
whether they remember the function name correctly, etc. It's not for
"learning about" stuff you never heard of, it's for remembering details
(as indeed is the usage for user-defined functions too).
regards, tom lane
Tom Lane wrote: > "Brendan Jurd" <direvus@gmail.com> writes: > > Most people wanting to learn about which system functions are > > available will be surely be going to the manual, not using \df? > > I think people use \df all the time to check the argument list, verify > whether they remember the function name correctly, etc. It's not for > "learning about" stuff you never heard of, it's for remembering details > (as indeed is the usage for user-defined functions too). Which means my patch will work perfectly for them (because of the pattern), and hopefully for you. ;-) -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
On Thu, 2009-01-15 at 12:36 -0500, Tom Lane wrote: > "Brendan Jurd" <direvus@gmail.com> writes: > > Most people wanting to learn about which system functions are > > available will be surely be going to the manual, not using \df? > > I think people use \df all the time to check the argument list, verify > whether they remember the function name correctly, etc. It's not for > "learning about" stuff you never heard of, it's for remembering details > (as indeed is the usage for user-defined functions too). Perhaps the way to solve this problem is to change the way the output is rendered. E.g; \df output wraps at 1024x768 which greatly limits usability as a whole. I hadn't noticed this until today as my workstation video card exploded and I have a temporary one that can't do more than 1024x768 with linux. Dropping the return type from the default output would solve this problem I think (use + to get the return type). More importantly why not just have it so \df sorts like this: 1. session users functions first 2. public functions second 3. pg_catalog functions last Sincerely, Joshua D. Drake > > regards, tom lane > -- PostgreSQL - XMPP: jdrake@jabber.postgresql.org Consulting, Development, Support, Training 503-667-4564 - http://www.commandprompt.com/ The PostgreSQL Company, serving since 1997
Bruce Momjian <bruce@momjian.us> writes:
> Tom Lane wrote:
>> I think people use \df all the time to check the argument list, verify
>> whether they remember the function name correctly, etc. It's not for
>> "learning about" stuff you never heard of, it's for remembering details
>> (as indeed is the usage for user-defined functions too).
> Which means my patch will work perfectly for them (because of the
> pattern), and hopefully for you. ;-)
I can agree that it's reasonable for the default behavior with no
arguments (no pattern) to be to show only user-defined objects.
Otherwise you're going to get quite a long list, which doesn't
seem particularly useful --- and if you really want that, you can
say '*.*' so there's no loss of functionality if we change it.
However, if we don't have that restriction when a pattern is given,
I wonder whether we need the 'S' modifier at all. If you really
want to see only system objects, there's 'pg_catalog.*', but this
doesn't seem like a case that's so common that it needs a command
modifier letter.
So my proposal at the moment is to get rid of 'S', have the behavior
with a pattern be the same as it was before, and only change the
behavior with no pattern.
regards, tom lane
Tom Lane wrote: > Bruce Momjian <bruce@momjian.us> writes: > > Tom Lane wrote: > >> I think people use \df all the time to check the argument list, verify > >> whether they remember the function name correctly, etc. It's not for > >> "learning about" stuff you never heard of, it's for remembering details > >> (as indeed is the usage for user-defined functions too). > > > Which means my patch will work perfectly for them (because of the > > pattern), and hopefully for you. ;-) > > I can agree that it's reasonable for the default behavior with no > arguments (no pattern) to be to show only user-defined objects. > Otherwise you're going to get quite a long list, which doesn't > seem particularly useful --- and if you really want that, you can > say '*.*' so there's no loss of functionality if we change it. > > However, if we don't have that restriction when a pattern is given, > I wonder whether we need the 'S' modifier at all. If you really > want to see only system objects, there's 'pg_catalog.*', but this > doesn't seem like a case that's so common that it needs a command > modifier letter. > > So my proposal at the moment is to get rid of 'S', have the behavior > with a pattern be the same as it was before, and only change the > behavior with no pattern. Well, this is psql and it should be easy; I am not sure pg_catalog.* fits that requirement. Right now if you do \dt you see user tables, and \dtS shows system tables; I don't see removing 'S' as being a great usability gain. I think searching for both user and system stuff with a pattern is a no-brainer. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
On Thu, Jan 15, 2009 at 09:49:59AM -0800, Joshua D. Drake wrote: > \df output wraps at 1024x768 which greatly limits usability as a whole. > I hadn't noticed this until today as my workstation video card exploded > and I have a temporary one that can't do more than 1024x768 with linux. > Dropping the return type from the default output would solve this > problem I think (use + to get the return type). Isn't this more of a problem for your pager? it's reasonably easy to configure this to be "less -S" which will make things look prettier for you. -- Sam http://samason.me.uk/
Rod Taylor <rod.taylor@gmail.com> writes:
> Right now pg_catalog sneaks its way onto the search_path for everybody. That
> is fine for execution but information listing like this should probably
> ignore those additions.
Actually, the single worst, most misleading, pernicious and dangerous
aspect of the currently committed behavior is exactly that it doesn't
work exactly like the search path. If I say "\df foo", it should tell
me about the same function(s) I would get from "select foo(...)".
As-is, it would tell me about a user-defined function even if that
function is masked by a similarly named system function. I don't
think that should *ever* happen. The converse is true if I have a
user function masking a system function (which is also possible, though
not with the default search path). So it's arguable that both 'S'
and the reverse are bad ideas.
regards, tom lane
Bruce Momjian <bruce@momjian.us> writes:
> Well, this is psql and it should be easy; I am not sure pg_catalog.*
> fits that requirement.
It should be easy for common cases, which I argue "I need to see *only*
system objects" is not.
> Right now if you do \dt you see user tables, and
> \dtS shows system tables; I don't see removing 'S' as being a great
> usability gain.
It's removal of unnecessary complexity. These commands are teetering on
the edge of being too complicated to explain already.
regards, tom lane
> I think searching for both user and system stuff with a pattern is a > no-brainer. I'm not sure whether you're endorsing that approach or panning it, but -1 from me. We have always had \d or \dt for user tables and \dS or \dtS for system tables. No one is complaining about this AFAICS, so we should \df be any different? The only argument I can see is that "it's always been different", but IMHO, making it still be inconsistent yet in a sneakier and less intuitive way doesn't seem like a step forward. ...Robert
"Robert Haas" <robertmhaas@gmail.com> writes:
> I'm not sure whether you're endorsing that approach or panning it, but
> -1 from me. We have always had \d or \dt for user tables and \dS or
> \dtS for system tables. No one is complaining about this AFAICS, so
> we should \df be any different? The only argument I can see is that
> "it's always been different", but IMHO, making it still be
> inconsistent yet in a sneakier and less intuitive way doesn't seem
> like a step forward.
You're ignoring the fact that tables and functions are different and
are used differently. In particular, most of the system catalogs are
not really meant to be used directly by users, which is surely not
true for functions and operators.
However, having said that, I'm not averse to unifying the behavior
as long as it's done in a sensible fashion. Imposing the old behavior
of \dt on everything else is simply not that sensible fashion.
regards, tom lane
How many of the people who find the new behaviour are mainly postgres hackers and not users? I remember finding the behaviour *very* frustrating when I was a user and was mainly concerned with maintaining my own functions. I hardly ever used \df for system functions. Now the situation is reversed - I mainly work with test databases with simple schemas. But it's common for users to have hundreds of functions - and much more likely that they would want to look them up by name. -- Greg On 15 Jan 2009, at 16:39, Tom Lane <tgl@sss.pgh.pa.us> wrote: > Bruce Momjian <bruce@momjian.us> writes: >> The basic goal of the patch was to make 'S' consistent for all \d >> backslash commands, and we had a lot of discussion about it, and many >> people asked for it (I can't find my user functions). > > I think this falls in the category of "be careful what you wish for, > you might get it". It is now blindingly obvious that the folks asking > for that had not actually lived with the behavior for any period of > time. > > Personally I think we should just revert the patch and go back to the > behavior we've had for umpteen years. However, if you cannot bear to > leave well enough alone, how about *reversing* the sense --- that is, > default behavior is to show everything and there is an extra character > to omit system objects? > > regards, tom lane > > -- > Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org) > To make changes to your subscription: > http://www.postgresql.org/mailpref/pgsql-hackers
On Thu, 2009-01-15 at 18:25 +0000, Greg Stark wrote:
> How many of the people who find the new behaviour are mainly postgres
> hackers and not users?
>
> I remember finding the behaviour *very* frustrating when I was a user
> and was mainly concerned with maintaining my own functions. I hardly
> ever used \df for system functions.
>
> Now the situation is reversed - I mainly work with test databases with
> simple schemas. But it's common for users to have hundreds of
> functions - and much more likely that they would want to look them up
> by name.
Very well said Greg. To add to this, I find that sometimes an
illustration of the problem is useful. Below is the \df of a sample
postgres database. Notice that the first 1854 entries are pg_catalog
entries.
How in any way is that manageable when what I want to see my functions?
I know I already posted this but it seems the most useful behavior is to
just change the sort. It doesn't change any behavior in terms of
flags/switches so there is nothing new to learn. It just changes the
output.
List of functions Schema | Name | Result
data type |
Argument data
types
------------+----------------------------------------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------pg_catalog
|RI_FKey_cascade_del | trigger
| pg_catalog | RI_FKey_cascade_upd | trigger
| pg_catalog | RI_FKey_check_ins | trigger
| pg_catalog | RI_FKey_check_upd | trigger
| pg_catalog | RI_FKey_noaction_del | trigger
| pg_catalog | RI_FKey_noaction_upd | trigger
| pg_catalog | RI_FKey_restrict_del | trigger
| pg_catalog | RI_FKey_restrict_upd | trigger
| pg_catalog | RI_FKey_setdefault_del | trigger
| pg_catalog | RI_FKey_setdefault_upd | trigger
| pg_catalog | RI_FKey_setnull_del | trigger
| pg_catalog | RI_FKey_setnull_upd | trigger
| pg_catalog | abbrev | text
| cidrpg_catalog | abbrev | text
| inetpg_catalog | abs | bigint
| bigintpg_catalog | abs | double
precision | double precisionpg_catalog | abs | integer
| integerpg_catalog | abs | numeric
| numericpg_catalog | abs | real
| realpg_catalog | abs | smallint
| smallintpg_catalog | abstime | abstime
| timestamp without time zonepg_catalog | abstime | abstime
| timestamp with time zonepg_catalog | abstimeeq | boolean
| abstime, abstimepg_catalog | abstimege | boolean
| abstime, abstimepg_catalog | abstimegt | boolean
| abstime, abstimepg_catalog | abstimele | boolean
| abstime, abstimepg_catalog | abstimelt | boolean
| abstime, abstimepg_catalog | abstimene | boolean
| abstime, abstimepg_catalog | abstimerecv | abstime
| internalpg_catalog | abstimesend | bytea
| abstimepg_catalog | aclcontains | boolean
| aclitem[], aclitempg_catalog | aclinsert | aclitem[]
| aclitem[], aclitempg_catalog | aclitemeq | boolean
| aclitem, aclitempg_catalog | aclremove | aclitem[]
| aclitem[], aclitempg_catalog | acos | double
precision | double precisionpg_catalog | age | integer
| xidpg_catalog | age | interval
| timestamp without time zonepg_catalog | age | interval
| timestamp without time zone, timestamp without time zonepg_catalog | age |
interval
| timestamp with time zonepg_catalog | age | interval
| timestamp with time zone, timestamp with time zonepg_catalog | anyarray_recv |
anyarray
| internalpg_catalog | anyarray_send | bytea
| anyarraypg_catalog | anytextcat | text
| anynonarray, textpg_catalog | area | double
precision | boxpg_catalog | area | double
precision | circlepg_catalog | area | double
precision | pathpg_catalog | areajoinsel | double
precision | internal, oid, internal, smallintpg_catalog | areasel |
double
precision | internal, oid, internal, integerpg_catalog | array_append |
anyarray
| anyarray, anyelementpg_catalog | array_cat | anyarray
| anyarray, anyarraypg_catalog | array_dims | text
| anyarraypg_catalog | array_eq | boolean
| anyarray, anyarraypg_catalog | array_ge | boolean
| anyarray, anyarraypg_catalog | array_gt | boolean
| anyarray, anyarraypg_catalog | array_larger | anyarray
| anyarray, anyarraypg_catalog | array_le | boolean
| anyarray, anyarraypg_catalog | array_lower | integer
| anyarray, integerpg_catalog | array_lt | boolean
| anyarray, anyarraypg_catalog | array_ne | boolean
| anyarray, anyarraypg_catalog | array_prepend | anyarray
| anyelement, anyarraypg_catalog | array_recv | anyarray
| internal, oid, integerpg_catalog | array_send | bytea
| anyarraypg_catalog | array_smaller | anyarray
| anyarray, anyarraypg_catalog | array_to_string | text
| anyarray, textpg_catalog | array_upper | integer
| anyarray, integerpg_catalog | arraycontained | boolean
| anyarray, anyarraypg_catalog | arraycontains | boolean
| anyarray, anyarraypg_catalog | arrayoverlap | boolean
| anyarray, anyarraypg_catalog | ascii | integer
| textpg_catalog | ascii_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | ascii_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | asin | double
precision | double precisionpg_catalog | atan | double
precision | double precisionpg_catalog | atan2 | double
precision | double precision, double precisionpg_catalog | big5_to_euc_tw |
void
| integer, integer, cstring, internal, integerpg_catalog | big5_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | big5_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | bit | bit
| bigint, integerpg_catalog | bit | bit
| bit, integer, booleanpg_catalog | bit | bit
| integer, integerpg_catalog | bit_length | integer
| bitpg_catalog | bit_length | integer
| byteapg_catalog | bit_length | integer
| textpg_catalog | bit_recv | bit
| internal, oid, integerpg_catalog | bit_send | bytea
| bitpg_catalog | bitand | bit
| bit, bitpg_catalog | bitcat | bit varying
| bit varying, bit varyingpg_catalog | bitcmp | integer
| bit, bitpg_catalog | biteq | boolean
| bit, bitpg_catalog | bitge | boolean
| bit, bitpg_catalog | bitgt | boolean
| bit, bitpg_catalog | bitle | boolean
| bit, bitpg_catalog | bitlt | boolean
| bit, bitpg_catalog | bitne | boolean
| bit, bitpg_catalog | bitnot | bit
| bitpg_catalog | bitor | bit
| bit, bitpg_catalog | bitshiftleft | bit
| bit, integerpg_catalog | bitshiftright | bit
| bit, integerpg_catalog | bittypmodin | integer
| cstring[]pg_catalog | bitxor | bit
| bit, bitpg_catalog | bool | boolean
| integerpg_catalog | booland_statefunc | boolean
| boolean, booleanpg_catalog | booleq | boolean
| boolean, booleanpg_catalog | boolge | boolean
| boolean, booleanpg_catalog | boolgt | boolean
| boolean, booleanpg_catalog | boolle | boolean
| boolean, booleanpg_catalog | boollt | boolean
| boolean, booleanpg_catalog | boolne | boolean
| boolean, booleanpg_catalog | boolor_statefunc | boolean
| boolean, booleanpg_catalog | boolrecv | boolean
| internalpg_catalog | boolsend | bytea
| booleanpg_catalog | box | box
| circlepg_catalog | box | box
| point, pointpg_catalog | box | box
| polygonpg_catalog | box_above | boolean
| box, boxpg_catalog | box_above_eq | boolean
| box, boxpg_catalog | box_add | box
| box, pointpg_catalog | box_below | boolean
| box, boxpg_catalog | box_below_eq | boolean
| box, boxpg_catalog | box_center | point
| boxpg_catalog | box_contain | boolean
| box, boxpg_catalog | box_contained | boolean
| box, boxpg_catalog | box_distance | double
precision | box, boxpg_catalog | box_div | box
| box, pointpg_catalog | box_eq | boolean
| box, boxpg_catalog | box_ge | boolean
| box, boxpg_catalog | box_gt | boolean
| box, boxpg_catalog | box_intersect | box
| box, boxpg_catalog | box_le | boolean
| box, boxpg_catalog | box_left | boolean
| box, boxpg_catalog | box_lt | boolean
| box, boxpg_catalog | box_mul | box
| box, pointpg_catalog | box_overabove | boolean
| box, boxpg_catalog | box_overbelow | boolean
| box, boxpg_catalog | box_overlap | boolean
| box, boxpg_catalog | box_overleft | boolean
| box, boxpg_catalog | box_overright | boolean
| box, boxpg_catalog | box_recv | box
| internalpg_catalog | box_right | boolean
| box, boxpg_catalog | box_same | boolean
| box, boxpg_catalog | box_send | bytea
| boxpg_catalog | box_sub | box
| box, pointpg_catalog | bpchar | character
| "char"pg_catalog | bpchar | character
| character, integer, booleanpg_catalog | bpchar | character
| namepg_catalog | bpchar_larger | character
| character, characterpg_catalog | bpchar_pattern_eq | boolean
| character, characterpg_catalog | bpchar_pattern_ge | boolean
| character, characterpg_catalog | bpchar_pattern_gt | boolean
| character, characterpg_catalog | bpchar_pattern_le | boolean
| character, characterpg_catalog | bpchar_pattern_lt | boolean
| character, characterpg_catalog | bpchar_pattern_ne | boolean
| character, characterpg_catalog | bpchar_smaller | character
| character, characterpg_catalog | bpcharcmp | integer
| character, characterpg_catalog | bpchareq | boolean
| character, characterpg_catalog | bpcharge | boolean
| character, characterpg_catalog | bpchargt | boolean
| character, characterpg_catalog | bpchariclike | boolean
| character, textpg_catalog | bpcharicnlike | boolean
| character, textpg_catalog | bpcharicregexeq | boolean
| character, textpg_catalog | bpcharicregexne | boolean
| character, textpg_catalog | bpcharle | boolean
| character, characterpg_catalog | bpcharlike | boolean
| character, textpg_catalog | bpcharlt | boolean
| character, characterpg_catalog | bpcharne | boolean
| character, characterpg_catalog | bpcharnlike | boolean
| character, textpg_catalog | bpcharrecv | character
| internal, oid, integerpg_catalog | bpcharregexeq | boolean
| character, textpg_catalog | bpcharregexne | boolean
| character, textpg_catalog | bpcharsend | bytea
| characterpg_catalog | bpchartypmodin | integer
| cstring[]pg_catalog | broadcast | inet
| inetpg_catalog | btabstimecmp | integer
| abstime, abstimepg_catalog | btarraycmp | integer
| anyarray, anyarraypg_catalog | btbeginscan | internal
| internal, internal, internalpg_catalog | btboolcmp | integer
| boolean, booleanpg_catalog | btbpchar_pattern_cmp | integer
| character, characterpg_catalog | btbuild | internal
| internal, internal, internalpg_catalog | btbulkdelete | internal
| internal, internal, internal, internalpg_catalog | btcharcmp | integer
| "char", "char"pg_catalog | btcostestimate | void
| internal, internal, internal, internal, internal, internal, internal,
internalpg_catalog | btendscan | void
| internalpg_catalog | btfloat48cmp | integer
| real, double precisionpg_catalog | btfloat4cmp | integer
| real, realpg_catalog | btfloat84cmp | integer
| double precision, realpg_catalog | btfloat8cmp | integer
| double precision, double precisionpg_catalog | btgetmulti | boolean
| internal, internal, internal, internalpg_catalog | btgettuple | boolean
| internal, internalpg_catalog | btinsert | boolean
| internal, internal, internal, internal, internal, internalpg_catalog | btint24cmp |
integer
| smallint, integerpg_catalog | btint28cmp | integer
| smallint, bigintpg_catalog | btint2cmp | integer
| smallint, smallintpg_catalog | btint42cmp | integer
| integer, smallintpg_catalog | btint48cmp | integer
| integer, bigintpg_catalog | btint4cmp | integer
| integer, integerpg_catalog | btint82cmp | integer
| bigint, smallintpg_catalog | btint84cmp | integer
| bigint, integerpg_catalog | btint8cmp | integer
| bigint, bigintpg_catalog | btmarkpos | void
| internalpg_catalog | btname_pattern_cmp | integer
| name, namepg_catalog | btnamecmp | integer
| name, namepg_catalog | btoidcmp | integer
| oid, oidpg_catalog | btoidvectorcmp | integer
| oidvector, oidvectorpg_catalog | btoptions | bytea
| text[], booleanpg_catalog | btreltimecmp | integer
| reltime, reltimepg_catalog | btrescan | void
| internal, internalpg_catalog | btrestrpos | void
| internalpg_catalog | btrim | bytea
| bytea, byteapg_catalog | btrim | text
| textpg_catalog | btrim | text
| text, textpg_catalog | bttext_pattern_cmp | integer
| text, textpg_catalog | bttextcmp | integer
| text, textpg_catalog | bttidcmp | integer
| tid, tidpg_catalog | bttintervalcmp | integer
| tinterval, tintervalpg_catalog | btvacuumcleanup | internal
| internal, internalpg_catalog | byteacat | bytea
| bytea, byteapg_catalog | byteacmp | integer
| bytea, byteapg_catalog | byteaeq | boolean
| bytea, byteapg_catalog | byteage | boolean
| bytea, byteapg_catalog | byteagt | boolean
| bytea, byteapg_catalog | byteale | boolean
| bytea, byteapg_catalog | bytealike | boolean
| bytea, byteapg_catalog | bytealt | boolean
| bytea, byteapg_catalog | byteane | boolean
| bytea, byteapg_catalog | byteanlike | boolean
| bytea, byteapg_catalog | bytearecv | bytea
| internalpg_catalog | byteasend | bytea
| byteapg_catalog | cash_cmp | integer
| money, moneypg_catalog | cash_div_flt4 | money
| money, realpg_catalog | cash_div_flt8 | money
| money, double precisionpg_catalog | cash_div_int2 | money
| money, smallintpg_catalog | cash_div_int4 | money
| money, integerpg_catalog | cash_eq | boolean
| money, moneypg_catalog | cash_ge | boolean
| money, moneypg_catalog | cash_gt | boolean
| money, moneypg_catalog | cash_le | boolean
| money, moneypg_catalog | cash_lt | boolean
| money, moneypg_catalog | cash_mi | money
| money, moneypg_catalog | cash_mul_flt4 | money
| money, realpg_catalog | cash_mul_flt8 | money
| money, double precisionpg_catalog | cash_mul_int2 | money
| money, smallintpg_catalog | cash_mul_int4 | money
| money, integerpg_catalog | cash_ne | boolean
| money, moneypg_catalog | cash_pl | money
| money, moneypg_catalog | cash_recv | money
| internalpg_catalog | cash_send | bytea
| moneypg_catalog | cash_words | text
| moneypg_catalog | cashlarger | money
| money, moneypg_catalog | cashsmaller | money
| money, moneypg_catalog | cbrt | double
precision | double precisionpg_catalog | ceil | double
precision | double precisionpg_catalog | ceil | numeric
| numericpg_catalog | ceiling | double
precision | double precisionpg_catalog | ceiling | numeric
| numericpg_catalog | center | point
| boxpg_catalog | center | point
| circlepg_catalog | char | "char"
| integerpg_catalog | char | "char"
| textpg_catalog | char_length | integer
| characterpg_catalog | char_length | integer
| textpg_catalog | character_length | integer
| characterpg_catalog | character_length | integer
| textpg_catalog | chareq | boolean
| "char", "char"pg_catalog | charge | boolean
| "char", "char"pg_catalog | chargt | boolean
| "char", "char"pg_catalog | charle | boolean
| "char", "char"pg_catalog | charlt | boolean
| "char", "char"pg_catalog | charne | boolean
| "char", "char"pg_catalog | charrecv | "char"
| internalpg_catalog | charsend | bytea
| "char"pg_catalog | chr | text
| integerpg_catalog | cideq | boolean
| cid, cidpg_catalog | cidr | cidr
| inetpg_catalog | cidr_recv | cidr
| internalpg_catalog | cidr_send | bytea
| cidrpg_catalog | cidrecv | cid
| internalpg_catalog | cidsend | bytea
| cidpg_catalog | circle | circle
| boxpg_catalog | circle | circle
| point, double precisionpg_catalog | circle | circle
| polygonpg_catalog | circle_above | boolean
| circle, circlepg_catalog | circle_add_pt | circle
| circle, pointpg_catalog | circle_below | boolean
| circle, circlepg_catalog | circle_center | point
| circlepg_catalog | circle_contain | boolean
| circle, circlepg_catalog | circle_contain_pt | boolean
| circle, pointpg_catalog | circle_contained | boolean
| circle, circlepg_catalog | circle_distance | double
precision | circle, circlepg_catalog | circle_div_pt | circle
| circle, pointpg_catalog | circle_eq | boolean
| circle, circlepg_catalog | circle_ge | boolean
| circle, circlepg_catalog | circle_gt | boolean
| circle, circlepg_catalog | circle_le | boolean
| circle, circlepg_catalog | circle_left | boolean
| circle, circlepg_catalog | circle_lt | boolean
| circle, circlepg_catalog | circle_mul_pt | circle
| circle, pointpg_catalog | circle_ne | boolean
| circle, circlepg_catalog | circle_overabove | boolean
| circle, circlepg_catalog | circle_overbelow | boolean
| circle, circlepg_catalog | circle_overlap | boolean
| circle, circlepg_catalog | circle_overleft | boolean
| circle, circlepg_catalog | circle_overright | boolean
| circle, circlepg_catalog | circle_recv | circle
| internalpg_catalog | circle_right | boolean
| circle, circlepg_catalog | circle_same | boolean
| circle, circlepg_catalog | circle_send | bytea
| circlepg_catalog | circle_sub_pt | circle
| circle, pointpg_catalog | clock_timestamp | timestamp
with time zone | pg_catalog | close_lb | point
| line, boxpg_catalog | close_ls | point
| line, lsegpg_catalog | close_lseg | point
| lseg, lsegpg_catalog | close_pb | point
| point, boxpg_catalog | close_pl | point
| point, linepg_catalog | close_ps | point
| point, lsegpg_catalog | close_sb | point
| lseg, boxpg_catalog | close_sl | point
| lseg, linepg_catalog | col_description | text
| oid, integerpg_catalog | contjoinsel | double
precision | internal, oid, internal, smallintpg_catalog | contsel |
double
precision | internal, oid, internal, integerpg_catalog | convert |
bytea
| bytea, name, namepg_catalog | convert_from | text
| bytea, namepg_catalog | convert_to | bytea
| text, namepg_catalog | cos | double
precision | double precisionpg_catalog | cot | double
precision | double precisionpg_catalog | current_database | name
| pg_catalog | current_schema | name
| pg_catalog | current_schemas | name[]
| booleanpg_catalog | current_setting | text
| textpg_catalog | current_user | name
| pg_catalog | currtid | tid
| oid, tidpg_catalog | currtid2 | tid
| text, tidpg_catalog | currval | bigint
| regclasspg_catalog | cursor_to_xml | xml
| cursor refcursor, count integer, nulls boolean, tableforest boolean,
targetns textpg_catalog | cursor_to_xmlschema | xml
| cursor refcursor, nulls boolean, tableforest boolean, targetns textpg_catalog | database_to_xml
| xml
| nulls boolean, tableforest boolean, targetns textpg_catalog | database_to_xml_and_xmlschema | xml
| nulls boolean, tableforest boolean, targetns textpg_catalog | database_to_xmlschema | xml
| nulls boolean, tableforest boolean, targetns textpg_catalog | date | date
| abstimepg_catalog | date | date
| timestamp without time zonepg_catalog | date | date
| timestamp with time zonepg_catalog | date_cmp | integer
| date, datepg_catalog | date_cmp_timestamp | integer
| date, timestamp without time zonepg_catalog | date_cmp_timestamptz | integer
| date, timestamp with time zonepg_catalog | date_eq | boolean
| date, datepg_catalog | date_eq_timestamp | boolean
| date, timestamp without time zonepg_catalog | date_eq_timestamptz | boolean
| date, timestamp with time zonepg_catalog | date_ge | boolean
| date, datepg_catalog | date_ge_timestamp | boolean
| date, timestamp without time zonepg_catalog | date_ge_timestamptz | boolean
| date, timestamp with time zonepg_catalog | date_gt | boolean
| date, datepg_catalog | date_gt_timestamp | boolean
| date, timestamp without time zonepg_catalog | date_gt_timestamptz | boolean
| date, timestamp with time zonepg_catalog | date_larger | date
| date, datepg_catalog | date_le | boolean
| date, datepg_catalog | date_le_timestamp | boolean
| date, timestamp without time zonepg_catalog | date_le_timestamptz | boolean
| date, timestamp with time zonepg_catalog | date_lt | boolean
| date, datepg_catalog | date_lt_timestamp | boolean
| date, timestamp without time zonepg_catalog | date_lt_timestamptz | boolean
| date, timestamp with time zonepg_catalog | date_mi | integer
| date, datepg_catalog | date_mi_interval | timestamp
without time zone | date, intervalpg_catalog | date_mii | date
| date, integerpg_catalog | date_ne | boolean
| date, datepg_catalog | date_ne_timestamp | boolean
| date, timestamp without time zonepg_catalog | date_ne_timestamptz | boolean
| date, timestamp with time zonepg_catalog | date_part | double
precision | text, abstimepg_catalog | date_part | double
precision | text, datepg_catalog | date_part | double
precision | text, intervalpg_catalog | date_part | double
precision | text, reltimepg_catalog | date_part | double
precision | text, timestamp without time zonepg_catalog | date_part |
double
precision | text, timestamp with time zonepg_catalog | date_part |
double
precision | text, time without time zonepg_catalog | date_part | double
precision | text, time with time zonepg_catalog | date_pl_interval | timestamp
without time zone | date, intervalpg_catalog | date_pli | date
| date, integerpg_catalog | date_recv | date
| internalpg_catalog | date_send | bytea
| datepg_catalog | date_smaller | date
| date, datepg_catalog | date_trunc | interval
| text, intervalpg_catalog | date_trunc | timestamp
without time zone | text, timestamp without time zonepg_catalog | date_trunc |
timestamp
with time zone | text, timestamp with time zonepg_catalog | datetime_pl |
timestamp
without time zone | date, time without time zonepg_catalog | datetimetz_pl | timestamp
with time zone | date, time with time zonepg_catalog | dcbrt | double
precision | double precisionpg_catalog | decode | bytea
| text, textpg_catalog | degrees | double
precision | double precisionpg_catalog | dexp | double
precision | double precisionpg_catalog | diagonal | lseg
| boxpg_catalog | diameter | double
precision | circlepg_catalog | dispell_init | internal
| internalpg_catalog | dispell_lexize | internal
| internal, internal, internal, internalpg_catalog | dist_cpoly | double
precision | circle, polygonpg_catalog | dist_lb | double
precision | line, boxpg_catalog | dist_pb | double
precision | point, boxpg_catalog | dist_pc | double
precision | point, circlepg_catalog | dist_pl | double
precision | point, linepg_catalog | dist_ppath | double
precision | point, pathpg_catalog | dist_ps | double
precision | point, lsegpg_catalog | dist_sb | double
precision | lseg, boxpg_catalog | dist_sl | double
precision | lseg, linepg_catalog | dlog1 | double
precision | double precisionpg_catalog | dlog10 | double
precision | double precisionpg_catalog | domain_recv | "any"
| internal, oid, integerpg_catalog | dpow | double
precision | double precision, double precisionpg_catalog | dround |
double
precision | double precisionpg_catalog | dsimple_init | internal
| internalpg_catalog | dsimple_lexize | internal
| internal, internal, internal, internalpg_catalog | dsnowball_init | internal
| internalpg_catalog | dsnowball_lexize | internal
| internal, internal, internal, internalpg_catalog | dsqrt | double
precision | double precisionpg_catalog | dsynonym_init | internal
| internalpg_catalog | dsynonym_lexize | internal
| internal, internal, internal, internalpg_catalog | dtrunc | double
precision | double precisionpg_catalog | encode | text
| bytea, textpg_catalog | enum_cmp | integer
| anyenum, anyenumpg_catalog | enum_eq | boolean
| anyenum, anyenumpg_catalog | enum_first | anyenum
| anyenumpg_catalog | enum_ge | boolean
| anyenum, anyenumpg_catalog | enum_gt | boolean
| anyenum, anyenumpg_catalog | enum_larger | anyenum
| anyenum, anyenumpg_catalog | enum_last | anyenum
| anyenumpg_catalog | enum_le | boolean
| anyenum, anyenumpg_catalog | enum_lt | boolean
| anyenum, anyenumpg_catalog | enum_ne | boolean
| anyenum, anyenumpg_catalog | enum_range | anyarray
| anyenumpg_catalog | enum_range | anyarray
| anyenum, anyenumpg_catalog | enum_send | bytea
| anyenumpg_catalog | enum_smaller | anyenum
| anyenum, anyenumpg_catalog | eqjoinsel | double
precision | internal, oid, internal, smallintpg_catalog | eqsel |
double
precision | internal, oid, internal, integerpg_catalog | euc_cn_to_mic |
void
| integer, integer, cstring, internal, integerpg_catalog | euc_cn_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | euc_jis_2004_to_shift_jis_2004 | void
| integer, integer, cstring, internal, integerpg_catalog | euc_jis_2004_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | euc_jp_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | euc_jp_to_sjis | void
| integer, integer, cstring, internal, integerpg_catalog | euc_jp_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | euc_kr_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | euc_kr_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | euc_tw_to_big5 | void
| integer, integer, cstring, internal, integerpg_catalog | euc_tw_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | euc_tw_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | exp | double
precision | double precisionpg_catalog | exp | numeric
| numericpg_catalog | factorial | numeric
| bigintpg_catalog | family | integer
| inetpg_catalog | flatfile_update_trigger | trigger
| pg_catalog | float4 | real
| bigintpg_catalog | float4 | real
| double precisionpg_catalog | float4 | real
| integerpg_catalog | float4 | real
| numericpg_catalog | float4 | real
| smallintpg_catalog | float48div | double
precision | real, double precisionpg_catalog | float48eq | boolean
| real, double precisionpg_catalog | float48ge | boolean
| real, double precisionpg_catalog | float48gt | boolean
| real, double precisionpg_catalog | float48le | boolean
| real, double precisionpg_catalog | float48lt | boolean
| real, double precisionpg_catalog | float48mi | double
precision | real, double precisionpg_catalog | float48mul | double
precision | real, double precisionpg_catalog | float48ne | boolean
| real, double precisionpg_catalog | float48pl | double
precision | real, double precisionpg_catalog | float4_accum | double
precision[] | double precision[], realpg_catalog | float4abs | real
| realpg_catalog | float4div | real
| real, realpg_catalog | float4eq | boolean
| real, realpg_catalog | float4ge | boolean
| real, realpg_catalog | float4gt | boolean
| real, realpg_catalog | float4larger | real
| real, realpg_catalog | float4le | boolean
| real, realpg_catalog | float4lt | boolean
| real, realpg_catalog | float4mi | real
| real, realpg_catalog | float4mul | real
| real, realpg_catalog | float4ne | boolean
| real, realpg_catalog | float4pl | real
| real, realpg_catalog | float4recv | real
| internalpg_catalog | float4send | bytea
| realpg_catalog | float4smaller | real
| real, realpg_catalog | float4um | real
| realpg_catalog | float4up | real
| realpg_catalog | float8 | double
precision | bigintpg_catalog | float8 | double
precision | integerpg_catalog | float8 | double
precision | numericpg_catalog | float8 | double
precision | realpg_catalog | float8 | double
precision | smallintpg_catalog | float84div | double
precision | double precision, realpg_catalog | float84eq | boolean
| double precision, realpg_catalog | float84ge | boolean
| double precision, realpg_catalog | float84gt | boolean
| double precision, realpg_catalog | float84le | boolean
| double precision, realpg_catalog | float84lt | boolean
| double precision, realpg_catalog | float84mi | double
precision | double precision, realpg_catalog | float84mul | double
precision | double precision, realpg_catalog | float84ne | boolean
| double precision, realpg_catalog | float84pl | double
precision | double precision, realpg_catalog | float8_accum | double
precision[] | double precision[], double precisionpg_catalog | float8_avg |
double
precision | double precision[]pg_catalog | float8_corr | double
precision | double precision[]pg_catalog | float8_covar_pop | double
precision | double precision[]pg_catalog | float8_covar_samp | double
precision | double precision[]pg_catalog | float8_regr_accum | double
precision[] | double precision[], double precision, double
precisionpg_catalog | float8_regr_avgx | double
precision | double precision[]pg_catalog | float8_regr_avgy | double
precision | double precision[]pg_catalog | float8_regr_intercept | double
precision | double precision[]pg_catalog | float8_regr_r2 | double
precision | double precision[]pg_catalog | float8_regr_slope | double
precision | double precision[]pg_catalog | float8_regr_sxx | double
precision | double precision[]pg_catalog | float8_regr_sxy | double
precision | double precision[]pg_catalog | float8_regr_syy | double
precision | double precision[]pg_catalog | float8_stddev_pop | double
precision | double precision[]pg_catalog | float8_stddev_samp | double
precision | double precision[]pg_catalog | float8_var_pop | double
precision | double precision[]pg_catalog | float8_var_samp | double
precision | double precision[]pg_catalog | float8abs | double
precision | double precisionpg_catalog | float8div | double
precision | double precision, double precisionpg_catalog | float8eq |
boolean
| double precision, double precisionpg_catalog | float8ge | boolean
| double precision, double precisionpg_catalog | float8gt | boolean
| double precision, double precisionpg_catalog | float8larger | double
precision | double precision, double precisionpg_catalog | float8le |
boolean
| double precision, double precisionpg_catalog | float8lt | boolean
| double precision, double precisionpg_catalog | float8mi | double
precision | double precision, double precisionpg_catalog | float8mul |
double
precision | double precision, double precisionpg_catalog | float8ne |
boolean
| double precision, double precisionpg_catalog | float8pl | double
precision | double precision, double precisionpg_catalog | float8recv |
double
precision | internalpg_catalog | float8send | bytea
| double precisionpg_catalog | float8smaller | double
precision | double precision, double precisionpg_catalog | float8um |
double
precision | double precisionpg_catalog | float8up | double
precision | double precisionpg_catalog | floor | double
precision | double precisionpg_catalog | floor | numeric
| numericpg_catalog | flt4_mul_cash | money
| real, moneypg_catalog | flt8_mul_cash | money
| double precision, moneypg_catalog | fmgr_c_validator | void
| oidpg_catalog | fmgr_internal_validator | void
| oidpg_catalog | fmgr_sql_validator | void
| oidpg_catalog | format_type | text
| oid, integerpg_catalog | gb18030_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | gbk_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | generate_series | setof
bigint | bigint, bigintpg_catalog | generate_series | setof
bigint | bigint, bigint, bigintpg_catalog | generate_series | setof
integer | integer, integerpg_catalog | generate_series | setof
integer | integer, integer, integerpg_catalog | get_bit | integer
| bytea, integerpg_catalog | get_byte | integer
| bytea, integerpg_catalog | get_current_ts_config | regconfig
| pg_catalog | getdatabaseencoding | name
| pg_catalog | getpgusername | name
| pg_catalog | gin_extract_tsquery | internal
| tsquery, internal, smallintpg_catalog | gin_extract_tsvector | internal
| tsvector, internalpg_catalog | gin_tsquery_consistent | boolean
| internal, smallint, tsquerypg_catalog | ginarrayconsistent | boolean
| internal, smallint, internalpg_catalog | ginarrayextract | internal
| anyarray, internalpg_catalog | ginbeginscan | internal
| internal, internal, internalpg_catalog | ginbuild | internal
| internal, internal, internalpg_catalog | ginbulkdelete | internal
| internal, internal, internal, internalpg_catalog | gincostestimate | void
| internal, internal, internal, internal, internal, internal, internal,
internalpg_catalog | ginendscan | void
| internalpg_catalog | gingetmulti | boolean
| internal, internal, internal, internalpg_catalog | gingettuple | boolean
| internal, internalpg_catalog | gininsert | boolean
| internal, internal, internal, internal, internal, internalpg_catalog | ginmarkpos |
void
| internalpg_catalog | ginoptions | bytea
| text[], booleanpg_catalog | ginqueryarrayextract | internal
| anyarray, internal, smallintpg_catalog | ginrescan | void
| internal, internalpg_catalog | ginrestrpos | void
| internalpg_catalog | ginvacuumcleanup | internal
| internal, internalpg_catalog | gist_box_compress | internal
| internalpg_catalog | gist_box_consistent | boolean
| internal, box, integerpg_catalog | gist_box_decompress | internal
| internalpg_catalog | gist_box_penalty | internal
| internal, internal, internalpg_catalog | gist_box_picksplit | internal
| internal, internalpg_catalog | gist_box_same | internal
| box, box, internalpg_catalog | gist_box_union | box
| internal, internalpg_catalog | gist_circle_compress | internal
| internalpg_catalog | gist_circle_consistent | boolean
| internal, circle, integerpg_catalog | gist_poly_compress | internal
| internalpg_catalog | gist_poly_consistent | boolean
| internal, polygon, integerpg_catalog | gistbeginscan | internal
| internal, internal, internalpg_catalog | gistbuild | internal
| internal, internal, internalpg_catalog | gistbulkdelete | internal
| internal, internal, internal, internalpg_catalog | gistcostestimate | void
| internal, internal, internal, internal, internal, internal, internal,
internalpg_catalog | gistendscan | void
| internalpg_catalog | gistgetmulti | boolean
| internal, internal, internal, internalpg_catalog | gistgettuple | boolean
| internal, internalpg_catalog | gistinsert | boolean
| internal, internal, internal, internal, internal, internalpg_catalog | gistmarkpos |
void
| internalpg_catalog | gistoptions | bytea
| text[], booleanpg_catalog | gistrescan | void
| internal, internalpg_catalog | gistrestrpos | void
| internalpg_catalog | gistvacuumcleanup | internal
| internal, internalpg_catalog | gtsquery_compress | internal
| internalpg_catalog | gtsquery_consistent | boolean
| bigint, internal, integerpg_catalog | gtsquery_decompress | internal
| internalpg_catalog | gtsquery_penalty | internal
| internal, internal, internalpg_catalog | gtsquery_picksplit | internal
| internal, internalpg_catalog | gtsquery_same | internal
| bigint, bigint, internalpg_catalog | gtsquery_union | internal
| internal, internalpg_catalog | gtsvector_compress | internal
| internalpg_catalog | gtsvector_consistent | boolean
| gtsvector, internal, integerpg_catalog | gtsvector_decompress | internal
| internalpg_catalog | gtsvector_penalty | internal
| internal, internal, internalpg_catalog | gtsvector_picksplit | internal
| internal, internalpg_catalog | gtsvector_same | internal
| gtsvector, gtsvector, internalpg_catalog | gtsvector_union | internal
| internal, internalpg_catalog | has_database_privilege | boolean
| name, oid, textpg_catalog | has_database_privilege | boolean
| name, text, textpg_catalog | has_database_privilege | boolean
| oid, oid, textpg_catalog | has_database_privilege | boolean
| oid, textpg_catalog | has_database_privilege | boolean
| oid, text, textpg_catalog | has_database_privilege | boolean
| text, textpg_catalog | has_function_privilege | boolean
| name, oid, textpg_catalog | has_function_privilege | boolean
| name, text, textpg_catalog | has_function_privilege | boolean
| oid, oid, textpg_catalog | has_function_privilege | boolean
| oid, textpg_catalog | has_function_privilege | boolean
| oid, text, textpg_catalog | has_function_privilege | boolean
| text, textpg_catalog | has_language_privilege | boolean
| name, oid, textpg_catalog | has_language_privilege | boolean
| name, text, textpg_catalog | has_language_privilege | boolean
| oid, oid, textpg_catalog | has_language_privilege | boolean
| oid, textpg_catalog | has_language_privilege | boolean
| oid, text, textpg_catalog | has_language_privilege | boolean
| text, textpg_catalog | has_schema_privilege | boolean
| name, oid, textpg_catalog | has_schema_privilege | boolean
| name, text, textpg_catalog | has_schema_privilege | boolean
| oid, oid, textpg_catalog | has_schema_privilege | boolean
| oid, textpg_catalog | has_schema_privilege | boolean
| oid, text, textpg_catalog | has_schema_privilege | boolean
| text, textpg_catalog | has_table_privilege | boolean
| name, oid, textpg_catalog | has_table_privilege | boolean
| name, text, textpg_catalog | has_table_privilege | boolean
| oid, oid, textpg_catalog | has_table_privilege | boolean
| oid, textpg_catalog | has_table_privilege | boolean
| oid, text, textpg_catalog | has_table_privilege | boolean
| text, textpg_catalog | has_tablespace_privilege | boolean
| name, oid, textpg_catalog | has_tablespace_privilege | boolean
| name, text, textpg_catalog | has_tablespace_privilege | boolean
| oid, oid, textpg_catalog | has_tablespace_privilege | boolean
| oid, textpg_catalog | has_tablespace_privilege | boolean
| oid, text, textpg_catalog | has_tablespace_privilege | boolean
| text, textpg_catalog | hash_aclitem | integer
| aclitempg_catalog | hash_numeric | integer
| numericpg_catalog | hashbeginscan | internal
| internal, internal, internalpg_catalog | hashbpchar | integer
| characterpg_catalog | hashbuild | internal
| internal, internal, internalpg_catalog | hashbulkdelete | internal
| internal, internal, internal, internalpg_catalog | hashchar | integer
| "char"pg_catalog | hashcostestimate | void
| internal, internal, internal, internal, internal, internal, internal,
internalpg_catalog | hashendscan | void
| internalpg_catalog | hashenum | integer
| anyenumpg_catalog | hashfloat4 | integer
| realpg_catalog | hashfloat8 | integer
| double precisionpg_catalog | hashgetmulti | boolean
| internal, internal, internal, internalpg_catalog | hashgettuple | boolean
| internal, internalpg_catalog | hashinet | integer
| inetpg_catalog | hashinsert | boolean
| internal, internal, internal, internal, internal, internalpg_catalog | hashint2 |
integer
| smallintpg_catalog | hashint2vector | integer
| int2vectorpg_catalog | hashint4 | integer
| integerpg_catalog | hashint8 | integer
| bigintpg_catalog | hashmacaddr | integer
| macaddrpg_catalog | hashmarkpos | void
| internalpg_catalog | hashname | integer
| namepg_catalog | hashoid | integer
| oidpg_catalog | hashoidvector | integer
| oidvectorpg_catalog | hashoptions | bytea
| text[], booleanpg_catalog | hashrescan | void
| internal, internalpg_catalog | hashrestrpos | void
| internalpg_catalog | hashtext | integer
| textpg_catalog | hashvacuumcleanup | internal
| internal, internalpg_catalog | hashvarlena | integer
| internalpg_catalog | height | double
precision | boxpg_catalog | host | text
| inetpg_catalog | hostmask | inet
| inetpg_catalog | iclikejoinsel | double
precision | internal, oid, internal, smallintpg_catalog | iclikesel |
double
precision | internal, oid, internal, integerpg_catalog | icnlikejoinsel |
double
precision | internal, oid, internal, smallintpg_catalog | icnlikesel |
double
precision | internal, oid, internal, integerpg_catalog | icregexeqjoinsel |
double
precision | internal, oid, internal, smallintpg_catalog | icregexeqsel |
double
precision | internal, oid, internal, integerpg_catalog | icregexnejoinsel |
double
precision | internal, oid, internal, smallintpg_catalog | icregexnesel |
double
precision | internal, oid, internal, integerpg_catalog | inet_client_addr |
inet
| pg_catalog | inet_client_port | integer
| pg_catalog | inet_recv | inet
| internalpg_catalog | inet_send | bytea
| inetpg_catalog | inet_server_addr | inet
| pg_catalog | inet_server_port | integer
| pg_catalog | inetand | inet
| inet, inetpg_catalog | inetmi | bigint
| inet, inetpg_catalog | inetmi_int8 | inet
| inet, bigintpg_catalog | inetnot | inet
| inetpg_catalog | inetor | inet
| inet, inetpg_catalog | inetpl | inet
| inet, bigintpg_catalog | initcap | text
| textpg_catalog | int2 | smallint
| bigintpg_catalog | int2 | smallint
| double precisionpg_catalog | int2 | smallint
| integerpg_catalog | int2 | smallint
| numericpg_catalog | int2 | smallint
| realpg_catalog | int24div | integer
| smallint, integerpg_catalog | int24eq | boolean
| smallint, integerpg_catalog | int24ge | boolean
| smallint, integerpg_catalog | int24gt | boolean
| smallint, integerpg_catalog | int24le | boolean
| smallint, integerpg_catalog | int24lt | boolean
| smallint, integerpg_catalog | int24mi | integer
| smallint, integerpg_catalog | int24mod | integer
| smallint, integerpg_catalog | int24mul | integer
| smallint, integerpg_catalog | int24ne | boolean
| smallint, integerpg_catalog | int24pl | integer
| smallint, integerpg_catalog | int28eq | boolean
| smallint, bigintpg_catalog | int28ge | boolean
| smallint, bigintpg_catalog | int28gt | boolean
| smallint, bigintpg_catalog | int28le | boolean
| smallint, bigintpg_catalog | int28lt | boolean
| smallint, bigintpg_catalog | int28ne | boolean
| smallint, bigintpg_catalog | int2_accum | numeric[]
| numeric[], smallintpg_catalog | int2_avg_accum | bigint[]
| bigint[], smallintpg_catalog | int2_mul_cash | money
| smallint, moneypg_catalog | int2_sum | bigint
| bigint, smallintpg_catalog | int2abs | smallint
| smallintpg_catalog | int2and | smallint
| smallint, smallintpg_catalog | int2div | smallint
| smallint, smallintpg_catalog | int2eq | boolean
| smallint, smallintpg_catalog | int2ge | boolean
| smallint, smallintpg_catalog | int2gt | boolean
| smallint, smallintpg_catalog | int2larger | smallint
| smallint, smallintpg_catalog | int2le | boolean
| smallint, smallintpg_catalog | int2lt | boolean
| smallint, smallintpg_catalog | int2mi | smallint
| smallint, smallintpg_catalog | int2mod | smallint
| smallint, smallintpg_catalog | int2mul | smallint
| smallint, smallintpg_catalog | int2ne | boolean
| smallint, smallintpg_catalog | int2not | smallint
| smallintpg_catalog | int2or | smallint
| smallint, smallintpg_catalog | int2pl | smallint
| smallint, smallintpg_catalog | int2recv | smallint
| internalpg_catalog | int2send | bytea
| smallintpg_catalog | int2shl | smallint
| smallint, integerpg_catalog | int2shr | smallint
| smallint, integerpg_catalog | int2smaller | smallint
| smallint, smallintpg_catalog | int2um | smallint
| smallintpg_catalog | int2up | smallint
| smallintpg_catalog | int2vectoreq | boolean
| int2vector, int2vectorpg_catalog | int2vectorrecv | int2vector
| internalpg_catalog | int2vectorsend | bytea
| int2vectorpg_catalog | int2xor | smallint
| smallint, smallintpg_catalog | int4 | integer
| bigintpg_catalog | int4 | integer
| bitpg_catalog | int4 | integer
| booleanpg_catalog | int4 | integer
| "char"pg_catalog | int4 | integer
| double precisionpg_catalog | int4 | integer
| numericpg_catalog | int4 | integer
| realpg_catalog | int4 | integer
| smallintpg_catalog | int42div | integer
| integer, smallintpg_catalog | int42eq | boolean
| integer, smallintpg_catalog | int42ge | boolean
| integer, smallintpg_catalog | int42gt | boolean
| integer, smallintpg_catalog | int42le | boolean
| integer, smallintpg_catalog | int42lt | boolean
| integer, smallintpg_catalog | int42mi | integer
| integer, smallintpg_catalog | int42mod | integer
| integer, smallintpg_catalog | int42mul | integer
| integer, smallintpg_catalog | int42ne | boolean
| integer, smallintpg_catalog | int42pl | integer
| integer, smallintpg_catalog | int48div | bigint
| integer, bigintpg_catalog | int48eq | boolean
| integer, bigintpg_catalog | int48ge | boolean
| integer, bigintpg_catalog | int48gt | boolean
| integer, bigintpg_catalog | int48le | boolean
| integer, bigintpg_catalog | int48lt | boolean
| integer, bigintpg_catalog | int48mi | bigint
| integer, bigintpg_catalog | int48mul | bigint
| integer, bigintpg_catalog | int48ne | boolean
| integer, bigintpg_catalog | int48pl | bigint
| integer, bigintpg_catalog | int4_accum | numeric[]
| numeric[], integerpg_catalog | int4_avg_accum | bigint[]
| bigint[], integerpg_catalog | int4_mul_cash | money
| integer, moneypg_catalog | int4_sum | bigint
| bigint, integerpg_catalog | int4abs | integer
| integerpg_catalog | int4and | integer
| integer, integerpg_catalog | int4div | integer
| integer, integerpg_catalog | int4eq | boolean
| integer, integerpg_catalog | int4ge | boolean
| integer, integerpg_catalog | int4gt | boolean
| integer, integerpg_catalog | int4inc | integer
| integerpg_catalog | int4larger | integer
| integer, integerpg_catalog | int4le | boolean
| integer, integerpg_catalog | int4lt | boolean
| integer, integerpg_catalog | int4mi | integer
| integer, integerpg_catalog | int4mod | integer
| integer, integerpg_catalog | int4mul | integer
| integer, integerpg_catalog | int4ne | boolean
| integer, integerpg_catalog | int4not | integer
| integerpg_catalog | int4or | integer
| integer, integerpg_catalog | int4pl | integer
| integer, integerpg_catalog | int4recv | integer
| internalpg_catalog | int4send | bytea
| integerpg_catalog | int4shl | integer
| integer, integerpg_catalog | int4shr | integer
| integer, integerpg_catalog | int4smaller | integer
| integer, integerpg_catalog | int4um | integer
| integerpg_catalog | int4up | integer
| integerpg_catalog | int4xor | integer
| integer, integerpg_catalog | int8 | bigint
| bitpg_catalog | int8 | bigint
| double precisionpg_catalog | int8 | bigint
| integerpg_catalog | int8 | bigint
| numericpg_catalog | int8 | bigint
| oidpg_catalog | int8 | bigint
| realpg_catalog | int8 | bigint
| smallintpg_catalog | int82eq | boolean
| bigint, smallintpg_catalog | int82ge | boolean
| bigint, smallintpg_catalog | int82gt | boolean
| bigint, smallintpg_catalog | int82le | boolean
| bigint, smallintpg_catalog | int82lt | boolean
| bigint, smallintpg_catalog | int82ne | boolean
| bigint, smallintpg_catalog | int84div | bigint
| bigint, integerpg_catalog | int84eq | boolean
| bigint, integerpg_catalog | int84ge | boolean
| bigint, integerpg_catalog | int84gt | boolean
| bigint, integerpg_catalog | int84le | boolean
| bigint, integerpg_catalog | int84lt | boolean
| bigint, integerpg_catalog | int84mi | bigint
| bigint, integerpg_catalog | int84mul | bigint
| bigint, integerpg_catalog | int84ne | boolean
| bigint, integerpg_catalog | int84pl | bigint
| bigint, integerpg_catalog | int8_accum | numeric[]
| numeric[], bigintpg_catalog | int8_avg | numeric
| bigint[]pg_catalog | int8_avg_accum | numeric[]
| numeric[], bigintpg_catalog | int8_sum | numeric
| numeric, bigintpg_catalog | int8abs | bigint
| bigintpg_catalog | int8and | bigint
| bigint, bigintpg_catalog | int8div | bigint
| bigint, bigintpg_catalog | int8eq | boolean
| bigint, bigintpg_catalog | int8ge | boolean
| bigint, bigintpg_catalog | int8gt | boolean
| bigint, bigintpg_catalog | int8inc | bigint
| bigintpg_catalog | int8inc_any | bigint
| bigint, "any"pg_catalog | int8inc_float8_float8 | bigint
| bigint, double precision, double precisionpg_catalog | int8larger | bigint
| bigint, bigintpg_catalog | int8le | boolean
| bigint, bigintpg_catalog | int8lt | boolean
| bigint, bigintpg_catalog | int8mi | bigint
| bigint, bigintpg_catalog | int8mod | bigint
| bigint, bigintpg_catalog | int8mul | bigint
| bigint, bigintpg_catalog | int8ne | boolean
| bigint, bigintpg_catalog | int8not | bigint
| bigintpg_catalog | int8or | bigint
| bigint, bigintpg_catalog | int8pl | bigint
| bigint, bigintpg_catalog | int8pl_inet | inet
| bigint, inetpg_catalog | int8recv | bigint
| internalpg_catalog | int8send | bytea
| bigintpg_catalog | int8shl | bigint
| bigint, integerpg_catalog | int8shr | bigint
| bigint, integerpg_catalog | int8smaller | bigint
| bigint, bigintpg_catalog | int8um | bigint
| bigintpg_catalog | int8up | bigint
| bigintpg_catalog | int8xor | bigint
| bigint, bigintpg_catalog | integer_pl_date | date
| integer, datepg_catalog | inter_lb | boolean
| line, boxpg_catalog | inter_sb | boolean
| lseg, boxpg_catalog | inter_sl | boolean
| lseg, linepg_catalog | interval | interval
| interval, integerpg_catalog | interval | interval
| reltimepg_catalog | interval | interval
| time without time zonepg_catalog | interval_accum | interval[]
| interval[], intervalpg_catalog | interval_avg | interval
| interval[]pg_catalog | interval_cmp | integer
| interval, intervalpg_catalog | interval_div | interval
| interval, double precisionpg_catalog | interval_eq | boolean
| interval, intervalpg_catalog | interval_ge | boolean
| interval, intervalpg_catalog | interval_gt | boolean
| interval, intervalpg_catalog | interval_hash | integer
| intervalpg_catalog | interval_larger | interval
| interval, intervalpg_catalog | interval_le | boolean
| interval, intervalpg_catalog | interval_lt | boolean
| interval, intervalpg_catalog | interval_mi | interval
| interval, intervalpg_catalog | interval_mul | interval
| interval, double precisionpg_catalog | interval_ne | boolean
| interval, intervalpg_catalog | interval_pl | interval
| interval, intervalpg_catalog | interval_pl_date | timestamp
without time zone | interval, datepg_catalog | interval_pl_time | time
without time zone | interval, time without time zonepg_catalog | interval_pl_timestamp |
timestamp
without time zone | interval, timestamp without time zonepg_catalog | interval_pl_timestamptz |
timestamp
with time zone | interval, timestamp with time zonepg_catalog | interval_pl_timetz | time
with
time zone | interval, time with time zonepg_catalog | interval_recv | interval
| internal, oid, integerpg_catalog | interval_send | bytea
| intervalpg_catalog | interval_smaller | interval
| interval, intervalpg_catalog | interval_um | interval
| intervalpg_catalog | intervaltypmodin | integer
| cstring[]pg_catalog | intinterval | boolean
| abstime, tintervalpg_catalog | isclosed | boolean
| pathpg_catalog | isfalse | boolean
| booleanpg_catalog | isfinite | boolean
| abstimepg_catalog | isfinite | boolean
| intervalpg_catalog | isfinite | boolean
| timestamp without time zonepg_catalog | isfinite | boolean
| timestamp with time zonepg_catalog | ishorizontal | boolean
| linepg_catalog | ishorizontal | boolean
| lsegpg_catalog | ishorizontal | boolean
| point, pointpg_catalog | isnotfalse | boolean
| booleanpg_catalog | isnottrue | boolean
| booleanpg_catalog | iso8859_1_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | iso8859_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | iso_to_koi8r | void
| integer, integer, cstring, internal, integerpg_catalog | iso_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | iso_to_win1251 | void
| integer, integer, cstring, internal, integerpg_catalog | iso_to_win866 | void
| integer, integer, cstring, internal, integerpg_catalog | isopen | boolean
| pathpg_catalog | isparallel | boolean
| line, linepg_catalog | isparallel | boolean
| lseg, lsegpg_catalog | isperp | boolean
| line, linepg_catalog | isperp | boolean
| lseg, lsegpg_catalog | istrue | boolean
| booleanpg_catalog | isvertical | boolean
| linepg_catalog | isvertical | boolean
| lsegpg_catalog | isvertical | boolean
| point, pointpg_catalog | johab_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | justify_days | interval
| intervalpg_catalog | justify_hours | interval
| intervalpg_catalog | justify_interval | interval
| intervalpg_catalog | koi8r_to_iso | void
| integer, integer, cstring, internal, integerpg_catalog | koi8r_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | koi8r_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | koi8r_to_win1251 | void
| integer, integer, cstring, internal, integerpg_catalog | koi8r_to_win866 | void
| integer, integer, cstring, internal, integerpg_catalog | lastval | bigint
| pg_catalog | latin1_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | latin2_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | latin2_to_win1250 | void
| integer, integer, cstring, internal, integerpg_catalog | latin3_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | latin4_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | length | double
precision | lsegpg_catalog | length | double
precision | pathpg_catalog | length | integer
| bitpg_catalog | length | integer
| byteapg_catalog | length | integer
| bytea, namepg_catalog | length | integer
| characterpg_catalog | length | integer
| textpg_catalog | length | integer
| tsvectorpg_catalog | like | boolean
| bytea, byteapg_catalog | like | boolean
| name, textpg_catalog | like | boolean
| text, textpg_catalog | like_escape | bytea
| bytea, byteapg_catalog | like_escape | text
| text, textpg_catalog | likejoinsel | double
precision | internal, oid, internal, smallintpg_catalog | likesel |
double
precision | internal, oid, internal, integerpg_catalog | line |
line
| point, pointpg_catalog | line_distance | double
precision | line, linepg_catalog | line_eq | boolean
| line, linepg_catalog | line_horizontal | boolean
| linepg_catalog | line_interpt | point
| line, linepg_catalog | line_intersect | boolean
| line, linepg_catalog | line_parallel | boolean
| line, linepg_catalog | line_perp | boolean
| line, linepg_catalog | line_recv | line
| internalpg_catalog | line_send | bytea
| linepg_catalog | line_vertical | boolean
| linepg_catalog | ln | double
precision | double precisionpg_catalog | ln | numeric
| numericpg_catalog | lo_close | integer
| integerpg_catalog | lo_creat | oid
| integerpg_catalog | lo_create | oid
| oidpg_catalog | lo_export | integer
| oid, textpg_catalog | lo_import | oid
| textpg_catalog | lo_lseek | integer
| integer, integer, integerpg_catalog | lo_open | integer
| oid, integerpg_catalog | lo_tell | integer
| integerpg_catalog | lo_truncate | integer
| integer, integerpg_catalog | lo_unlink | integer
| oidpg_catalog | log | double
precision | double precisionpg_catalog | log | numeric
| numericpg_catalog | log | numeric
| numeric, numericpg_catalog | loread | bytea
| integer, integerpg_catalog | lower | text
| textpg_catalog | lowrite | integer
| integer, byteapg_catalog | lpad | text
| text, integerpg_catalog | lpad | text
| text, integer, textpg_catalog | lseg | lseg
| boxpg_catalog | lseg | lseg
| point, pointpg_catalog | lseg_center | point
| lsegpg_catalog | lseg_distance | double
precision | lseg, lsegpg_catalog | lseg_eq | boolean
| lseg, lsegpg_catalog | lseg_ge | boolean
| lseg, lsegpg_catalog | lseg_gt | boolean
| lseg, lsegpg_catalog | lseg_horizontal | boolean
| lsegpg_catalog | lseg_interpt | point
| lseg, lsegpg_catalog | lseg_intersect | boolean
| lseg, lsegpg_catalog | lseg_le | boolean
| lseg, lsegpg_catalog | lseg_length | double
precision | lsegpg_catalog | lseg_lt | boolean
| lseg, lsegpg_catalog | lseg_ne | boolean
| lseg, lsegpg_catalog | lseg_parallel | boolean
| lseg, lsegpg_catalog | lseg_perp | boolean
| lseg, lsegpg_catalog | lseg_recv | lseg
| internalpg_catalog | lseg_send | bytea
| lsegpg_catalog | lseg_vertical | boolean
| lsegpg_catalog | ltrim | text
| textpg_catalog | ltrim | text
| text, textpg_catalog | macaddr_cmp | integer
| macaddr, macaddrpg_catalog | macaddr_eq | boolean
| macaddr, macaddrpg_catalog | macaddr_ge | boolean
| macaddr, macaddrpg_catalog | macaddr_gt | boolean
| macaddr, macaddrpg_catalog | macaddr_le | boolean
| macaddr, macaddrpg_catalog | macaddr_lt | boolean
| macaddr, macaddrpg_catalog | macaddr_ne | boolean
| macaddr, macaddrpg_catalog | macaddr_recv | macaddr
| internalpg_catalog | macaddr_send | bytea
| macaddrpg_catalog | makeaclitem | aclitem
| oid, oid, text, booleanpg_catalog | masklen | integer
| inetpg_catalog | md5 | text
| byteapg_catalog | md5 | text
| textpg_catalog | mic_to_ascii | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_big5 | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_euc_cn | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_euc_jp | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_euc_kr | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_euc_tw | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_iso | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_koi8r | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_latin1 | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_latin2 | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_latin3 | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_latin4 | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_sjis | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_win1250 | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_win1251 | void
| integer, integer, cstring, internal, integerpg_catalog | mic_to_win866 | void
| integer, integer, cstring, internal, integerpg_catalog | mktinterval | tinterval
| abstime, abstimepg_catalog | mod | bigint
| bigint, bigintpg_catalog | mod | integer
| integer, integerpg_catalog | mod | integer
| integer, smallintpg_catalog | mod | integer
| smallint, integerpg_catalog | mod | numeric
| numeric, numericpg_catalog | mod | smallint
| smallint, smallintpg_catalog | mul_d_interval | interval
| double precision, intervalpg_catalog | name | name
| characterpg_catalog | name | name
| character varyingpg_catalog | name | name
| textpg_catalog | name_pattern_eq | boolean
| name, namepg_catalog | name_pattern_ge | boolean
| name, namepg_catalog | name_pattern_gt | boolean
| name, namepg_catalog | name_pattern_le | boolean
| name, namepg_catalog | name_pattern_lt | boolean
| name, namepg_catalog | name_pattern_ne | boolean
| name, namepg_catalog | nameeq | boolean
| name, namepg_catalog | namege | boolean
| name, namepg_catalog | namegt | boolean
| name, namepg_catalog | nameiclike | boolean
| name, textpg_catalog | nameicnlike | boolean
| name, textpg_catalog | nameicregexeq | boolean
| name, textpg_catalog | nameicregexne | boolean
| name, textpg_catalog | namele | boolean
| name, namepg_catalog | namelike | boolean
| name, textpg_catalog | namelt | boolean
| name, namepg_catalog | namene | boolean
| name, namepg_catalog | namenlike | boolean
| name, textpg_catalog | namerecv | name
| internalpg_catalog | nameregexeq | boolean
| name, textpg_catalog | nameregexne | boolean
| name, textpg_catalog | namesend | bytea
| namepg_catalog | neqjoinsel | double
precision | internal, oid, internal, smallintpg_catalog | neqsel |
double
precision | internal, oid, internal, integerpg_catalog | netmask |
inet
| inetpg_catalog | network | cidr
| inetpg_catalog | network_cmp | integer
| inet, inetpg_catalog | network_eq | boolean
| inet, inetpg_catalog | network_ge | boolean
| inet, inetpg_catalog | network_gt | boolean
| inet, inetpg_catalog | network_le | boolean
| inet, inetpg_catalog | network_lt | boolean
| inet, inetpg_catalog | network_ne | boolean
| inet, inetpg_catalog | network_sub | boolean
| inet, inetpg_catalog | network_subeq | boolean
| inet, inetpg_catalog | network_sup | boolean
| inet, inetpg_catalog | network_supeq | boolean
| inet, inetpg_catalog | nextval | bigint
| regclasspg_catalog | nlikejoinsel | double
precision | internal, oid, internal, smallintpg_catalog | nlikesel |
double
precision | internal, oid, internal, integerpg_catalog | nonnullvalue |
boolean
| "any"pg_catalog | notlike | boolean
| bytea, byteapg_catalog | notlike | boolean
| name, textpg_catalog | notlike | boolean
| text, textpg_catalog | now | timestamp
with time zone | pg_catalog | npoints | integer
| pathpg_catalog | npoints | integer
| polygonpg_catalog | nullvalue | boolean
| "any"pg_catalog | numeric | numeric
| bigintpg_catalog | numeric | numeric
| double precisionpg_catalog | numeric | numeric
| integerpg_catalog | numeric | numeric
| numeric, integerpg_catalog | numeric | numeric
| realpg_catalog | numeric | numeric
| smallintpg_catalog | numeric_abs | numeric
| numericpg_catalog | numeric_accum | numeric[]
| numeric[], numericpg_catalog | numeric_add | numeric
| numeric, numericpg_catalog | numeric_avg | numeric
| numeric[]pg_catalog | numeric_avg_accum | numeric[]
| numeric[], numericpg_catalog | numeric_cmp | integer
| numeric, numericpg_catalog | numeric_div | numeric
| numeric, numericpg_catalog | numeric_eq | boolean
| numeric, numericpg_catalog | numeric_exp | numeric
| numericpg_catalog | numeric_fac | numeric
| bigintpg_catalog | numeric_ge | boolean
| numeric, numericpg_catalog | numeric_gt | boolean
| numeric, numericpg_catalog | numeric_inc | numeric
| numericpg_catalog | numeric_larger | numeric
| numeric, numericpg_catalog | numeric_le | boolean
| numeric, numericpg_catalog | numeric_ln | numeric
| numericpg_catalog | numeric_log | numeric
| numeric, numericpg_catalog | numeric_lt | boolean
| numeric, numericpg_catalog | numeric_mod | numeric
| numeric, numericpg_catalog | numeric_mul | numeric
| numeric, numericpg_catalog | numeric_ne | boolean
| numeric, numericpg_catalog | numeric_power | numeric
| numeric, numericpg_catalog | numeric_recv | numeric
| internal, oid, integerpg_catalog | numeric_send | bytea
| numericpg_catalog | numeric_smaller | numeric
| numeric, numericpg_catalog | numeric_sqrt | numeric
| numericpg_catalog | numeric_stddev_pop | numeric
| numeric[]pg_catalog | numeric_stddev_samp | numeric
| numeric[]pg_catalog | numeric_sub | numeric
| numeric, numericpg_catalog | numeric_uminus | numeric
| numericpg_catalog | numeric_uplus | numeric
| numericpg_catalog | numeric_var_pop | numeric
| numeric[]pg_catalog | numeric_var_samp | numeric
| numeric[]pg_catalog | numerictypmodin | integer
| cstring[]pg_catalog | numnode | integer
| tsquerypg_catalog | obj_description | text
| oidpg_catalog | obj_description | text
| oid, namepg_catalog | octet_length | integer
| bitpg_catalog | octet_length | integer
| byteapg_catalog | octet_length | integer
| characterpg_catalog | octet_length | integer
| textpg_catalog | oid | oid
| bigintpg_catalog | oideq | boolean
| oid, oidpg_catalog | oidge | boolean
| oid, oidpg_catalog | oidgt | boolean
| oid, oidpg_catalog | oidlarger | oid
| oid, oidpg_catalog | oidle | boolean
| oid, oidpg_catalog | oidlt | boolean
| oid, oidpg_catalog | oidne | boolean
| oid, oidpg_catalog | oidrecv | oid
| internalpg_catalog | oidsend | bytea
| oidpg_catalog | oidsmaller | oid
| oid, oidpg_catalog | oidvectoreq | boolean
| oidvector, oidvectorpg_catalog | oidvectorge | boolean
| oidvector, oidvectorpg_catalog | oidvectorgt | boolean
| oidvector, oidvectorpg_catalog | oidvectorle | boolean
| oidvector, oidvectorpg_catalog | oidvectorlt | boolean
| oidvector, oidvectorpg_catalog | oidvectorne | boolean
| oidvector, oidvectorpg_catalog | oidvectorrecv | oidvector
| internalpg_catalog | oidvectorsend | bytea
| oidvectorpg_catalog | oidvectortypes | text
| oidvectorpg_catalog | on_pb | boolean
| point, boxpg_catalog | on_pl | boolean
| point, linepg_catalog | on_ppath | boolean
| point, pathpg_catalog | on_ps | boolean
| point, lsegpg_catalog | on_sb | boolean
| lseg, boxpg_catalog | on_sl | boolean
| lseg, linepg_catalog | overlaps | boolean
| timestamp without time zone, interval, timestamp without time zone,
intervalpg_catalog | overlaps | boolean
| timestamp without time zone, interval, timestamp without time zone,
timestamp without time zonepg_catalog | overlaps | boolean
| timestamp without time zone, timestamp without time zone, timestamp
without time zone, intervalpg_catalog | overlaps | boolean
| timestamp without time zone, timestamp without time zone, timestamp
without time zone, timestamp without time zonepg_catalog | overlaps | boolean
| timestamp with time zone, interval, timestamp with time zone, intervalpg_catalog | overlaps
| boolean
| timestamp with time zone, interval, timestamp with time zone,
timestamp with time zonepg_catalog | overlaps | boolean
| timestamp with time zone, timestamp with time zone, timestamp with
time zone, intervalpg_catalog | overlaps | boolean
| timestamp with time zone, timestamp with time zone, timestamp with
time zone, timestamp with time zonepg_catalog | overlaps | boolean
| time without time zone, interval, time without time zone, intervalpg_catalog | overlaps
| boolean
| time without time zone, interval, time without time zone, time without
time zonepg_catalog | overlaps | boolean
| time without time zone, time without time zone, time without time
zone, intervalpg_catalog | overlaps | boolean
| time without time zone, time without time zone, time without time
zone, time without time zonepg_catalog | overlaps | boolean
| time with time zone, time with time zone, time with time zone, time
with time zonepg_catalog | overlay | text
| text, text, integerpg_catalog | overlay | text
| text, text, integer, integerpg_catalog | path | path
| polygonpg_catalog | path_add | path
| path, pathpg_catalog | path_add_pt | path
| path, pointpg_catalog | path_center | point
| pathpg_catalog | path_contain_pt | boolean
| path, pointpg_catalog | path_distance | double
precision | path, pathpg_catalog | path_div_pt | path
| path, pointpg_catalog | path_inter | boolean
| path, pathpg_catalog | path_length | double
precision | pathpg_catalog | path_mul_pt | path
| path, pointpg_catalog | path_n_eq | boolean
| path, pathpg_catalog | path_n_ge | boolean
| path, pathpg_catalog | path_n_gt | boolean
| path, pathpg_catalog | path_n_le | boolean
| path, pathpg_catalog | path_n_lt | boolean
| path, pathpg_catalog | path_npoints | integer
| pathpg_catalog | path_recv | path
| internalpg_catalog | path_send | bytea
| pathpg_catalog | path_sub_pt | path
| path, pointpg_catalog | pclose | path
| pathpg_catalog | pg_advisory_lock | void
| bigintpg_catalog | pg_advisory_lock | void
| integer, integerpg_catalog | pg_advisory_lock_shared | void
| bigintpg_catalog | pg_advisory_lock_shared | void
| integer, integerpg_catalog | pg_advisory_unlock | boolean
| bigintpg_catalog | pg_advisory_unlock | boolean
| integer, integerpg_catalog | pg_advisory_unlock_all | void
| pg_catalog | pg_advisory_unlock_shared | boolean
| bigintpg_catalog | pg_advisory_unlock_shared | boolean
| integer, integerpg_catalog | pg_backend_pid | integer
| pg_catalog | pg_cancel_backend | boolean
| integerpg_catalog | pg_char_to_encoding | integer
| namepg_catalog | pg_client_encoding | name
| pg_catalog | pg_column_size | integer
| "any"pg_catalog | pg_conversion_is_visible | boolean
| oidpg_catalog | pg_current_xlog_insert_location | text
| pg_catalog | pg_current_xlog_location | text
| pg_catalog | pg_cursor | setof
record | pg_catalog | pg_database_size | bigint
| namepg_catalog | pg_database_size | bigint
| oidpg_catalog | pg_encoding_to_char | name
| integerpg_catalog | pg_function_is_visible | boolean
| oidpg_catalog | pg_get_constraintdef | text
| oidpg_catalog | pg_get_constraintdef | text
| oid, booleanpg_catalog | pg_get_expr | text
| text, oidpg_catalog | pg_get_expr | text
| text, oid, booleanpg_catalog | pg_get_indexdef | text
| oidpg_catalog | pg_get_indexdef | text
| oid, integer, booleanpg_catalog | pg_get_ruledef | text
| oidpg_catalog | pg_get_ruledef | text
| oid, booleanpg_catalog | pg_get_serial_sequence | text
| text, textpg_catalog | pg_get_triggerdef | text
| oidpg_catalog | pg_get_userbyid | name
| oidpg_catalog | pg_get_viewdef | text
| oidpg_catalog | pg_get_viewdef | text
| oid, booleanpg_catalog | pg_get_viewdef | text
| textpg_catalog | pg_get_viewdef | text
| text, booleanpg_catalog | pg_has_role | boolean
| name, name, textpg_catalog | pg_has_role | boolean
| name, oid, textpg_catalog | pg_has_role | boolean
| name, textpg_catalog | pg_has_role | boolean
| oid, name, textpg_catalog | pg_has_role | boolean
| oid, oid, textpg_catalog | pg_has_role | boolean
| oid, textpg_catalog | pg_is_other_temp_schema | boolean
| oidpg_catalog | pg_lock_status | setof
record | pg_catalog | pg_ls_dir | setof text
| textpg_catalog | pg_my_temp_schema | oid
| pg_catalog | pg_opclass_is_visible | boolean
| oidpg_catalog | pg_operator_is_visible | boolean
| oidpg_catalog | pg_postmaster_start_time | timestamp
with time zone | pg_catalog | pg_prepared_statement | setof
record | pg_catalog | pg_prepared_xact | setof
record | pg_catalog | pg_read_file | text
| text, bigint, bigintpg_catalog | pg_relation_size | bigint
| oidpg_catalog | pg_relation_size | bigint
| textpg_catalog | pg_reload_conf | boolean
| pg_catalog | pg_rotate_logfile | boolean
| pg_catalog | pg_show_all_settings | setof
record | pg_catalog | pg_size_pretty | text
| bigintpg_catalog | pg_sleep | void
| double precisionpg_catalog | pg_start_backup | text
| textpg_catalog | pg_stat_clear_snapshot | void
| pg_catalog | pg_stat_file | record
| filename text, OUT size bigint, OUT access timestamp with time zone,
OUT modification timestamp with time zone, OUT change timestamp with
time zone, OUT creation timestamp with time zone, OUT isdir booleanpg_catalog | pg_stat_get_backend_activity
| text
| integerpg_catalog | pg_stat_get_backend_activity_start | timestamp
with time zone | integerpg_catalog | pg_stat_get_backend_client_addr | inet
| integerpg_catalog | pg_stat_get_backend_client_port | integer
| integerpg_catalog | pg_stat_get_backend_dbid | oid
| integerpg_catalog | pg_stat_get_backend_idset | setof
integer | pg_catalog | pg_stat_get_backend_pid | integer
| integerpg_catalog | pg_stat_get_backend_start | timestamp
with time zone | integerpg_catalog | pg_stat_get_backend_userid | oid
| integerpg_catalog | pg_stat_get_backend_waiting | boolean
| integerpg_catalog | pg_stat_get_backend_xact_start | timestamp
with time zone | integerpg_catalog | pg_stat_get_bgwriter_buf_written_checkpoints | bigint
| pg_catalog | pg_stat_get_bgwriter_buf_written_clean | bigint
| pg_catalog | pg_stat_get_bgwriter_maxwritten_clean | bigint
| pg_catalog | pg_stat_get_bgwriter_requested_checkpoints | bigint
| pg_catalog | pg_stat_get_bgwriter_timed_checkpoints | bigint
| pg_catalog | pg_stat_get_blocks_fetched | bigint
| oidpg_catalog | pg_stat_get_blocks_hit | bigint
| oidpg_catalog | pg_stat_get_buf_alloc | bigint
| pg_catalog | pg_stat_get_buf_written_backend | bigint
| pg_catalog | pg_stat_get_db_blocks_fetched | bigint
| oidpg_catalog | pg_stat_get_db_blocks_hit | bigint
| oidpg_catalog | pg_stat_get_db_numbackends | integer
| oidpg_catalog | pg_stat_get_db_tuples_deleted | bigint
| oidpg_catalog | pg_stat_get_db_tuples_fetched | bigint
| oidpg_catalog | pg_stat_get_db_tuples_inserted | bigint
| oidpg_catalog | pg_stat_get_db_tuples_returned | bigint
| oidpg_catalog | pg_stat_get_db_tuples_updated | bigint
| oidpg_catalog | pg_stat_get_db_xact_commit | bigint
| oidpg_catalog | pg_stat_get_db_xact_rollback | bigint
| oidpg_catalog | pg_stat_get_dead_tuples | bigint
| oidpg_catalog | pg_stat_get_last_analyze_time | timestamp
with time zone | oidpg_catalog | pg_stat_get_last_autoanalyze_time | timestamp
with time zone | oidpg_catalog | pg_stat_get_last_autovacuum_time | timestamp
with time zone | oidpg_catalog | pg_stat_get_last_vacuum_time | timestamp
with time zone | oidpg_catalog | pg_stat_get_live_tuples | bigint
| oidpg_catalog | pg_stat_get_numscans | bigint
| oidpg_catalog | pg_stat_get_tuples_deleted | bigint
| oidpg_catalog | pg_stat_get_tuples_fetched | bigint
| oidpg_catalog | pg_stat_get_tuples_hot_updated | bigint
| oidpg_catalog | pg_stat_get_tuples_inserted | bigint
| oidpg_catalog | pg_stat_get_tuples_returned | bigint
| oidpg_catalog | pg_stat_get_tuples_updated | bigint
| oidpg_catalog | pg_stat_reset | void
| pg_catalog | pg_stop_backup | text
| pg_catalog | pg_switch_xlog | text
| pg_catalog | pg_table_is_visible | boolean
| oidpg_catalog | pg_tablespace_databases | setof oid
| oidpg_catalog | pg_tablespace_size | bigint
| namepg_catalog | pg_tablespace_size | bigint
| oidpg_catalog | pg_timezone_abbrevs | setof
record | OUT abbrev text, OUT utc_offset interval, OUT
is_dst booleanpg_catalog | pg_timezone_names | setof
record | OUT name text, OUT abbrev text, OUT utc_offset
interval, OUT is_dst booleanpg_catalog | pg_total_relation_size | bigint
| oidpg_catalog | pg_total_relation_size | bigint
| textpg_catalog | pg_try_advisory_lock | boolean
| bigintpg_catalog | pg_try_advisory_lock | boolean
| integer, integerpg_catalog | pg_try_advisory_lock_shared | boolean
| bigintpg_catalog | pg_try_advisory_lock_shared | boolean
| integer, integerpg_catalog | pg_ts_config_is_visible | boolean
| oidpg_catalog | pg_ts_dict_is_visible | boolean
| oidpg_catalog | pg_ts_parser_is_visible | boolean
| oidpg_catalog | pg_ts_template_is_visible | boolean
| oidpg_catalog | pg_type_is_visible | boolean
| oidpg_catalog | pg_xlogfile_name | text
| textpg_catalog | pg_xlogfile_name_offset | record
| wal_location text, OUT file_name text, OUT file_offset integerpg_catalog | pi
| double
precision | pg_catalog | plainto_tsquery | tsquery
| regconfig, textpg_catalog | plainto_tsquery | tsquery
| textpg_catalog | plpgsql_call_handler |
language_handler | pg_catalog | plpgsql_validator | void
| oidpg_catalog | point | point
| boxpg_catalog | point | point
| circlepg_catalog | point | point
| double precision, double precisionpg_catalog | point | point
| lsegpg_catalog | point | point
| pathpg_catalog | point | point
| polygonpg_catalog | point_above | boolean
| point, pointpg_catalog | point_add | point
| point, pointpg_catalog | point_below | boolean
| point, pointpg_catalog | point_distance | double
precision | point, pointpg_catalog | point_div | point
| point, pointpg_catalog | point_eq | boolean
| point, pointpg_catalog | point_horiz | boolean
| point, pointpg_catalog | point_left | boolean
| point, pointpg_catalog | point_mul | point
| point, pointpg_catalog | point_ne | boolean
| point, pointpg_catalog | point_recv | point
| internalpg_catalog | point_right | boolean
| point, pointpg_catalog | point_send | bytea
| pointpg_catalog | point_sub | point
| point, pointpg_catalog | point_vert | boolean
| point, pointpg_catalog | poly_above | boolean
| polygon, polygonpg_catalog | poly_below | boolean
| polygon, polygonpg_catalog | poly_center | point
| polygonpg_catalog | poly_contain | boolean
| polygon, polygonpg_catalog | poly_contain_pt | boolean
| polygon, pointpg_catalog | poly_contained | boolean
| polygon, polygonpg_catalog | poly_distance | double
precision | polygon, polygonpg_catalog | poly_left | boolean
| polygon, polygonpg_catalog | poly_npoints | integer
| polygonpg_catalog | poly_overabove | boolean
| polygon, polygonpg_catalog | poly_overbelow | boolean
| polygon, polygonpg_catalog | poly_overlap | boolean
| polygon, polygonpg_catalog | poly_overleft | boolean
| polygon, polygonpg_catalog | poly_overright | boolean
| polygon, polygonpg_catalog | poly_recv | polygon
| internalpg_catalog | poly_right | boolean
| polygon, polygonpg_catalog | poly_same | boolean
| polygon, polygonpg_catalog | poly_send | bytea
| polygonpg_catalog | polygon | polygon
| boxpg_catalog | polygon | polygon
| circlepg_catalog | polygon | polygon
| integer, circlepg_catalog | polygon | polygon
| pathpg_catalog | popen | path
| pathpg_catalog | position | integer
| bit, bitpg_catalog | position | integer
| bytea, byteapg_catalog | position | integer
| text, textpg_catalog | positionjoinsel | double
precision | internal, oid, internal, smallintpg_catalog | positionsel |
double
precision | internal, oid, internal, integerpg_catalog | pow |
double
precision | double precision, double precisionpg_catalog | pow |
numeric
| numeric, numericpg_catalog | power | double
precision | double precision, double precisionpg_catalog | power |
numeric
| numeric, numericpg_catalog | prsd_end | void
| internalpg_catalog | prsd_headline | internal
| internal, internal, tsquerypg_catalog | prsd_lextype | internal
| internalpg_catalog | prsd_nexttoken | internal
| internal, internal, internalpg_catalog | prsd_start | internal
| internal, integerpg_catalog | pt_contained_circle | boolean
| point, circlepg_catalog | pt_contained_poly | boolean
| point, polygonpg_catalog | query_to_xml | xml
| query text, nulls boolean, tableforest boolean, targetns textpg_catalog | query_to_xml_and_xmlschema
| xml
| query text, nulls boolean, tableforest boolean, targetns textpg_catalog | query_to_xmlschema
| xml
| query text, nulls boolean, tableforest boolean, targetns textpg_catalog | querytree
| text
| tsquerypg_catalog | quote_ident | text
| textpg_catalog | quote_literal | text
| anyelementpg_catalog | quote_literal | text
| textpg_catalog | radians | double
precision | double precisionpg_catalog | radius | double
precision | circlepg_catalog | random | double
precision | pg_catalog | record_recv | record
| internal, oid, integerpg_catalog | record_send | bytea
| recordpg_catalog | regclass | regclass
| textpg_catalog | regclassrecv | regclass
| internalpg_catalog | regclasssend | bytea
| regclasspg_catalog | regconfigrecv | regconfig
| internalpg_catalog | regconfigsend | bytea
| regconfigpg_catalog | regdictionaryrecv |
regdictionary | internalpg_catalog | regdictionarysend | bytea
| regdictionarypg_catalog | regexeqjoinsel | double
precision | internal, oid, internal, smallintpg_catalog | regexeqsel |
double
precision | internal, oid, internal, integerpg_catalog | regexnejoinsel |
double
precision | internal, oid, internal, smallintpg_catalog | regexnesel |
double
precision | internal, oid, internal, integerpg_catalog | regexp_matches |
setof
text[] | text, textpg_catalog | regexp_matches | setof
text[] | text, text, textpg_catalog | regexp_replace | text
| text, text, textpg_catalog | regexp_replace | text
| text, text, text, textpg_catalog | regexp_split_to_array | text[]
| text, textpg_catalog | regexp_split_to_array | text[]
| text, text, textpg_catalog | regexp_split_to_table | setof text
| text, textpg_catalog | regexp_split_to_table | setof text
| text, text, textpg_catalog | regoperatorrecv | regoperator
| internalpg_catalog | regoperatorsend | bytea
| regoperatorpg_catalog | regoperrecv | regoper
| internalpg_catalog | regopersend | bytea
| regoperpg_catalog | regprocedurerecv |
regprocedure | internalpg_catalog | regproceduresend | bytea
| regprocedurepg_catalog | regprocrecv | regproc
| internalpg_catalog | regprocsend | bytea
| regprocpg_catalog | regtyperecv | regtype
| internalpg_catalog | regtypesend | bytea
| regtypepg_catalog | reltime | reltime
| intervalpg_catalog | reltimeeq | boolean
| reltime, reltimepg_catalog | reltimege | boolean
| reltime, reltimepg_catalog | reltimegt | boolean
| reltime, reltimepg_catalog | reltimele | boolean
| reltime, reltimepg_catalog | reltimelt | boolean
| reltime, reltimepg_catalog | reltimene | boolean
| reltime, reltimepg_catalog | reltimerecv | reltime
| internalpg_catalog | reltimesend | bytea
| reltimepg_catalog | repeat | text
| text, integerpg_catalog | replace | text
| text, text, textpg_catalog | round | double
precision | double precisionpg_catalog | round | numeric
| numericpg_catalog | round | numeric
| numeric, integerpg_catalog | rpad | text
| text, integerpg_catalog | rpad | text
| text, integer, textpg_catalog | rtrim | text
| textpg_catalog | rtrim | text
| text, textpg_catalog | scalargtjoinsel | double
precision | internal, oid, internal, smallintpg_catalog | scalargtsel |
double
precision | internal, oid, internal, integerpg_catalog | scalarltjoinsel |
double
precision | internal, oid, internal, smallintpg_catalog | scalarltsel |
double
precision | internal, oid, internal, integerpg_catalog | schema_to_xml | xml
| schema name, nulls boolean, tableforest boolean, targetns textpg_catalog | schema_to_xml_and_xmlschema
| xml
| schema name, nulls boolean, tableforest boolean, targetns textpg_catalog | schema_to_xmlschema
| xml
| schema name, nulls boolean, tableforest boolean, targetns textpg_catalog | session_user
| name
| pg_catalog | set_bit | bytea
| bytea, integer, integerpg_catalog | set_byte | bytea
| bytea, integer, integerpg_catalog | set_config | text
| text, text, booleanpg_catalog | set_masklen | cidr
| cidr, integerpg_catalog | set_masklen | inet
| inet, integerpg_catalog | setseed | void
| double precisionpg_catalog | setval | bigint
| regclass, bigintpg_catalog | setval | bigint
| regclass, bigint, booleanpg_catalog | setweight | tsvector
| tsvector, "char"pg_catalog | shift_jis_2004_to_euc_jis_2004 | void
| integer, integer, cstring, internal, integerpg_catalog | shift_jis_2004_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | shobj_description | text
| oid, namepg_catalog | sign | double
precision | double precisionpg_catalog | sign | numeric
| numericpg_catalog | similar_escape | text
| text, textpg_catalog | sin | double
precision | double precisionpg_catalog | sjis_to_euc_jp | void
| integer, integer, cstring, internal, integerpg_catalog | sjis_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | sjis_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | slope | double
precision | point, pointpg_catalog | smgreq | boolean
| smgr, smgrpg_catalog | smgrne | boolean
| smgr, smgrpg_catalog | split_part | text
| text, text, integerpg_catalog | sqrt | double
precision | double precisionpg_catalog | sqrt | numeric
| numericpg_catalog | statement_timestamp | timestamp
with time zone | pg_catalog | string_to_array | text[]
| text, textpg_catalog | strip | tsvector
| tsvectorpg_catalog | strpos | integer
| text, textpg_catalog | substr | bytea
| bytea, integerpg_catalog | substr | bytea
| bytea, integer, integerpg_catalog | substr | text
| text, integerpg_catalog | substr | text
| text, integer, integerpg_catalog | substring | bit
| bit, integerpg_catalog | substring | bit
| bit, integer, integerpg_catalog | substring | bytea
| bytea, integerpg_catalog | substring | bytea
| bytea, integer, integerpg_catalog | substring | text
| text, integerpg_catalog | substring | text
| text, integer, integerpg_catalog | substring | text
| text, textpg_catalog | substring | text
| text, text, textpg_catalog | table_to_xml | xml
| tbl regclass, nulls boolean, tableforest boolean, targetns textpg_catalog | table_to_xml_and_xmlschema
| xml
| tbl regclass, nulls boolean, tableforest boolean, targetns textpg_catalog | table_to_xmlschema
| xml
| tbl regclass, nulls boolean, tableforest boolean, targetns textpg_catalog | tan
| double
precision | double precisionpg_catalog | text | text
| booleanpg_catalog | text | text
| "char"pg_catalog | text | text
| characterpg_catalog | text | text
| inetpg_catalog | text | text
| namepg_catalog | text | text
| xmlpg_catalog | text_ge | boolean
| text, textpg_catalog | text_gt | boolean
| text, textpg_catalog | text_larger | text
| text, textpg_catalog | text_le | boolean
| text, textpg_catalog | text_lt | boolean
| text, textpg_catalog | text_pattern_eq | boolean
| text, textpg_catalog | text_pattern_ge | boolean
| text, textpg_catalog | text_pattern_gt | boolean
| text, textpg_catalog | text_pattern_le | boolean
| text, textpg_catalog | text_pattern_lt | boolean
| text, textpg_catalog | text_pattern_ne | boolean
| text, textpg_catalog | text_smaller | text
| text, textpg_catalog | textanycat | text
| text, anynonarraypg_catalog | textcat | text
| text, textpg_catalog | texteq | boolean
| text, textpg_catalog | texticlike | boolean
| text, textpg_catalog | texticnlike | boolean
| text, textpg_catalog | texticregexeq | boolean
| text, textpg_catalog | texticregexne | boolean
| text, textpg_catalog | textlen | integer
| textpg_catalog | textlike | boolean
| text, textpg_catalog | textne | boolean
| text, textpg_catalog | textnlike | boolean
| text, textpg_catalog | textrecv | text
| internalpg_catalog | textregexeq | boolean
| text, textpg_catalog | textregexne | boolean
| text, textpg_catalog | textsend | bytea
| textpg_catalog | thesaurus_init | internal
| internalpg_catalog | thesaurus_lexize | internal
| internal, internal, internal, internalpg_catalog | tideq | boolean
| tid, tidpg_catalog | tidge | boolean
| tid, tidpg_catalog | tidgt | boolean
| tid, tidpg_catalog | tidlarger | tid
| tid, tidpg_catalog | tidle | boolean
| tid, tidpg_catalog | tidlt | boolean
| tid, tidpg_catalog | tidne | boolean
| tid, tidpg_catalog | tidrecv | tid
| internalpg_catalog | tidsend | bytea
| tidpg_catalog | tidsmaller | tid
| tid, tidpg_catalog | time | time
without time zone | abstimepg_catalog | time | time
without time zone | intervalpg_catalog | time | time
without time zone | timestamp without time zonepg_catalog | time | time
without time zone | timestamp with time zonepg_catalog | time | time
without time zone | time without time zone, integerpg_catalog | time |
time
without time zone | time with time zonepg_catalog | time_cmp | integer
| time without time zone, time without time zonepg_catalog | time_eq | boolean
| time without time zone, time without time zonepg_catalog | time_ge | boolean
| time without time zone, time without time zonepg_catalog | time_gt | boolean
| time without time zone, time without time zonepg_catalog | time_hash | integer
| time without time zonepg_catalog | time_larger | time
without time zone | time without time zone, time without time zonepg_catalog | time_le
| boolean
| time without time zone, time without time zonepg_catalog | time_lt | boolean
| time without time zone, time without time zonepg_catalog | time_mi_interval | time
without time zone | time without time zone, intervalpg_catalog | time_mi_time |
interval
| time without time zone, time without time zonepg_catalog | time_ne | boolean
| time without time zone, time without time zonepg_catalog | time_pl_interval | time
without time zone | time without time zone, intervalpg_catalog | time_recv |
time
without time zone | internal, oid, integerpg_catalog | time_send | bytea
| time without time zonepg_catalog | time_smaller | time
without time zone | time without time zone, time without time zonepg_catalog | timedate_pl
| timestamp
without time zone | time without time zone, datepg_catalog | timemi | abstime
| abstime, reltimepg_catalog | timenow | abstime
| pg_catalog | timeofday | text
| pg_catalog | timepl | abstime
| abstime, reltimepg_catalog | timestamp | timestamp
without time zone | abstimepg_catalog | timestamp | timestamp
without time zone | datepg_catalog | timestamp | timestamp
without time zone | date, time without time zonepg_catalog | timestamp | timestamp
without time zone | timestamp without time zone, integerpg_catalog | timestamp |
timestamp
without time zone | timestamp with time zonepg_catalog | timestamp_cmp | integer
| timestamp without time zone, timestamp without time zonepg_catalog | timestamp_cmp_date |
integer
| timestamp without time zone, datepg_catalog | timestamp_cmp_timestamptz | integer
| timestamp without time zone, timestamp with time zonepg_catalog | timestamp_eq |
boolean
| timestamp without time zone, timestamp without time zonepg_catalog | timestamp_eq_date |
boolean
| timestamp without time zone, datepg_catalog | timestamp_eq_timestamptz | boolean
| timestamp without time zone, timestamp with time zonepg_catalog | timestamp_ge |
boolean
| timestamp without time zone, timestamp without time zonepg_catalog | timestamp_ge_date |
boolean
| timestamp without time zone, datepg_catalog | timestamp_ge_timestamptz | boolean
| timestamp without time zone, timestamp with time zonepg_catalog | timestamp_gt |
boolean
| timestamp without time zone, timestamp without time zonepg_catalog | timestamp_gt_date |
boolean
| timestamp without time zone, datepg_catalog | timestamp_gt_timestamptz | boolean
| timestamp without time zone, timestamp with time zonepg_catalog | timestamp_hash |
integer
| timestamp without time zonepg_catalog | timestamp_larger | timestamp
without time zone | timestamp without time zone, timestamp without time
zonepg_catalog | timestamp_le | boolean
| timestamp without time zone, timestamp without time zonepg_catalog | timestamp_le_date |
boolean
| timestamp without time zone, datepg_catalog | timestamp_le_timestamptz | boolean
| timestamp without time zone, timestamp with time zonepg_catalog | timestamp_lt |
boolean
| timestamp without time zone, timestamp without time zonepg_catalog | timestamp_lt_date |
boolean
| timestamp without time zone, datepg_catalog | timestamp_lt_timestamptz | boolean
| timestamp without time zone, timestamp with time zonepg_catalog | timestamp_mi |
interval
| timestamp without time zone, timestamp without time zonepg_catalog | timestamp_mi_interval |
timestamp
without time zone | timestamp without time zone, intervalpg_catalog | timestamp_ne |
boolean
| timestamp without time zone, timestamp without time zonepg_catalog | timestamp_ne_date |
boolean
| timestamp without time zone, datepg_catalog | timestamp_ne_timestamptz | boolean
| timestamp without time zone, timestamp with time zonepg_catalog | timestamp_pl_interval |
timestamp
without time zone | timestamp without time zone, intervalpg_catalog | timestamp_recv |
timestamp
without time zone | internal, oid, integerpg_catalog | timestamp_send | bytea
| timestamp without time zonepg_catalog | timestamp_smaller | timestamp
without time zone | timestamp without time zone, timestamp without time
zonepg_catalog | timestamptypmodin | integer
| cstring[]pg_catalog | timestamptz | timestamp
with time zone | abstimepg_catalog | timestamptz | timestamp
with time zone | datepg_catalog | timestamptz | timestamp
with time zone | date, time without time zonepg_catalog | timestamptz | timestamp
with time zone | date, time with time zonepg_catalog | timestamptz | timestamp
with time zone | timestamp without time zonepg_catalog | timestamptz | timestamp
with time zone | timestamp with time zone, integerpg_catalog | timestamptz_cmp |
integer
| timestamp with time zone, timestamp with time zonepg_catalog | timestamptz_cmp_date |
integer
| timestamp with time zone, datepg_catalog | timestamptz_cmp_timestamp | integer
| timestamp with time zone, timestamp without time zonepg_catalog | timestamptz_eq |
boolean
| timestamp with time zone, timestamp with time zonepg_catalog | timestamptz_eq_date |
boolean
| timestamp with time zone, datepg_catalog | timestamptz_eq_timestamp | boolean
| timestamp with time zone, timestamp without time zonepg_catalog | timestamptz_ge |
boolean
| timestamp with time zone, timestamp with time zonepg_catalog | timestamptz_ge_date |
boolean
| timestamp with time zone, datepg_catalog | timestamptz_ge_timestamp | boolean
| timestamp with time zone, timestamp without time zonepg_catalog | timestamptz_gt |
boolean
| timestamp with time zone, timestamp with time zonepg_catalog | timestamptz_gt_date |
boolean
| timestamp with time zone, datepg_catalog | timestamptz_gt_timestamp | boolean
| timestamp with time zone, timestamp without time zonepg_catalog | timestamptz_larger |
timestamp
with time zone | timestamp with time zone, timestamp with time zonepg_catalog | timestamptz_le
| boolean
| timestamp with time zone, timestamp with time zonepg_catalog | timestamptz_le_date |
boolean
| timestamp with time zone, datepg_catalog | timestamptz_le_timestamp | boolean
| timestamp with time zone, timestamp without time zonepg_catalog | timestamptz_lt |
boolean
| timestamp with time zone, timestamp with time zonepg_catalog | timestamptz_lt_date |
boolean
| timestamp with time zone, datepg_catalog | timestamptz_lt_timestamp | boolean
| timestamp with time zone, timestamp without time zonepg_catalog | timestamptz_mi |
interval
| timestamp with time zone, timestamp with time zonepg_catalog | timestamptz_mi_interval |
timestamp
with time zone | timestamp with time zone, intervalpg_catalog | timestamptz_ne |
boolean
| timestamp with time zone, timestamp with time zonepg_catalog | timestamptz_ne_date |
boolean
| timestamp with time zone, datepg_catalog | timestamptz_ne_timestamp | boolean
| timestamp with time zone, timestamp without time zonepg_catalog | timestamptz_pl_interval |
timestamp
with time zone | timestamp with time zone, intervalpg_catalog | timestamptz_recv |
timestamp
with time zone | internal, oid, integerpg_catalog | timestamptz_send | bytea
| timestamp with time zonepg_catalog | timestamptz_smaller | timestamp
with time zone | timestamp with time zone, timestamp with time zonepg_catalog | timestamptztypmodin
| integer
| cstring[]pg_catalog | timetypmodin | integer
| cstring[]pg_catalog | timetz | time with
time zone | timestamp with time zonepg_catalog | timetz | time with
time zone | time without time zonepg_catalog | timetz | time with
time zone | time with time zone, integerpg_catalog | timetz_cmp | integer
| time with time zone, time with time zonepg_catalog | timetz_eq | boolean
| time with time zone, time with time zonepg_catalog | timetz_ge | boolean
| time with time zone, time with time zonepg_catalog | timetz_gt | boolean
| time with time zone, time with time zonepg_catalog | timetz_hash | integer
| time with time zonepg_catalog | timetz_larger | time with
time zone | time with time zone, time with time zonepg_catalog | timetz_le |
boolean
| time with time zone, time with time zonepg_catalog | timetz_lt | boolean
| time with time zone, time with time zonepg_catalog | timetz_mi_interval | time with
time zone | time with time zone, intervalpg_catalog | timetz_ne | boolean
| time with time zone, time with time zonepg_catalog | timetz_pl_interval | time with
time zone | time with time zone, intervalpg_catalog | timetz_recv | time with
time zone | internal, oid, integerpg_catalog | timetz_send | bytea
| time with time zonepg_catalog | timetz_smaller | time with
time zone | time with time zone, time with time zonepg_catalog | timetzdate_pl |
timestamp
with time zone | time with time zone, datepg_catalog | timetztypmodin | integer
| cstring[]pg_catalog | timezone | timestamp
without time zone | interval, timestamp with time zonepg_catalog | timezone |
timestamp
without time zone | text, timestamp with time zonepg_catalog | timezone |
timestamp
with time zone | interval, timestamp without time zonepg_catalog | timezone |
timestamp
with time zone | text, timestamp without time zonepg_catalog | timezone | time
with
time zone | interval, time with time zonepg_catalog | timezone | time with
time zone | text, time with time zonepg_catalog | tinterval | tinterval
| abstime, abstimepg_catalog | tintervalct | boolean
| tinterval, tintervalpg_catalog | tintervalend | abstime
| tintervalpg_catalog | tintervaleq | boolean
| tinterval, tintervalpg_catalog | tintervalge | boolean
| tinterval, tintervalpg_catalog | tintervalgt | boolean
| tinterval, tintervalpg_catalog | tintervalle | boolean
| tinterval, tintervalpg_catalog | tintervalleneq | boolean
| tinterval, reltimepg_catalog | tintervallenge | boolean
| tinterval, reltimepg_catalog | tintervallengt | boolean
| tinterval, reltimepg_catalog | tintervallenle | boolean
| tinterval, reltimepg_catalog | tintervallenlt | boolean
| tinterval, reltimepg_catalog | tintervallenne | boolean
| tinterval, reltimepg_catalog | tintervallt | boolean
| tinterval, tintervalpg_catalog | tintervalne | boolean
| tinterval, tintervalpg_catalog | tintervalov | boolean
| tinterval, tintervalpg_catalog | tintervalrecv | tinterval
| internalpg_catalog | tintervalrel | reltime
| tintervalpg_catalog | tintervalsame | boolean
| tinterval, tintervalpg_catalog | tintervalsend | bytea
| tintervalpg_catalog | tintervalstart | abstime
| tintervalpg_catalog | to_ascii | text
| textpg_catalog | to_ascii | text
| text, integerpg_catalog | to_ascii | text
| text, namepg_catalog | to_char | text
| bigint, textpg_catalog | to_char | text
| double precision, textpg_catalog | to_char | text
| integer, textpg_catalog | to_char | text
| interval, textpg_catalog | to_char | text
| numeric, textpg_catalog | to_char | text
| real, textpg_catalog | to_char | text
| timestamp without time zone, textpg_catalog | to_char | text
| timestamp with time zone, textpg_catalog | to_date | date
| text, textpg_catalog | to_hex | text
| bigintpg_catalog | to_hex | text
| integerpg_catalog | to_number | numeric
| text, textpg_catalog | to_timestamp | timestamp
with time zone | double precisionpg_catalog | to_timestamp | timestamp
with time zone | text, textpg_catalog | to_tsquery | tsquery
| regconfig, textpg_catalog | to_tsquery | tsquery
| textpg_catalog | to_tsvector | tsvector
| regconfig, textpg_catalog | to_tsvector | tsvector
| textpg_catalog | transaction_timestamp | timestamp
with time zone | pg_catalog | translate | text
| text, text, textpg_catalog | trunc | double
precision | double precisionpg_catalog | trunc | macaddr
| macaddrpg_catalog | trunc | numeric
| numericpg_catalog | trunc | numeric
| numeric, integerpg_catalog | ts_debug | setof
record | config regconfig, document text, OUT alias text,
OUT description text, OUT token text, OUT dictionaries regdictionary[],
OUT dictionary regdictionary, OUT lexemes text[]pg_catalog | ts_debug | setof
record | document text, OUT alias text, OUT description
text, OUT token text, OUT dictionaries regdictionary[], OUT dictionary
regdictionary, OUT lexemes text[]pg_catalog | ts_headline | text
| regconfig, text, tsquerypg_catalog | ts_headline | text
| regconfig, text, tsquery, textpg_catalog | ts_headline | text
| text, tsquerypg_catalog | ts_headline | text
| text, tsquery, textpg_catalog | ts_lexize | text[]
| regdictionary, textpg_catalog | ts_match_qv | boolean
| tsquery, tsvectorpg_catalog | ts_match_tq | boolean
| text, tsquerypg_catalog | ts_match_tt | boolean
| text, textpg_catalog | ts_match_vq | boolean
| tsvector, tsquerypg_catalog | ts_parse | setof
record | parser_name text, txt text, OUT tokid integer,
OUT token textpg_catalog | ts_parse | setof
record | parser_oid oid, txt text, OUT tokid integer, OUT
token textpg_catalog | ts_rank | real
| real[], tsvector, tsquerypg_catalog | ts_rank | real
| real[], tsvector, tsquery, integerpg_catalog | ts_rank | real
| tsvector, tsquerypg_catalog | ts_rank | real
| tsvector, tsquery, integerpg_catalog | ts_rank_cd | real
| real[], tsvector, tsquerypg_catalog | ts_rank_cd | real
| real[], tsvector, tsquery, integerpg_catalog | ts_rank_cd | real
| tsvector, tsquerypg_catalog | ts_rank_cd | real
| tsvector, tsquery, integerpg_catalog | ts_rewrite | tsquery
| tsquery, textpg_catalog | ts_rewrite | tsquery
| tsquery, tsquery, tsquerypg_catalog | ts_stat | setof
record | query text, OUT word text, OUT ndoc integer, OUT
nentry integerpg_catalog | ts_stat | setof
record | query text, weights text, OUT word text, OUT
ndoc integer, OUT nentry integerpg_catalog | ts_token_type | setof
record | parser_name text, OUT tokid integer, OUT alias
text, OUT description textpg_catalog | ts_token_type | setof
record | parser_oid oid, OUT tokid integer, OUT alias
text, OUT description textpg_catalog | tsq_mcontained | boolean
| tsquery, tsquerypg_catalog | tsq_mcontains | boolean
| tsquery, tsquerypg_catalog | tsquery_and | tsquery
| tsquery, tsquerypg_catalog | tsquery_cmp | integer
| tsquery, tsquerypg_catalog | tsquery_eq | boolean
| tsquery, tsquerypg_catalog | tsquery_ge | boolean
| tsquery, tsquerypg_catalog | tsquery_gt | boolean
| tsquery, tsquerypg_catalog | tsquery_le | boolean
| tsquery, tsquerypg_catalog | tsquery_lt | boolean
| tsquery, tsquerypg_catalog | tsquery_ne | boolean
| tsquery, tsquerypg_catalog | tsquery_not | tsquery
| tsquerypg_catalog | tsquery_or | tsquery
| tsquery, tsquerypg_catalog | tsqueryrecv | tsquery
| internalpg_catalog | tsquerysend | bytea
| tsquerypg_catalog | tsvector_cmp | integer
| tsvector, tsvectorpg_catalog | tsvector_concat | tsvector
| tsvector, tsvectorpg_catalog | tsvector_eq | boolean
| tsvector, tsvectorpg_catalog | tsvector_ge | boolean
| tsvector, tsvectorpg_catalog | tsvector_gt | boolean
| tsvector, tsvectorpg_catalog | tsvector_le | boolean
| tsvector, tsvectorpg_catalog | tsvector_lt | boolean
| tsvector, tsvectorpg_catalog | tsvector_ne | boolean
| tsvector, tsvectorpg_catalog | tsvector_update_trigger | trigger
| pg_catalog | tsvector_update_trigger_column | trigger
| pg_catalog | tsvectorrecv | tsvector
| internalpg_catalog | tsvectorsend | bytea
| tsvectorpg_catalog | txid_current | bigint
| pg_catalog | txid_current_snapshot |
txid_snapshot | pg_catalog | txid_snapshot_recv |
txid_snapshot | internalpg_catalog | txid_snapshot_send | bytea
| txid_snapshotpg_catalog | txid_snapshot_xip | setof
bigint | txid_snapshotpg_catalog | txid_snapshot_xmax | bigint
| txid_snapshotpg_catalog | txid_snapshot_xmin | bigint
| txid_snapshotpg_catalog | txid_visible_in_snapshot | boolean
| bigint, txid_snapshotpg_catalog | uhc_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | unknownrecv | unknown
| internalpg_catalog | unknownsend | bytea
| unknownpg_catalog | upper | text
| textpg_catalog | utf8_to_ascii | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_big5 | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_euc_cn | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_euc_jis_2004 | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_euc_jp | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_euc_kr | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_euc_tw | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_gb18030 | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_gbk | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_iso8859 | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_iso8859_1 | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_johab | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_koi8r | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_shift_jis_2004 | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_sjis | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_uhc | void
| integer, integer, cstring, internal, integerpg_catalog | utf8_to_win | void
| integer, integer, cstring, internal, integerpg_catalog | uuid_cmp | integer
| uuid, uuidpg_catalog | uuid_eq | boolean
| uuid, uuidpg_catalog | uuid_ge | boolean
| uuid, uuidpg_catalog | uuid_gt | boolean
| uuid, uuidpg_catalog | uuid_hash | integer
| uuidpg_catalog | uuid_le | boolean
| uuid, uuidpg_catalog | uuid_lt | boolean
| uuid, uuidpg_catalog | uuid_ne | boolean
| uuid, uuidpg_catalog | uuid_recv | uuid
| internalpg_catalog | uuid_send | bytea
| uuidpg_catalog | varbit | bit varying
| bit varying, integer, booleanpg_catalog | varbit_recv | bit varying
| internal, oid, integerpg_catalog | varbit_send | bytea
| bit varyingpg_catalog | varbitcmp | integer
| bit varying, bit varyingpg_catalog | varbiteq | boolean
| bit varying, bit varyingpg_catalog | varbitge | boolean
| bit varying, bit varyingpg_catalog | varbitgt | boolean
| bit varying, bit varyingpg_catalog | varbitle | boolean
| bit varying, bit varyingpg_catalog | varbitlt | boolean
| bit varying, bit varyingpg_catalog | varbitne | boolean
| bit varying, bit varyingpg_catalog | varbittypmodin | integer
| cstring[]pg_catalog | varchar | character
varying | character varying, integer, booleanpg_catalog | varchar |
character
varying | namepg_catalog | varcharrecv | character
varying | internal, oid, integerpg_catalog | varcharsend | bytea
| character varyingpg_catalog | varchartypmodin | integer
| cstring[]pg_catalog | version | text
| pg_catalog | width | double
precision | boxpg_catalog | width_bucket | integer
| double precision, double precision, double precision, integerpg_catalog | width_bucket
| integer
| numeric, numeric, numeric, integerpg_catalog | win1250_to_latin2 | void
| integer, integer, cstring, internal, integerpg_catalog | win1250_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | win1251_to_iso | void
| integer, integer, cstring, internal, integerpg_catalog | win1251_to_koi8r | void
| integer, integer, cstring, internal, integerpg_catalog | win1251_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | win1251_to_win866 | void
| integer, integer, cstring, internal, integerpg_catalog | win866_to_iso | void
| integer, integer, cstring, internal, integerpg_catalog | win866_to_koi8r | void
| integer, integer, cstring, internal, integerpg_catalog | win866_to_mic | void
| integer, integer, cstring, internal, integerpg_catalog | win866_to_win1251 | void
| integer, integer, cstring, internal, integerpg_catalog | win_to_utf8 | void
| integer, integer, cstring, internal, integerpg_catalog | xideq | boolean
| xid, xidpg_catalog | xideqint4 | boolean
| xid, integerpg_catalog | xidrecv | xid
| internalpg_catalog | xidsend | bytea
| xidpg_catalog | xml | xml
| textpg_catalog | xml_recv | xml
| internalpg_catalog | xml_send | bytea
| xmlpg_catalog | xmlcomment | xml
| textpg_catalog | xmlconcat2 | xml
| xml, xmlpg_catalog | xmlvalidate | boolean
| xml, textpg_catalog | xpath | xml[]
| text, xmlpg_catalog | xpath | xml[]
| text, xml, text[]public | drop_table | integer
| public | foo | setof text
| public | plfoo | setof text
|
(1858 rows)
--
PostgreSQL - XMPP: jdrake@jabber.postgresql.org Consulting, Development, Support, Training 503-667-4564 -
http://www.commandprompt.com/ The PostgreSQL Company, serving since 1997
I wrote:
> "Robert Haas" <robertmhaas@gmail.com> writes:
>> I'm not sure whether you're endorsing that approach or panning it, but
>> -1 from me. We have always had \d or \dt for user tables and \dS or
>> \dtS for system tables. No one is complaining about this AFAICS, so
>> we should \df be any different?
> You're ignoring the fact that tables and functions are different and
> are used differently.
BTW, it might be worth pointing out that \d has never worked like that;
for instance "\d pg_class" gives me an answer anyway. So holding up the
table behavior as a model of consistency that other \d commands should
emulate is a pretty weak argument to begin with.
regards, tom lane
> BTW, it might be worth pointing out that \d has never worked like that; > for instance "\d pg_class" gives me an answer anyway. So holding up the > table behavior as a model of consistency that other \d commands should > emulate is a pretty weak argument to begin with. So in 8.3.5, which is what I currently have in front of me: \d lists all tables, sequences, views \dt lists user tables only \d *foo* shows detailed information on all user and system tables, sequences, and views that have foo in the name \dt *foo* lists (without detail) all user tables \d foo shows detailed information about foo, regardless of whether foo is a user or system object \dt foo shows detailed information about foo, provided it is a user table So it appears that \dt only switches to detail mode when given a specific object, not when given a wildcard, whereas \d switches when given either a wildcard or a specific object, and only lists when given no arguments at all. I agree that is pretty weird. ...Robert
> You're ignoring the fact that tables and functions are different and > are used differently. In particular, most of the system catalogs are > not really meant to be used directly by users, which is surely not > true for functions and operators. > > However, having said that, I'm not averse to unifying the behavior > as long as it's done in a sensible fashion. Imposing the old behavior > of \dt on everything else is simply not that sensible fashion. Do you have another proposal? Although I agree with you that there's more of a case for a user wanting looking for system functions/operators than there is for looking for system tables, I think it's important that there is some EASY way to get only user functions, or only system functions, when that's what you want. In 8.3, you can get that for tables but not for functions, and it is a huge pain in the neck. Since there are only a limited number of characters in the alphabet, it's not going to be possible to have a two-letter sequence for everything someone might want to do. We are only talking about one extra character to get at the stuff in the system catalog, though I'm curmudgeonly enough to wish it weren't a capital letter so I could avoid having to hit the shift key. ...Robert
> I know I already posted this but it seems the most useful behavior is to > just change the sort. It doesn't change any behavior in terms of > flags/switches so there is nothing new to learn. It just changes the > output. That's better than nothing, but it still doesn't help when I want to do: psql -c '\df' | grep bool This is not a made-up use case. ...Robert
On Thu, Jan 15, 2009 at 01:06:22PM -0500, Tom Lane wrote: > Bruce Momjian <bruce@momjian.us> writes: > > Well, this is psql and it should be easy; I am not sure > > pg_catalog.* fits that requirement. > > It should be easy for common cases, which I argue "I need to see > *only* system objects" is not. Neither is "I need to see system objects by default," despite what some people whose day job is hacking on PostgreSQL may believe. Cheers, David. -- David Fetter <david@fetter.org> http://fetter.org/ Phone: +1 415 235 3778 AIM: dfetter666 Yahoo!: dfetter Skype: davidfetter XMPP: david.fetter@gmail.com Remember to vote! Consider donating to Postgres: http://www.postgresql.org/about/donate
"Robert Haas" <robertmhaas@gmail.com> writes:
>> However, having said that, I'm not averse to unifying the behavior
>> as long as it's done in a sensible fashion. Imposing the old behavior
>> of \dt on everything else is simply not that sensible fashion.
> Do you have another proposal?
> Although I agree with you that there's more of a case for a user
> wanting looking for system functions/operators than there is for
> looking for system tables, I think it's important that there is some
> EASY way to get only user functions, or only system functions, when
> that's what you want.
Well, as I said before, I'm not averse to having the default behavior
*with no pattern* to be that we omit system objects --- and I think we
could make that apply across the board. What I'm saying is that when
you give a pattern it should not matter whether an object is system or
user. It would go like this:
\df -- all non-system functions
\df sin -- the active (visible) definition of sin()
\df sin* -- all visible functions starting with "sin"
lesser used cases:
\df * -- all visible functions
\df *.* -- all functions, period
\df pg_catalog.* -- all system functions
\df public.* -- all functions in public
Now admittedly, if your user functions are scattered across multiple
schemas this doesn't provide any easy way to say "all functions starting
with "sin" that are *not* system functions", but I don't see that that
is such an important use-case that it trumps usability for every other
purpose. If you're naming your functions in a way that conflicts with
system functions, you're going to have other problems (and a \df acting
as HEAD does would actually get in the way of you discovering what the
root of the problem is).
regards, tom lane
On Thu, Jan 15, 2009 at 01:46:08PM -0500, Robert Haas wrote: > > I know I already posted this but it seems the most useful behavior is to > > just change the sort. It doesn't change any behavior in terms of > > flags/switches so there is nothing new to learn. It just changes the > > output. > > That's better than nothing, but it still doesn't help when I want to do: > > psql -c '\df' | grep bool psql -c '\dfS' |grep bool > This is not a made-up use case. Nor is does this long overdue change impose an undue burden on it :) Cheers, David. -- David Fetter <david@fetter.org> http://fetter.org/ Phone: +1 415 235 3778 AIM: dfetter666 Yahoo!: dfetter Skype: davidfetter XMPP: david.fetter@gmail.com Remember to vote! Consider donating to Postgres: http://www.postgresql.org/about/donate
David Fetter <david@fetter.org> writes:
> On Thu, Jan 15, 2009 at 01:46:08PM -0500, Robert Haas wrote:
>> That's better than nothing, but it still doesn't help when I want to do:
>> psql -c '\df' | grep bool
> psql -c '\dfS' |grep bool
That presumes the opposite case, when you only want to see system
functions.
I hesitate to suggest this, but maybe an acceptable compromise is\df -> old behavior\dfS -> only system functions\dfU
->only user functions
I do not actually believe that either of the latter really makes
sense in combination with a pattern, but if people are going to
insist on seeing a misleading view of the system state, let's at
least make it symmetric.
regards, tom lane
Tom, > The real problem here is that the 'S' suffix for \dt is a bad precedent > for everything else. If you want consistency then we need to change > that end of things. I think that the idea of a switch to omit system > objects, rather than include them, might work. I disagree. Most users, most of the time, do not want to see system objects. So all of the \d commands should omit system objects by default, and we should have one consistent switch across all \d commands to include system objects. Actually, I personally would prefer a *general* switch, that is: \system on \system off ... which would turn on and off the display of system objects with all \d commands, over extending \d with an array of Hungarian notation suffixes. --Josh
Le 15 janv. 09 à 17:16, Tom Lane <tgl@sss.pgh.pa.us> a écrit : > Peter Eisentraut <peter_e@gmx.net> writes: >> This patch has annoyed me twice in two days now, and similarly with >> other people I know. Having to type \dfS now is about the worst >> loss of >> usability in psql that I can recall. Can we reconsider or revert >> this? > > I agree, this change mostly sucks, and particularly with respect to > \df. Maybe it does so much 'cause you're developing system functions. I've yet to try it but think it's a good feature. What about a new \dfU listing only non system objects ( User ones ) ? -- dim
Josh Berkus <josh@agliodbs.com> writes:
> I disagree. Most users, most of the time, do not want to see system
> objects.
I remain of the opinion that this opinion is wrong, and is based on
lack of experience with the committed patch.
You *think* you don't want to see system objects. The first time that
you waste hours trying to figure out why your function doesn't work,
only to find that it conflicts with a system function that \df wasn't
showing you, you'll reconsider.
However, since it seems that people are willing to be vocal regardless
of how much time they've spent with CVS HEAD, maybe we had better wait
till we are a month or so into beta and then take up the discussion
again.
regards, tom lane
Dimitri Fontaine <dfontaine@hi-media.com> writes:
> Le 15 janv. 09 à 17:16, Tom Lane <tgl@sss.pgh.pa.us> a écrit :
>> I agree, this change mostly sucks, and particularly with respect to
>> \df.
> Maybe it does so much 'cause you're developing system functions.
No, I hardly ever use \df on a function I'm working on just at the
moment, because I know what it's supposed to be. It's remembering
functions that I haven't used lately that is the issue.
> I've yet to try it but think it's a good feature. ^^^^^^^^^^^^^^^^^^
Indeed...
> What about a new \dfU listing only non system objects ( User ones ) ?
\dfS together with \dfU would at least be a reasonably symmetric
extension. I'm still of the opinion that neither is really a very
helpful thing to use in connection with a pattern.
regards, tom lane
Le 15 janv. 09 à 21:39, Tom Lane <tgl@sss.pgh.pa.us> a écrit : > \dfS together with \dfU would at least be a reasonably symmetric > extension. I'm still of the opinion that neither is really a very > helpful thing to use in connection with a pattern. I completly agree with the idea of showing things respecting current search_path for pattern matches. Even more so now that I've read the thread. -- dim
On Thu, Jan 15, 2009 at 3:03 PM, Josh Berkus <josh@agliodbs.com> wrote: >> The real problem here is that the 'S' suffix for \dt is a bad precedent >> for everything else. If you want consistency then we need to change >> that end of things. I think that the idea of a switch to omit system >> objects, rather than include them, might work. > > I disagree. Most users, most of the time, do not want to see system > objects. So all of the \d commands should omit system objects by default, > and we should have one consistent switch across all \d commands to include > system objects. > > Actually, I personally would prefer a *general* switch, that is: > > \system on > \system off > > ... which would turn on and off the display of system objects with all \d > commands, over extending \d with an array of Hungarian notation suffixes. I think the general switch is a good idea, because then everyone can get the behavior they want using ~/.psqlrc. But I still want the Hungarian suffixes because being able to get a different behavior just once is handy. ...Robert
Tom, > You *think* you don't want to see system objects. The first time that > you waste hours trying to figure out why your function doesn't work, > only to find that it conflicts with a system function that \df wasn't > showing you, you'll reconsider. I'm still a consultant for a living, so I use the psql command line on a variety of client systems a lot. And I'll tell you that 80% of the time I use \df it's to look up the exact spelling and parameters of a user-defined function, not a builtin. The builtins are well-documented in the PostgreSQL docs; why would I use \df to look them up? In other words, no, I can't tell you that this patch is well-implemented (and for that matter I don't like the syntax of \dfS), but I can say that the *current* behavior is annoying and time-wasting, and always has been. It's also inconsistent with the behavior of \dt. So I'm not arguing for this patch ... I'd reject it on messy syntax grounds, and because I think a general \system switch is cleaner ... but I am arguing against rejecting the idea that we want the default behavior to show user-defined functions. --Josh
Josh Berkus <josh@agliodbs.com> writes:
>> You *think* you don't want to see system objects.
> I'm still a consultant for a living, so I use the psql command line on a
> variety of client systems a lot. And I'll tell you that 80% of the time
> I use \df it's to look up the exact spelling and parameters of a
> user-defined function, not a builtin.
And?
It seems to me there are two cases here:
1. You want to just write "\df" because there aren't a whole lot of
user-defined functions. Fine, I'm okay with changing the behavior
of that case to show only user-defined functions.
2. You want to write "\df something". Fine, that's not going to show
any system functions anyway, unless there are system functions that are
also selected by "something". If there are, it's not apparent to me why
it's a bad idea to show them; as I've already argued, I think not
showing them is a horrid idea, especially if they are an exact match
that will mask the user-defined function.
> So I'm not arguing for this patch ... I'd reject it on messy syntax
> grounds, and because I think a general \system switch is cleaner ...
I'm unimpressed with the idea of a \system switch, because it will still
be breaking your \df queries hours after you forgot you used it to
adjust \dt. (This argument holds no matter which way you prefer as
default.)
regards, tom lane
Tom, > I'm unimpressed with the idea of a \system switch, because it will still > be breaking your \df queries hours after you forgot you used it to > adjust \dt. (This argument holds no matter which way you prefer as > default.) Hmmmm, OK. BTW, is this patch even under consideration for 8.4? If not, why are we arguing about it? We have 6 months after 8.4 comes out to work out a spec. --Josh
> 2. You want to write "\df something". Fine, that's not going to show > any system functions anyway, unless there are system functions that are > also selected by "something". If there are, it's not apparent to me why > it's a bad idea to show them; as I've already argued, I think not > showing them is a horrid idea, especially if they are an exact match > that will mask the user-defined function. You seem to be assuming that conflicts between user-defined functions and system functions are a common problem against which users need protection. I have been using PostgreSQL for almost 10 years and am not sure that I've EVER had a problem with this. Maybe once? On the other hand, I want to look at and search my user-defined functions FREQUENTLY. I don't care about the system functions. If I type \df a*, it's not because I want to see all 6 versions of the absolute value function and 61 other functions, it's because I don't want to think hard enough to remember how I spelled the first word in one of my functions that I know starts with "a". I can't imagine why it's reasonable for me to want to see a list of only my own functions, but it's NOT reasonable for me to want to SEARCH the list of only my own functions. ...Robert
Josh Berkus <josh@agliodbs.com> writes:
> BTW, is this patch even under consideration for 8.4?
It's already committed --- remember the start of the thread was Peter
complaining that he'd already been annoyed by the new behavior. (As
had I, but I'd not gotten round to complaining yet.)
If we wait till after 8.4 is released to reconsider, we'll have yet
another layer of backwards-compatibility issues to deal with while
trying to fix it.
regards, tom lane
* Robert Haas (robertmhaas@gmail.com) wrote:
> On the other hand, I want to look at and search my user-defined
> functions FREQUENTLY. I don't care about the system functions. If I
> type \df a*, it's not because I want to see all 6 versions of the
> absolute value function and 61 other functions, it's because I don't
> want to think hard enough to remember how I spelled the first word in
> one of my functions that I know starts with "a".
I have to agree with this in general, to be honest. We use alot of
pl/pgsql functions and having the system functions be in \df and be
included in '\df a*' searches has really been annoying, not to mention
that it's time consuming. I do understand Tom's concern, but I wonder
if we could address is in a different way- could we WARN about
functions being created which overlap with system functions at CREATE
time? I'm pretty sure people don't generally do that on purpose, and if
they do, they need to realize they have to treat it specially
afterwards to make sure they get their function called..
> I can't imagine why it's reasonable for me to want to see a list of
> only my own functions, but it's NOT reasonable for me to want to
> SEARCH the list of only my own functions.
I would like the ability to search system functions too, I've had
occation where that's easier than going to the docs for a particular
function, but my impression was that'd be possible through \dfS or
something?
Thanks,
Stephen
Robert Haas <robertmhaas@gmail.com> writes:
> You seem to be assuming that conflicts between user-defined functions
> and system functions are a common problem against which users need
> protection. I have been using PostgreSQL for almost 10 years and am
> not sure that I've EVER had a problem with this.
Probably not, else it would be seared into your memory and you'd not be
in favor of making a change that increases the odds of repeating the
experience ;-)
> On the other hand, I want to look at and search my user-defined
> functions FREQUENTLY. I don't care about the system functions. If I
> type \df a*, it's not because I want to see all 6 versions of the
> absolute value function and 61 other functions, it's because I don't
> want to think hard enough to remember how I spelled the first word in
> one of my functions that I know starts with "a".
Well, maybe we do need to go with the \df \dfS \dfU approach.
But I'm still convinced that setting things up so that it's impossible
to search both classes of functions together is a seriously bad idea.
regards, tom lane
Tom, > Well, maybe we do need to go with the \df \dfS \dfU approach. > But I'm still convinced that setting things up so that it's impossible > to search both classes of functions together is a seriously bad idea. Agreed -- there are times I *want* to search the system functions, and for less-trained users they might not know the difference between UDFs and builtin functions, especially if they've loaded a few contrib modules. Personally, I don't care that much about what Hungarian Notation we use, as long as we try to make it consistent with \dt, \dv, \dn etc. My main objection to requiring \dfU to get only user functions is that it's not what we do with \dt. --Josh
>> On the other hand, I want to look at and search my user-defined >> functions FREQUENTLY. I don't care about the system functions. If I >> type \df a*, it's not because I want to see all 6 versions of the >> absolute value function and 61 other functions, it's because I don't >> want to think hard enough to remember how I spelled the first word in >> one of my functions that I know starts with "a". > > Well, maybe we do need to go with the \df \dfS \dfU approach. > But I'm still convinced that setting things up so that it's impossible > to search both classes of functions together is a seriously bad idea. I agree - that's one thing that's definitely weird about the new behavior. Of course, we've had this problem with \dt for a while, but it is somewhat masked by the fact that \d (without t) behaves differently (which seems totally strange too, come to think about it).I think maybe we should make \dt, \df, etc. show userobjects, \dtS, \dfS, etc. show system objects and pick some other glyph to mean "everything". \dfA, \df!, I don't care what it is... ...Robert
On Thu, 2009-01-15 at 14:32 -0800, Josh Berkus wrote: > Tom, > > Personally, I don't care that much about what Hungarian Notation we use, > as long as we try to make it consistent with \dt, \dv, \dn etc. My main > objection to requiring \dfU to get only user functions is that it's not > what we do with \dt. O.k. since Tom rightfully complained that everyone was bleating about this patch without actually trying it, I updated to head and checked it out and this is what I got: postgres=# \df List of functionsSchema | Name | Result data type | Argument data types --------+------+------------------+--------------------- (0 rows) Which I admit caught me off guard. The main problem with the above is it says, "List of functions". It should say, "List of User Defined Functions" or some such thing. If I type \dfS I get the usual list of system functions. I created a user function: postgres=# create function test() returns integer AS $$select 1$$ language 'SQL'; CREATE FUNCTION And then used \df postgres=# \df List of functionsSchema | Name | Result data type | Argument data types --------+------+------------------+---------------------public | test | integer | (1 row) I like this behavior. A lot. I then created a new schema and a function inside the schema: postgres=# create schema functions; CREATE SCHEMA postgres=# create function functions.test() returns integer AS $$select 1$$ language 'SQL'; CREATE FUNCTION postgres=# \df List of functionsSchema | Name | Result data type | Argument data types --------+------+------------------+---------------------public | test | integer | (1 row) That was a little irritating but I get the point. The schema functions is not in my search path. So: postgres=# set search_path to public,functions; SET postgres=# \df List of functionsSchema | Name | Result data type | Argument data types --------+------+------------------+---------------------public | test | integer | (1 row) The above is broken. If I put functions in my search path and perform a \df I should get user functions from public and functions. postgres=# set search_path to functions; SET postgres=# \df List of functions Schema | Name | Result data type | Argument data types -----------+------+------------------+---------------------functions | test | integer | (1 row) Performs as expected. So to me, the patch needs to be fixed. It should search whatever is in my search path. It should further properly reflect what I am searching on in its header (List of User Defined Functions). I do not see any usefulness to searching *ALL* functions except on that rare occasion where you do them, "Where did I create that function again?". You can use pg_dump -s for that. Further I would also be perfectly happy with the following behavior: \df does nothing but return: \df <please specify \dfU or \dfS or \dfA) Where \dfU is users, \dfS is system and \dfA is all (as a compromise). Sincerely, Joshua D. Drake -- PostgreSQL - XMPP: jdrake@jabber.postgresql.org Consulting, Development, Support, Training 503-667-4564 - http://www.commandprompt.com/ The PostgreSQL Company, serving since 1997
Josh Berkus <josh@agliodbs.com> writes:
>> Well, maybe we do need to go with the \df \dfS \dfU approach.
>> But I'm still convinced that setting things up so that it's impossible
>> to search both classes of functions together is a seriously bad idea.
> Agreed -- there are times I *want* to search the system functions, and
> for less-trained users they might not know the difference between UDFs
> and builtin functions, especially if they've loaded a few contrib modules.
Yeah, the contrib-module point is a telling one.
> Personally, I don't care that much about what Hungarian Notation we use,
> as long as we try to make it consistent with \dt, \dv, \dn etc. My main
> objection to requiring \dfU to get only user functions is that it's not
> what we do with \dt.
Well, if we were going to do anything like that, I'd want to change the
behavior of \dt to match everything else. I don't see the argument why
\dt's existing behavior is sacrosanct if the others aren't ...
regards, tom lane
* Joshua D. Drake (jd@commandprompt.com) wrote:
> I like this behavior. A lot.
ditto.
> That was a little irritating but I get the point. The schema functions
> is not in my search path. So:
That's exactly right, imv.. I've got schemas with tons of functions in
them, I don't want to see every function in every schema in my
database every time I do \df..
> The above is broken. If I put functions in my search path and perform a
> \df I should get user functions from public and functions.
Agreed, 100%. That's definitely busted.
> So to me, the patch needs to be fixed. It should search whatever is in
> my search path. It should further properly reflect what I am searching
> on in its header (List of User Defined Functions).
I agree, though the header isn't a huge deal to me.
> I do not see any usefulness to searching *ALL* functions except on that
> rare occasion where you do them, "Where did I create that function
> again?". You can use pg_dump -s for that.
or pg_proc, and doesn't information_schema have some view?
> Further I would also be perfectly happy with the following behavior:
>
> \df does nothing but return:
>
> \df <please specify \dfU or \dfS or \dfA)
gah, I find that to be terrible. If we wanted to compromise, I'd
rather have \df do what it does today, to keep backwards-compat and
not confuse users, and \dfU to do what I want 99% of the time. That's
a better compromise than both changing \df *and* making it useless, if
we have to compromise.
On a seperate (kind of) note, I'd really like to be able to say "I want
this function visible everywhere" like a system function. public really
doesn't fit this bill very well, in my experience.
Thanks,
Stephen
Stephen, > On a seperate (kind of) note, I'd really like to be able to say "I want > this function visible everywhere" like a system function. public really > doesn't fit this bill very well, in my experience. We're *so* not going there. If you really want this, just log in as superuser and add the functions to pg_catalog. --Josh
Stephen Frost <sfrost@snowman.net> writes:
> gah, I find that to be terrible. If we wanted to compromise, I'd
> rather have \df do what it does today, to keep backwards-compat and
> not confuse users, and \dfU to do what I want 99% of the time.
This seems to me to be the compromise most likely to dissatisfy everyone
the least ...
> On a seperate (kind of) note, I'd really like to be able to say "I want
> this function visible everywhere" like a system function.
Huh? System functions don't have that property either.
You could do that today with a quick hack on your default search path,
though: set search_path = global, pg_catalog, public or something like
that (... and be *very* careful about what you put in schema "global").
regards, tom lane
On Thu, 2009-01-15 at 20:25 -0500, Tom Lane wrote: > Stephen Frost <sfrost@snowman.net> writes: > > gah, I find that to be terrible. If we wanted to compromise, I'd > > rather have \df do what it does today, to keep backwards-compat and > > not confuse users, and \dfU to do what I want 99% of the time. > > This seems to me to be the compromise most likely to dissatisfy everyone > the least ... I could live with that. Although I really think we should review how it interacts with search paths, but that could be a 8.5 thing. Joshua D. Drake -- PostgreSQL - XMPP: jdrake@jabber.postgresql.org Consulting, Development, Support, Training 503-667-4564 - http://www.commandprompt.com/ The PostgreSQL Company, serving since 1997
On Thu, Jan 15, 2009 at 8:25 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote: > Stephen Frost <sfrost@snowman.net> writes: >> gah, I find that to be terrible. If we wanted to compromise, I'd >> rather have \df do what it does today, to keep backwards-compat and >> not confuse users, and \dfU to do what I want 99% of the time. > > This seems to me to be the compromise most likely to dissatisfy everyone > the least ... This is more sensible than most of the alternatives that have been proposed. At least I can do what I want, even if not with exactly the easiest sequence to type. I really wonder what is so terrible about the behavrior as implemented in CVS HEAD. AFAICS, no one except maybe Tom has really specified WHY they don't like it, just that they don't like it. I'm not sure whether that's because (1) it's different, and they're used to the old way; (2) it involves typing an extra character to get the behavior they want; or (3) there's no way to search user and system functions simultaneously. I reply, with respect to (1), that the new behavior is more consistent and we'll all get used to it given time; with respect to (2), if someone is going to have to type an extra character it should be the developers, not the end-users; with respect to (3), there's nothing preventing us from adding yet another option to get that behavior. But I may be trying to push water up a hill, so, I can live with adding \dfU and keeping \df as-was. ...Robert
All, > But I may be trying to push water up a hill, so, I can live with > adding \dfU and keeping \df as-was. BTW, why the capital? \dfu is *considerably* easier to type than \dfU. \JosH
* Josh Berkus (josh@agliodbs.com) wrote:
>> But I may be trying to push water up a hill, so, I can live with
>> adding \dfU and keeping \df as-was.
>
> BTW, why the capital? \dfu is *considerably* easier to type than \dfU.
I havn't got much of a preference for \dfu vs. \dfU. Either works for
me. Still should list all functions on the search_path tho, just to be
clear.
Thanks,
Stephen
* Tom Lane (tgl@sss.pgh.pa.us) wrote:
> Stephen Frost <sfrost@snowman.net> writes:
> > On a seperate (kind of) note, I'd really like to be able to say "I want
> > this function visible everywhere" like a system function.
>
> Huh? System functions don't have that property either.
Perhaps I'm missing something, or it was a poor choice of words,
but:
postgres=> show search_path; search_path
----------------"$user",public
(1 row)
postgres*=> \df abstime
...pg_catalog | abstime | abstime | timestamp without time zone
...
postgres*=> select abstime('2008-10-10'); abstime
------------------------2008-10-10 00:00:00-04
(1 row)
Regardless of what I reset my search_path to, I'm going to have access
to abstime. Is there something else special about it besides being
a 'system function' and being in pg_catalog to make it always available
regardless of my search_path?
> You could do that today with a quick hack on your default search path,
> though: set search_path = global, pg_catalog, public or something like
> that (... and be *very* careful about what you put in schema "global").
I reset my search_path all the time going between different tasks,
different projects, etc, and it gets really annoying to have to include
', public;' every time I want to use a PostGIS function in my 'gis'
database. That's primairly what's driving this comment, and the fact
that I tend to like keeping the 'public' schema pristine. I would find
it much cleaner if I could drop my PostGIS functions in a 'postgis'
schema but still mark the public ones as being always available somehow.
I've got lots of functions in other schemas where I *don't* want them
globally available too, of course. And it should be something at the
level of database-owner or similar to declare functions in such a way.
The point there being that PostGIS is really an extension or a
module that, if all the stars aligned, might be part of the system
catalog some day (or the same functionality at any rate). Until then,
I'd like the ability to mimic it more closely than I can today. The
other fact being that it feels dirty to me to have to put any function
that I want globally available into the 'public' schema, thus
mish-mashing them together into one area.
I've lived with it for as long as I've been using PostGIS though, so
it's not exactly a show stopper.
Thanks,
Stephen
Josh Berkus <josh@agliodbs.com> writes:
>> But I may be trying to push water up a hill, so, I can live with
>> adding \dfU and keeping \df as-was.
> BTW, why the capital? \dfu is *considerably* easier to type than \dfU.
Because (1) its counterpart S is capitalized by historical tradition,
and (2) we are going to apply this to all the variants of \d so we'd
have a conflict with \du. (Even if we special-cased our way out of the
actual conflict, there would certainly be user confusion there.)
Also (3) you are not actually going to use this as much as you think
you are, so saving a shift keypress is not the be-all and end-all.
regards, tom lane
Josh,
* Josh Berkus (josh@agliodbs.com) wrote:
>> On a seperate (kind of) note, I'd really like to be able to say "I want
>> this function visible everywhere" like a system function. public really
>> doesn't fit this bill very well, in my experience.
>
> We're *so* not going there. If you really want this, just log in as
> superuser and add the functions to pg_catalog.
Perhaps I didn't consider that out of sheer paranoia, but now that
you've mentioned it, I'm not inherently against doing it if
it'd work and not cause me more headaches than what I've got today.
As I mentioned in my other email, this is mainly for PostGIS, but it can
certainly apply to other modules. Is this what we would recommend as an
approach for these kinds of modules? I feel like that would give
-hackers, or perhaps the PostGIS people, some heartburn, but maybe I'm
wrong?
Still doesn't solve my complaint about being unable to keep the
functions from different modules seperate, but that's true regardless of
using pg_catalog or public, so this could at least be a net improvment.
Comments?
Thanks,
Stephen
* Tom Lane (tgl@sss.pgh.pa.us) wrote:
> Josh Berkus <josh@agliodbs.com> writes:
> >> But I may be trying to push water up a hill, so, I can live with
> >> adding \dfU and keeping \df as-was.
>
> > BTW, why the capital? \dfu is *considerably* easier to type than \dfU.
>
> Because (1) its counterpart S is capitalized by historical tradition,
> and (2) we are going to apply this to all the variants of \d so we'd
> have a conflict with \du. (Even if we special-cased our way out of the
> actual conflict, there would certainly be user confusion there.)
>
> Also (3) you are not actually going to use this as much as you think
> you are, so saving a shift keypress is not the be-all and end-all.
Well, and (4), you could always 'remap' it, if you will:
-- obviously with \\dfU if it gets added
postgres*=> \set df '\\df'
postgres*=> :df
List of functions [...]
I use ':r' for 'rollback;' all the time (not my idea, someone on IRC),
but a : tends to be as easy for me as \. <shrug> I wouldn't complain
about a more generic aliasing ability in psql, mind you.
Thanks,
Stephen
Stephen Frost <sfrost@snowman.net> writes:
> Regardless of what I reset my search_path to, I'm going to have access
> to abstime. Is there something else special about it besides being
> a 'system function' and being in pg_catalog to make it always available
> regardless of my search_path?
Read the documentation for search_path: if pg_catalog isn't explicitly
mentioned, we add it implicitly. This is mainly because it would be
contrary to SQL spec (and pretty useless to boot) to not recognize the
standard functions and operators. But beyond that hack, there is no
mechanism other than search_path that determines what's visible or not.
regards, tom lane
* Tom Lane (tgl@sss.pgh.pa.us) wrote:
> Read the documentation for search_path: if pg_catalog isn't explicitly
> mentioned, we add it implicitly. This is mainly because it would be
> contrary to SQL spec (and pretty useless to boot) to not recognize the
> standard functions and operators. But beyond that hack, there is no
> mechanism other than search_path that determines what's visible or not.
Sorry, I didn't mean to imply I was completely oblivious to this. I
think I spoke a little too quickly and phrased it poorly.
It would be nice for an administrator to be able to implicitly add other
schemas to the search_path, primairly for functions but possibly other
things, because that way add-on modules like PostGIS could look more
like they're just part of PG. Another option might be to add things to
pg_catalog, but I suspect that's frowned upon with good reason.
Thanks,
Stephen
Stephen Frost <sfrost@snowman.net> writes:
> As I mentioned in my other email, this is mainly for PostGIS, but it can
> certainly apply to other modules. Is this what we would recommend as an
> approach for these kinds of modules? I feel like that would give
> -hackers, or perhaps the PostGIS people, some heartburn, but maybe I'm
> wrong?
If you have an idle evening you might want to peruse all the past
threads about developing better support for modules. This is clearly
an area where we need to improve, and it's also clear that no quick
hack is going to make it significantly better (in fact, it might make
things worse by creating extra compatibility issues when we do get
around to implementing a real solution).
The main argument against sticking stuff into pg_catalog is that
pg_dump will think it's a built-in and not dump it. In some respects
that could be a plus, but for the most part it's a headache.
regards, tom lane
Tom Lane escribió: > Stephen Frost <sfrost@snowman.net> writes: > > As I mentioned in my other email, this is mainly for PostGIS, but it can > > certainly apply to other modules. Is this what we would recommend as an > > approach for these kinds of modules? I feel like that would give > > -hackers, or perhaps the PostGIS people, some heartburn, but maybe I'm > > wrong? > > If you have an idle evening you might want to peruse all the past > threads about developing better support for modules. All the useful material in this area is linked to on the TODO list. -- Alvaro Herrera http://www.CommandPrompt.com/ PostgreSQL Replication, Consulting, Custom Development, 24x7 support
* Tom Lane (tgl@sss.pgh.pa.us) wrote:
> If you have an idle evening you might want to peruse all the past
> threads about developing better support for modules. This is clearly
> an area where we need to improve, and it's also clear that no quick
> hack is going to make it significantly better (in fact, it might make
> things worse by creating extra compatibility issues when we do get
> around to implementing a real solution).
I'll try and do that over the next few weeks, I recall seeing at least
some of those threads. Perhaps we can come up with a good approach to
improve module support for 8.5.
> The main argument against sticking stuff into pg_catalog is that
> pg_dump will think it's a built-in and not dump it. In some respects
> that could be a plus, but for the most part it's a headache.
Yeah, that issue did occur to me, though my plan for Debian on upgrades
was to try and filter out the PostGIS functions from the old database
and cleanly install them in the new database from scratch, which would
be more easily done if they're just not included in the old dump. On
the flip side, the support tables for PostGIS need to be migrated, so
something special would have to be done there if they were in
pg_catalog.
Thanks,
Stephen
Alvaro,
* Alvaro Herrera (alvherre@commandprompt.com) wrote:
> Tom Lane escribió:
> > If you have an idle evening you might want to peruse all the past
> > threads about developing better support for modules.
>
> All the useful material in this area is linked to on the TODO list.
Thanks for the pointer. I think PostGIS makes a very good test case for
anything new we come up with, both in terms of trying to not break
things too badly for their existing users, and in being a pretty complex
module that's rather popular. Suggestions on others?
Thanks,
Stephen
Tom, > Also (3) you are not actually going to use this as much as you think > you are, so saving a shift keypress is not the be-all and end-all. Clearly you've never had to troubleshoot a client's database which has over 400 functions they've never completely documented. --Josh
Josh Berkus wrote: > Tom, > >> Also (3) you are not actually going to use this as much as you think >> you are, so saving a shift keypress is not the be-all and end-all. > > Clearly you've never had to troubleshoot a client's database which has > over 400 functions they've never completely documented. Oh ... he above was just a comment, and NOT an argument for different syntax. Please let's end the discussion of this very small feature, and move on to things that deserve it, like SELinux and Hot standby? --Josh
On Thu, 2009-01-15 at 20:19 -0800, Josh Berkus wrote: > Tom, > > > Also (3) you are not actually going to use this as much as you think > > you are, so saving a shift keypress is not the be-all and end-all. > > Clearly you've never had to troubleshoot a client's database which has > over 400 functions they've never completely documented. I have and anyone who has come anywhere close to what we have knows this is useful on a significant level. Joshua D. Draek -- PostgreSQL - XMPP: jdrake@jabber.postgresql.org Consulting, Development, Support, Training 503-667-4564 - http://www.commandprompt.com/ The PostgreSQL Company, serving since 1997
Stephen Frost wrote: > Alvaro, > > * Alvaro Herrera (alvherre@commandprompt.com) wrote: >> Tom Lane escribió: >>> If you have an idle evening you might want to peruse all the past >>> threads about developing better support for modules. >> All the useful material in this area is linked to on the TODO list. > > Thanks for the pointer. I think PostGIS makes a very good test case for > anything new we come up with, both in terms of trying to not break > things too badly for their existing users, and in being a pretty complex > module that's rather popular. Suggestions on others? Contrib modules.. Like pgcrypto for example. tsearch2 used to be a great example of this, until it was integrated. //Magnus
Tom Lane <tgl@sss.pgh.pa.us> writes: > Well, as I said before, I'm not averse to having the default behavior > *with no pattern* to be that we omit system objects --- and I think we > could make that apply across the board. What I'm saying is that when > you give a pattern it should not matter whether an object is system or > user. It would go like this: > > \df -- all non-system functions > \df sin -- the active (visible) definition of sin() > \df sin* -- all visible functions starting with "sin" > > lesser used cases: > > \df * -- all visible functions > \df *.* -- all functions, period > \df pg_catalog.* -- all system functions > \df public.* -- all functions in public So it seems to me that we made \df consistent with \dt when in fact what we really wanted is for it to be consistent with \d. I hadn't actually realized that the behaviour for \d was so different from \dt myself. The behaviour of \dt in the face of tables which shadow system tables is actually even stranger: postgres=# create table pg_proc (t text); CREATE TABLE postgres=# commit; COMMIT postgres=# \dt pg_proc No matchingrelations found. And I don't see any reason aggregates, operators, etc, shouldn't be any more susceptible the shadowing problem. -- Gregory Stark EnterpriseDB http://www.enterprisedb.com Get trained by Bruce Momjian - ask me about EnterpriseDB'sPostgreSQL training!
Gregory Stark <stark@enterprisedb.com> writes:
> So it seems to me that we made \df consistent with \dt when in fact what we
> really wanted is for it to be consistent with \d. I hadn't actually realized
> that the behaviour for \d was so different from \dt myself.
Yeah, given that the battle cry for this patch was "let's make
everything consistent", it seems like some attention should be paid to
that.
I think that when everybody got tired of arguing yesterday, the last
idea left standing was
* revert \df to its former behavior, ie doesn't care if functions are system or user* \dfS will restrict the printout
tosystem functions* \dfU will restrict the printout to non-system functions
where "system function" means "it's in the pg_catalog schema".
(Presumably this means that "\dfS public.*" fails to print anything ...
is that okay?)
I suggest that we make all the \d commands work like that, including
\d and \dt.
One issue here is that plain \d gets less useful because it'll now
include system catalogs. We could add the additional rule that
the above statements apply only when a pattern is specified, and
without a pattern you get just user stuff (so omitting a pattern
corresponds to pattern "*" with the U modifier, not just "*").
This would probably make it a bit easier to have exactly the same
rules across the board.
Again, "\dfS" would be a bit useless, unless we say that the implicit
U modifier for no pattern doesn't override an explicit S modifier.
Comments? Does this cover all the cases?
regards, tom lane
On Jan 16, 2009, at 8:36 AM, Tom Lane wrote: > One issue here is that plain \d gets less useful because it'll now > include system catalogs. We could add the additional rule that > the above statements apply only when a pattern is specified, and > without a pattern you get just user stuff (so omitting a pattern > corresponds to pattern "*" with the U modifier, not just "*"). > This would probably make it a bit easier to have exactly the same > rules across the board. > > Again, "\dfS" would be a bit useless, unless we say that the implicit > U modifier for no pattern doesn't override an explicit S modifier. > > Comments? Does this cover all the cases? So would "\df" then be equivalent to "\dU"? Or am I misunderstanding something? David
On Fri, 2009-01-16 at 09:14 -0800, David E. Wheeler wrote: > On Jan 16, 2009, at 8:36 AM, Tom Lane wrote: > > > One issue here is that plain \d gets less useful because it'll now > > include system catalogs. We could add the additional rule that > > the above statements apply only when a pattern is specified, and > > without a pattern you get just user stuff (so omitting a pattern > > corresponds to pattern "*" with the U modifier, not just "*"). > > This would probably make it a bit easier to have exactly the same > > rules across the board. > > > > Again, "\dfS" would be a bit useless, unless we say that the implicit > > U modifier for no pattern doesn't override an explicit S modifier. > > > > Comments? Does this cover all the cases? > > So would "\df" then be equivalent to "\dU"? Or am I misunderstanding > something? \df would act as it does now. Showing you *everything*. Joshua D. Drake > > David > -- PostgreSQL - XMPP: jdrake@jabber.postgresql.org Consulting, Development, Support, Training 503-667-4564 - http://www.commandprompt.com/ The PostgreSQL Company, serving since 1997
"David E. Wheeler" <david@kineticode.com> writes:
> On Jan 16, 2009, at 8:36 AM, Tom Lane wrote:
>> Comments? Does this cover all the cases?
> So would "\df" then be equivalent to "\dU"? Or am I misunderstanding
> something?
You mean "\dfU"? Yes, if there's no pattern.
regards, tom lane
-----BEGIN PGP SIGNED MESSAGE-----
Hash: RIPEMD160
> One issue here is that plain \d gets less useful because it'll now
> include system catalogs.
Are you kidding me? No way. That's a recipe for making all our users
unhappy with us.
> * \dfU will restrict the printout to non-system functions
Sorry, but the "U" is ugly and unnecessary. The *default* should always
be user-defined functions, and to hide the internals. Hence, we have a
special flag for when you know what you are doing and want to see the system
information: "S".
I do agree that \d is not consistent with anything else, but let's not
throw the baby out with the bathwater. Or if we do, let's not have \d
show sequences either, because that part always annoyed me. :)
> Comments? Does this cover all the cases?
No: the user case someone had upthread, where they want to see all their
functions starting with an "a" across all schemas in their path:
\df a*
This should act similar to how \dt does right now:
\dt p*
Such that it shows only the user's functions, and only the user's tables.
99% of the time, people don't care about or want to see the 60+ internal
functions starting with "a", and the 40 or so internal tables
starting with "p".
I'm willing to concede some of the "\d.{1} objectname" behavior, but I don't
think we should mess at all with "\d" or "\dt" because people are used
to the current behavior, and its rather sane and useful (unlike \df)
- --
Greg Sabino Mullane greg@turnstep.com
End Point Corporation
PGP Key: 0x14964AC8 200901161234
http://biglumber.com/x/web?pk=2529DF6AB8F79407E94445B4BC9B906714964AC8
-----BEGIN PGP SIGNATURE-----
iEYEAREDAAYFAklwxXgACgkQvJuQZxSWSsgawACeMox6/RveSyvRJ4gpe/TiLSR3
YeYAoOBxy6IpTLdHYI40haMAgCebobLB
=Dj3a
-----END PGP SIGNATURE-----
On Jan 16, 2009, at 9:35 AM, Tom Lane wrote: >> So would "\df" then be equivalent to "\dU"? Or am I misunderstanding >> something? > > You mean "\dfU"? Yes, if there's no pattern. Yeah, that's what I meant. Thanks. +1. Best, David
"Joshua D. Drake" <jd@commandprompt.com> writes:
> On Fri, 2009-01-16 at 09:14 -0800, David E. Wheeler wrote:
>> On Jan 16, 2009, at 8:36 AM, Tom Lane wrote:
>>> One issue here is that plain \d gets less useful because it'll now
>>> include system catalogs. We could add the additional rule that
>>> the above statements apply only when a pattern is specified, and
>>> without a pattern you get just user stuff (so omitting a pattern
>>> corresponds to pattern "*" with the U modifier, not just "*").
>>> This would probably make it a bit easier to have exactly the same
>>> rules across the board.
>>>
>>> Again, "\dfS" would be a bit useless, unless we say that the implicit
>>> U modifier for no pattern doesn't override an explicit S modifier.
>>>
>>> Comments? Does this cover all the cases?
>>
>> So would "\df" then be equivalent to "\dU"? Or am I misunderstanding
>> something?
> \df would act as it does now. Showing you *everything*.
Which part of the quoted paragraph didn't you read?
regards, tom lane
On Fri, 2009-01-16 at 12:40 -0500, Tom Lane wrote: > "Joshua D. Drake" <jd@commandprompt.com> writes: > >>> Again, "\dfS" would be a bit useless, unless we say that the implicit > >>> U modifier for no pattern doesn't override an explicit S modifier. > >>> > >>> Comments? Does this cover all the cases? > >> > >> So would "\df" then be equivalent to "\dU"? Or am I misunderstanding > >> something? > > > \df would act as it does now. Showing you *everything*. > > Which part of the quoted paragraph didn't you read? Apparently at least part. Sorry for the noise. Sincerely, Joshua D. Drake > > regards, tom lane > -- PostgreSQL - XMPP: jdrake@jabber.postgresql.org Consulting, Development, Support, Training 503-667-4564 - http://www.commandprompt.com/ The PostgreSQL Company, serving since 1997
"Greg Sabino Mullane" <greg@turnstep.com> writes:
>> Comments? Does this cover all the cases?
> No: the user case someone had upthread, where they want to see all their
> functions starting with an "a" across all schemas in their path:
> \df a*
I think either "\dfU a*" or "\dfU *.a*" is a sufficiently close
approximation to that. The behavior you are asking for is essentially
"I want to pay attention to the search path, except not actually follow
its rules", which is bogus. Either you want to see the functions you
can call without schema qualification, or you want to see 'em all ---
it does no good whatsoever to lie about the visibility.
regards, tom lane
> One issue here is that plain \d gets less useful because it'll now > include system catalogs. We could add the additional rule that > the above statements apply only when a pattern is specified, and > without a pattern you get just user stuff (so omitting a pattern > corresponds to pattern "*" with the U modifier, not just "*"). > This would probably make it a bit easier to have exactly the same > rules across the board. Changing the scope of the search on the basis of whether or not a pattern is present strikes me as a terrible idea. It's confusing and unlikely to make anyone happy. ...Robert
Robert Haas <robertmhaas@gmail.com> writes:
> Changing the scope of the search on the basis of whether or not a
> pattern is present strikes me as a terrible idea. It's confusing and
> unlikely to make anyone happy.
Huh? The pattern itself "changes the scope of the search", so I don't
see how this is a conceptual violation.
Not that I'd personally be unhappy with dropping that part of the
proposal, but this doesn't seem like a good argument against it.
regards, tom lane
-----BEGIN PGP SIGNED MESSAGE----- Hash: RIPEMD160 > I think either "\dfU a*" or "\dfU *.a*" is a sufficiently close > approximation to that. The behavior you are asking for is essentially > "I want to pay attention to the search path, except not actually follow > its rules", which is bogus. Either you want to see the functions you > can call without schema qualification, or you want to see 'em all --- > it does no good whatsoever to lie about the visibility. But that's what \dt and \di and \dv have done since forever, and I've never heard a single complaint about it. - -- Greg Sabino Mullane greg@turnstep.com End Point Corporation PGP Key: 0x14964AC8 200901161321 http://biglumber.com/x/web?pk=2529DF6AB8F79407E94445B4BC9B906714964AC8 -----BEGIN PGP SIGNATURE----- iEYEAREDAAYFAklw0MwACgkQvJuQZxSWSsj5LQCeIl2j+/fT2v0G6aZ/0UnRcCVl xUoAnj1OBE8mPL9qJHxo+ETwWSHrfFJj =vtEm -----END PGP SIGNATURE-----
On Fri, Jan 16, 2009 at 1:09 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote: > Robert Haas <robertmhaas@gmail.com> writes: >> Changing the scope of the search on the basis of whether or not a >> pattern is present strikes me as a terrible idea. It's confusing and >> unlikely to make anyone happy. > > Huh? The pattern itself "changes the scope of the search", so I don't > see how this is a conceptual violation. > > Not that I'd personally be unhappy with dropping that part of the > proposal, but this doesn't seem like a good argument against it. I don't understand your confusion. You're once again proposing to have \df display only user functions, and \df <pattern> search both user and system functions. That doesn't seem remotely sane to me. Now I do "\df"and get a list of 30 functions, and that's more than I want to wade through so I do "\df a*" and get a list of 60 functions. Yuck! I feel pretty strongly that making the pattern search against a different list of stuff than what the same command would display without the pattern is confusing and a bad idea. It's a bad idea regardless of which particular backslash-sequence we're talking about.It doesn't work that way in 8.3.x, it doesn't workthat way in CVS HEAD, and it seems quite obvious it will confuse and annoy end-users. ...Robert
Robert Haas <robertmhaas@gmail.com> writes:
> I feel pretty strongly that making the pattern search against a
> different list of stuff than what the same command would display
> without the pattern is confusing and a bad idea. It's a bad idea
> regardless of which particular backslash-sequence we're talking about.
Well, I'm perfectly happy to drop that stipulation and just go with
\df -- all\dfS -- system only\dfU -- non-system only
but are we willing to change \d and \dt to work that way too?
Or should we leave them inconsistent?
regards, tom lane
On Fri, 2009-01-16 at 13:37 -0500, Tom Lane wrote: > Robert Haas <robertmhaas@gmail.com> writes: > > I feel pretty strongly that making the pattern search against a > > different list of stuff than what the same command would display > > without the pattern is confusing and a bad idea. It's a bad idea > > regardless of which particular backslash-sequence we're talking about. > > Well, I'm perfectly happy to drop that stipulation and just go with > > \df -- all > \dfS -- system only > \dfU -- non-system only > > but are we willing to change \d and \dt to work that way too? > Or should we leave them inconsistent? > I would prefer them consistent. Joshua D. Drake > regards, tom lane > -- PostgreSQL - XMPP: jdrake@jabber.postgresql.org Consulting, Development, Support, Training 503-667-4564 - http://www.commandprompt.com/ The PostgreSQL Company, serving since 1997
Tom Lane wrote: > Robert Haas <robertmhaas@gmail.com> writes: >> I feel pretty strongly that making the pattern search against a >> different list of stuff than what the same command would display >> without the pattern is confusing and a bad idea. It's a bad idea >> regardless of which particular backslash-sequence we're talking about. > > Well, I'm perfectly happy to drop that stipulation and just go with > > \df -- all > \dfS -- system only > \dfU -- non-system only > > but are we willing to change \d and \dt to work that way too? > Or should we leave them inconsistent? I think changing \dt would confuse the heck out of people. Far more than changing \df to be consistent with \dt would be. So my votes, in order of preference, are: 1) make \df consistent with \dt 2) leave them inconsistent --Josh
On Jan 16, 2009, at 10:43 AM, Joshua D. Drake wrote: >> \df -- all >> \dfS -- system only >> \dfU -- non-system only >> >> but are we willing to change \d and \dt to work that way too? >> Or should we leave them inconsistent? > > I would prefer them consistent. I think that people will hate the changed behavior to \d and \dt. Best, David
>>> Tom Lane <tgl@sss.pgh.pa.us> wrote: > Comments? Does this cover all the cases? I tend to think that changing which schemas are searched based on the presence or absence of a search pattern is a bad idea. Is the bare form (no U or S) going to search all schemas or the ones on the search path? Whatever the answer, do we need a way to get the other? +1 for consistency across all \d commands, even though I almost always want to see just the user objects. IMO it's worth the extra keystroke to be sure of what I'm seeing. -Kevin
"David E. Wheeler" <david@kineticode.com> writes:
> On Jan 16, 2009, at 10:43 AM, Joshua D. Drake wrote:
>>> but are we willing to change \d and \dt to work that way too?
>>> Or should we leave them inconsistent?
>>
>> I would prefer them consistent.
> I think that people will hate the changed behavior to \d and \dt.
Yeah, one of the advantages of the simpler proposal is that the behavior
of plain \df doesn't change from what it was, so there's no surprise
factor, just a couple of new options. But if we apply that same
behavior to \d and \dt then we do have a change in default behavior.
The point of "assume U for no pattern" was to preserve the default
behavior of those two commands.
Actually, now that I look at the code, the historical behavior of
\d is even weirder than I thought:
\d or \d+ *with no pattern* is equivalent to \dtvs(+) (and hence shows all user tables and no system tables)
\d or \d+ *with a pattern* takes a completely different code path that has no system-vs-user special behavior, ie
it'sabout like the historical \df behavior
which means that Robert's complaint about treating no-pattern
differently from pattern falls to the ground. It's exactly what
\d has done for years, and nobody has complained about that.
regards, tom lane
"Greg Sabino Mullane" <greg@turnstep.com> writes:
>> I think either "\dfU a*" or "\dfU *.a*" is a sufficiently close
>> approximation to that. The behavior you are asking for is essentially
>> "I want to pay attention to the search path, except not actually follow
>> its rules", which is bogus. Either you want to see the functions you
>> can call without schema qualification, or you want to see 'em all ---
>> it does no good whatsoever to lie about the visibility.
> But that's what \dt and \di and \dv have done since forever, and I've
> never heard a single complaint about it.
The reason it's not really an issue for those is that we still maintain
the convention that system catalogs have names beginning with "pg_",
and most people still avoid such names for user tables, and so there is
no conflict that search path order would matter for. With function
names there is no such standard and thus far greater risk of collisions.
It is a serious, serious error to suppose that behavior that is good
enough for tables (and in fact was designed before we had schemas...)
is also good enough for functions.
regards, tom lane
Tom, > which means that Robert's complaint about treating no-pattern > differently from pattern falls to the ground. It's exactly what > \d has done for years, and nobody has complained about that. Just because they haven't voiced loud complaints doesn't mean that they haven't been *confused* by it. I know that I've been confused by the behaviour of \d before, which is why I pretty much never use it. I think a search of -general and -newbie would be educational on the number of people who are confused by the shortcuts. Or, to put it another way, the fact that we screwed up in the past is hardly a justification to do it in the future. --Josh
On Fri, Jan 16, 2009 at 1:37 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote: > Robert Haas <robertmhaas@gmail.com> writes: >> I feel pretty strongly that making the pattern search against a >> different list of stuff than what the same command would display >> without the pattern is confusing and a bad idea. It's a bad idea >> regardless of which particular backslash-sequence we're talking about. > > Well, I'm perfectly happy to drop that stipulation and just go with > > \df -- all > \dfS -- system only > \dfU -- non-system only > > but are we willing to change \d and \dt to work that way too? > Or should we leave them inconsistent? I think you should make: \df - non-system only \dfS - system only \dfA - all Then you could make \dt the same way, and it wouldn't involve breaking the way \dt works now. ...Robert
Josh Berkus <josh@agliodbs.com> writes:
> Tom,
>> which means that Robert's complaint about treating no-pattern
>> differently from pattern falls to the ground. It's exactly what
>> \d has done for years, and nobody has complained about that.
> Just because they haven't voiced loud complaints doesn't mean that they
> haven't been *confused* by it. I know that I've been confused by the
> behaviour of \d before, which is why I pretty much never use it.
> I think a search of -general and -newbie would be educational on the
> number of people who are confused by the shortcuts.
> Or, to put it another way, the fact that we screwed up in the past is
> hardly a justification to do it in the future.
Well, the only reason for proposing the special case for no-pattern
was to provide some modicum of backward compatibility for \d and \dt.
If we want to decide that those are screwed up anyway and we should
make them work more like the other ones, that'd be okay with me.
But I have gotten the clear impression that such a proposal isn't
going to get majority support.
I think though that your confusion may come from an aspect of \d's
behavior that is more or less orthogonal to what we've been discussing:
without a pattern it equates to \dtvs, that is you get a summary
one-line-per-relation display of tables, views, and sequences; whereas
with a pattern it does something entirely different, to wit you get a
verbose display about each matching relation. Maybe we should
reconsider that bit; but it's a different argument from the one about
system vs user objects.
[ thinks a bit... ] One interesting idea is to go with the all/S/U
behavior for \dt, but to define bare "\d" as meaning "\dtvsU" not
just "\dtvs". That keeps backwards compatibility for that specific
case without introducing any conceptual inconsistency into the rest of
the command set.
regards, tom lane
> Actually, now that I look at the code, the historical behavior of > \d is even weirder than I thought: > > \d or \d+ *with no pattern* is equivalent to \dtvs(+) > (and hence shows all user tables and no system tables) > > \d or \d+ *with a pattern* takes a completely different > code path that has no system-vs-user special behavior, > ie it's about like the historical \df behavior > > which means that Robert's complaint about treating no-pattern > differently from pattern falls to the ground. It's exactly what > \d has done for years, and nobody has complained about that. Well, the behavior of \d with a pattern is almost totally useless right now. Probably no one is doing "\d a*" because it produces an obscene amount of output (or if you don't have more than one table with a, then pick some other letter). On the other hand "\dt a*" does something very nice that is just what you might expect. But you're right: my facts were wrong with respect to treating no-pattern differently than pattern. I don't think that makes the point invalid. I can't shake the feeling that this is about a couple of PostgreSQL hackers (yourself included) not wanting to type \dfS or \dfA or something to get the behavior they currently get with \df. If that's the case, come off it, because there's lots of evidence on this thread (and in all likelihood elsewhere) that this behavior is not what end-users want. Making \df only show user functions, and "\df <pattern>" only search user functions, is going to make a LOT of people happy (perhaps after 5 minutes of initial confusion). If it makes three developers unhappy, it's worth it - especially because the developers can easily add a switch, backslash command, environment variable setting, or whatever they want to still be able to have it the way they like it. By all means, add a setting that includes system stuff without having to type an extra letter - just don't make it the default. ...Robert
Robert Haas <robertmhaas@gmail.com> writes:
> I think you should make:
> \df - non-system only
> \dfS - system only
> \dfA - all
> Then you could make \dt the same way, and it wouldn't involve breaking
> the way \dt works now.
No, instead it would break \df. As I said before, a solution that was
designed for tables back around 6.4 isn't good enough for functions
in a schema world.
regards, tom lane
"Kevin Grittner" <Kevin.Grittner@wicourts.gov> writes:
> Is the bare form (no U or S) going to search all schemas or the ones
> on the search path? Whatever the answer, do we need a way to get the
> other?
The former, if you specify "*.*" (or "*.anything") as your pattern.
The latter, if you don't specify a schema qualifier in your pattern.
This already works and has since 7.3; I don't think we need to embed
any such semantics in the command names.
regards, tom lane
Robert Haas <robertmhaas@gmail.com> writes:
> I can't shake the feeling that this is about a couple
> of PostgreSQL hackers (yourself included) not wanting to type \dfS or
> \dfA or something to get the behavior they currently get with \df. If
> that's the case, come off it, because there's lots of evidence on this
> thread (and in all likelihood elsewhere) that this behavior is not
> what end-users want.
As was made clear at the beginning of the thread, that's what they
*think* they want, without any experience with a system that actually
behaves that way. And yes I do believe I know better, both from knowing
how the system works and from actual experience with the ill-considered
patch that's now in HEAD. I'm willing to provide a "U" modifier but
I think it will be a serious error to make that the default behavior.
regards, tom lane
On Fri, Jan 16, 2009 at 3:16 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote: > Robert Haas <robertmhaas@gmail.com> writes: >> I can't shake the feeling that this is about a couple >> of PostgreSQL hackers (yourself included) not wanting to type \dfS or >> \dfA or something to get the behavior they currently get with \df. If >> that's the case, come off it, because there's lots of evidence on this >> thread (and in all likelihood elsewhere) that this behavior is not >> what end-users want. > > As was made clear at the beginning of the thread, that's what they > *think* they want, without any experience with a system that actually > behaves that way. And yes I do believe I know better, both from knowing > how the system works and from actual experience with the ill-considered > patch that's now in HEAD. I'm willing to provide a "U" modifier but > I think it will be a serious error to make that the default behavior. 1. Providing the U modifier is a step in the right direction. 2. I agree that developers sometimes know better than users what users actually want. I have a pretty good track record there myself. 3. On this thread, we have you, Peter Eisentraut, and Heikki Linnakangas arguing for reverting the default behavior of \df, and we have (by my tally, apologies to anyone I've missed or misrepresented) Greg Sabino Mullane, Josh Berkus, Josh Drake, Greg Stark, David Fetter, Dmitri Fontaine, Stephen Frost, and myself expressing support for the change (with various differences of opinion on what other alternatives might not or might not be better). So in this case I think you don't know better. However, by my count, zero of the people who like the change are committers and all of the people who don't like it are, so we may be out of luck. :-) ...Robert
Gregory Stark wrote:
> The behaviour of \dt in the face of tables which shadow system tables is
> actually even stranger:
>
> postgres=# create table pg_proc (t text);
> CREATE TABLE
> postgres=# commit;
> COMMIT
> postgres=# \dt pg_proc
> No matching relations found.
>
>
> And I don't see any reason aggregates, operators, etc, shouldn't be any more
> susceptible the shadowing problem.
The inconsistency between \d and \dt is not defensible, and no one said
they liked it. Here is an example:
test=> \d pg_language
--> Table "pg_catalog.pg_language"
Column | Type | Modifiers
---------------+-----------+-----------
lanname | name | not null
lanowner | oid | not null
lanispl | boolean | not null
lanpltrusted | boolean | not null
lanplcallfoid | oid | not null
lanvalidator | oid | not null
lanacl | aclitem[] |
Indexes:
"pg_language_name_index" UNIQUE, btree (lanname)
"pg_language_oid_index" UNIQUE, btree (oid)
test=> \dt pg_language
--> No matching relations found.
As you can see, \d shows system tables, while \dt does not. The
attached patch makes \d and \dt consistent:
test=> \d pg_language
Did not find any relation named "pg_language".
test=> \dt pg_language
No matching relations found.
test=> \dS pg_language
Table "pg_catalog.pg_language"
Column | Type | Modifiers
---------------+-----------+-----------
lanname | name | not null
lanowner | oid | not null
lanispl | boolean | not null
lanpltrusted | boolean | not null
lanplcallfoid | oid | not null
lanvalidator | oid | not null
lanacl | aclitem[] |
Indexes:
"pg_language_name_index" UNIQUE, btree (lanname)
"pg_language_oid_index" UNIQUE, btree (oid)
test=> \dtS pg_language
List of relations
Schema | Name | Type | Owner
------------+-------------+-------+----------
pg_catalog | pg_language | table | postgres
(1 row)
In pre-8.4, 'S' was recognised only by \dt.
The other part of the patch shows system and _user_ tables when \dtS is
used, to be consistent with the rest of the \d* commands.
I know we don't like the current behavior, but I think we need to make
them consistent first for easy testing and so when we change it, it will
remain consistent.
Applied. I will work on a consensus patch soon for the new behavior.
--
Bruce Momjian <bruce@momjian.us> http://momjian.us
EnterpriseDB http://enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
Index: src/bin/psql/command.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/command.c,v
retrieving revision 1.201
diff -c -c -r1.201 command.c
*** src/bin/psql/command.c 6 Jan 2009 21:10:30 -0000 1.201
--- src/bin/psql/command.c 20 Jan 2009 02:02:17 -0000
***************
*** 334,347 ****
OT_NORMAL, NULL, true);
show_verbose = strchr(cmd, '+') ? true : false;
! show_system = strchr(cmd, 'S') ? true: false;
switch (cmd[1])
{
case '\0':
case '+':
if (pattern)
! success = describeTableDetails(pattern, show_verbose);
else
/* standard listing of interesting things */
success = listTables("tvs", NULL, show_verbose, show_system);
--- 334,348 ----
OT_NORMAL, NULL, true);
show_verbose = strchr(cmd, '+') ? true : false;
! show_system = strchr(cmd, 'S') ? true : false;
switch (cmd[1])
{
case '\0':
case '+':
+ case 'S':
if (pattern)
! success = describeTableDetails(pattern, show_verbose, show_system);
else
/* standard listing of interesting things */
success = listTables("tvs", NULL, show_verbose, show_system);
***************
*** 390,396 ****
case 'v':
case 'i':
case 's':
- case 'S':
success = listTables(&cmd[1], pattern, show_verbose, show_system);
break;
case 'u':
--- 391,396 ----
Index: src/bin/psql/describe.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/describe.c,v
retrieving revision 1.196
diff -c -c -r1.196 describe.c
*** src/bin/psql/describe.c 19 Jan 2009 18:44:32 -0000 1.196
--- src/bin/psql/describe.c 20 Jan 2009 02:02:17 -0000
***************
*** 782,788 ****
* verbose: if true, this is \d+
*/
bool
! describeTableDetails(const char *pattern, bool verbose)
{
PQExpBufferData buf;
PGresult *res;
--- 782,788 ----
* verbose: if true, this is \d+
*/
bool
! describeTableDetails(const char *pattern, bool verbose, bool showSystem)
{
PQExpBufferData buf;
PGresult *res;
***************
*** 797,803 ****
"FROM pg_catalog.pg_class c\n"
" LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n");
! processSQLNamePattern(pset.db, &buf, pattern, false, false,
"n.nspname", "c.relname", NULL,
"pg_catalog.pg_table_is_visible(c.oid)");
--- 797,806 ----
"FROM pg_catalog.pg_class c\n"
" LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n");
! if (!showSystem)
! appendPQExpBuffer(&buf, " WHERE n.nspname <> 'pg_catalog'\n");
!
! processSQLNamePattern(pset.db, &buf, pattern, !showSystem, false,
"n.nspname", "c.relname", NULL,
"pg_catalog.pg_table_is_visible(c.oid)");
***************
*** 1961,1980 ****
appendPQExpBuffer(&buf, "'i',");
if (showSeq)
appendPQExpBuffer(&buf, "'S',");
! if (showSystem && showTables)
appendPQExpBuffer(&buf, "'s',"); /* was RELKIND_SPECIAL in <= 8.1.X */
appendPQExpBuffer(&buf, "''"); /* dummy */
appendPQExpBuffer(&buf, ")\n");
! /*
! * If showSystem is specified, show only system objects (those in
! * pg_catalog). Otherwise, suppress system objects, including those in
! * pg_catalog and pg_toast. (We don't want to hide temp tables though.)
! */
! if (showSystem)
! appendPQExpBuffer(&buf,
! " AND n.nspname = 'pg_catalog'\n");
! else
appendPQExpBuffer(&buf,
" AND n.nspname <> 'pg_catalog'\n"
" AND n.nspname !~ '^pg_toast'\n");
--- 1964,1976 ----
appendPQExpBuffer(&buf, "'i',");
if (showSeq)
appendPQExpBuffer(&buf, "'S',");
! if (showSystem)
appendPQExpBuffer(&buf, "'s',"); /* was RELKIND_SPECIAL in <= 8.1.X */
appendPQExpBuffer(&buf, "''"); /* dummy */
appendPQExpBuffer(&buf, ")\n");
! if (!showSystem)
! /* Exclude system and pg_toast objects, but show temp tables */
appendPQExpBuffer(&buf,
" AND n.nspname <> 'pg_catalog'\n"
" AND n.nspname !~ '^pg_toast'\n");
Index: src/bin/psql/describe.h
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/describe.h,v
retrieving revision 1.38
diff -c -c -r1.38 describe.h
*** src/bin/psql/describe.h 6 Jan 2009 21:10:30 -0000 1.38
--- src/bin/psql/describe.h 20 Jan 2009 02:02:17 -0000
***************
*** 34,40 ****
extern bool objectDescription(const char *pattern, bool showSystem);
/* \d foo */
! extern bool describeTableDetails(const char *pattern, bool verbose);
/* \dF */
extern bool listTSConfigs(const char *pattern, bool verbose);
--- 34,40 ----
extern bool objectDescription(const char *pattern, bool showSystem);
/* \d foo */
! extern bool describeTableDetails(const char *pattern, bool verbose, bool showSystem);
/* \dF */
extern bool listTSConfigs(const char *pattern, bool verbose);
Bruce Momjian wrote:
> I know we don't like the current behavior, but I think we need to make
> them consistent first for easy testing and so when we change it, it will
> remain consistent.
>
> I will work on a consensus patch soon for the new behavior.
Here is what I hope is a consensus patch. It adds 'A' to show all
objects, including system ones. It turns out that this is how 'S' works
now in CVS, but 'S' is unclear because it suggests just system objects;
'A' for show 'all' objects seems clearer.
I did not add any special handling for patterns:
test=> \df repeat
List of functions
Schema | Name | Result data type | Argument data types
--------+------+------------------+---------------------
(0 rows)
test=> \dfA repeat
List of functions
Schema | Name | Result data type | Argument data types
------------+--------+------------------+---------------------
pg_catalog | repeat | text | text, integer
(1 row)
I am afraid that special pattern rules are going to be too confusing.
You can see only system objects by referencing pg_catalog:
test=> \dtA pg_catalog.pg_t*
List of relations
Schema | Name | Type | Owner
------------+------------------+-------+----------
pg_catalog | pg_tablespace | table | postgres
pg_catalog | pg_trigger | table | postgres
pg_catalog | pg_ts_config | table | postgres
pg_catalog | pg_ts_config_map | table | postgres
pg_catalog | pg_ts_dict | table | postgres
pg_catalog | pg_ts_parser | table | postgres
pg_catalog | pg_ts_template | table | postgres
pg_catalog | pg_type | table | postgres
(8 rows)
Patch attached. One interesting idea would be to assume 'A' if the
a schema is specified in the pattern, so;
\df pg_catalog.*
would work without 'A'.
With this patch, \d and \dt show only user tables, and \df shows only
user functions. I think usability-wise, these are good, and \dA, \dtA,
and \dfA include system tables and functions.
--
Bruce Momjian <bruce@momjian.us> http://momjian.us
EnterpriseDB http://enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
Index: doc/src/sgml/ref/psql-ref.sgml
===================================================================
RCS file: /cvsroot/pgsql/doc/src/sgml/ref/psql-ref.sgml,v
retrieving revision 1.218
diff -c -c -r1.218 psql-ref.sgml
*** doc/src/sgml/ref/psql-ref.sgml 20 Jan 2009 02:38:37 -0000 1.218
--- doc/src/sgml/ref/psql-ref.sgml 20 Jan 2009 03:54:20 -0000
***************
*** 833,840 ****
more information is displayed: any comments associated with the
columns of the table are shown, as is the presence of OIDs in the
table.
! The letter <literal>S</literal> adds the listing of system
! objects; without <literal>S</literal>, only non-system
objects are shown.
</para>
--- 833,840 ----
more information is displayed: any comments associated with the
columns of the table are shown, as is the presence of OIDs in the
table.
! The letter <literal>A</literal> adds the listing of system
! objects; without <literal>A</literal>, only non-system
objects are shown.
</para>
***************
*** 859,866 ****
return type and the data types they operate on. If <replaceable
class="parameter">pattern</replaceable>
is specified, only aggregates whose names match the pattern are shown.
! The letter <literal>S</literal> adds the listing of system
! objects; without <literal>S</literal>, only non-system
objects are shown.
</para>
</listitem>
--- 859,866 ----
return type and the data types they operate on. If <replaceable
class="parameter">pattern</replaceable>
is specified, only aggregates whose names match the pattern are shown.
! The letter <literal>A</literal> adds the listing of system
! objects; without <literal>A</literal>, only non-system
objects are shown.
</para>
</listitem>
***************
*** 890,897 ****
If <replaceable class="parameter">pattern</replaceable>
is specified, only conversions whose names match the pattern are
listed.
! The letter <literal>S</literal> adds the listing of system
! objects; without <literal>S</literal>, only non-system
objects are shown.
</para>
</listitem>
--- 890,897 ----
If <replaceable class="parameter">pattern</replaceable>
is specified, only conversions whose names match the pattern are
listed.
! The letter <literal>A</literal> adds the listing of system
! objects; without <literal>A</literal>, only non-system
objects are shown.
</para>
</listitem>
***************
*** 919,926 ****
class="parameter">pattern</replaceable>, or of all visible objects if
no argument is given. But in either case, only objects that have
a description are listed.
! The letter <literal>S</literal> adds the listing of system
! objects; without <literal>S</literal>, only non-system
objects are shown.
(<quote>Object</quote> covers aggregates, functions, operators,
types, relations (tables, views, indexes, sequences, large
--- 919,926 ----
class="parameter">pattern</replaceable>, or of all visible objects if
no argument is given. But in either case, only objects that have
a description are listed.
! The letter <literal>A</literal> adds the listing of system
! objects; without <literal>A</literal>, only non-system
objects are shown.
(<quote>Object</quote> covers aggregates, functions, operators,
types, relations (tables, views, indexes, sequences, large
***************
*** 951,958 ****
Lists all available domains. If <replaceable
class="parameter">pattern</replaceable>
is specified, only matching domains are shown.
! The letter <literal>S</literal> adds the listing of system
! objects; without <literal>S</literal>, only non-system
objects are shown.
</para>
</listitem>
--- 951,958 ----
Lists all available domains. If <replaceable
class="parameter">pattern</replaceable>
is specified, only matching domains are shown.
! The letter <literal>A</literal> adds the listing of system
! objects; without <literal>A</literal>, only non-system
objects are shown.
</para>
</listitem>
***************
*** 1025,1032 ****
is specified, only functions whose names match the pattern are shown.
If the form <literal>\df+</literal> is used, additional information about
each function, including volatility, language, source code and description, is shown.
! The letter <literal>S</literal> adds the listing of system
! objects; without <literal>S</literal>, only non-system
objects are shown.
</para>
--- 1025,1032 ----
is specified, only functions whose names match the pattern are shown.
If the form <literal>\df+</literal> is used, additional information about
each function, including volatility, language, source code and description, is shown.
! The letter <literal>A</literal> adds the listing of system
! objects; without <literal>A</literal>, only non-system
objects are shown.
</para>
***************
*** 1135,1142 ****
and tables. If <literal>+</literal> is
appended to the command name, each object is listed with its
physical size on disk and its associated description, if any.
! The letter <literal>S</literal> adds the listing of system
! objects; without <literal>S</literal>, only non-system
objects are shown.
</para>
--- 1135,1142 ----
and tables. If <literal>+</literal> is
appended to the command name, each object is listed with its
physical size on disk and its associated description, if any.
! The letter <literal>A</literal> adds the listing of system
! objects; without <literal>A</literal>, only non-system
objects are shown.
</para>
***************
*** 1182,1189 ****
Lists available operators with their operand and return types.
If <replaceable class="parameter">pattern</replaceable> is
specified, only operators whose names match the pattern are listed.
! The letter <literal>S</literal> adds the listing of system
! objects; without <literal>S</literal>, only non-system
objects are shown.
</para>
</listitem>
--- 1182,1189 ----
Lists available operators with their operand and return types.
If <replaceable class="parameter">pattern</replaceable> is
specified, only operators whose names match the pattern are listed.
! The letter <literal>A</literal> adds the listing of system
! objects; without <literal>A</literal>, only non-system
objects are shown.
</para>
</listitem>
***************
*** 1217,1224 ****
class="parameter">pattern</replaceable>. The command form
<literal>\dT+</literal> shows extra information, namely the type's internal name, size, and
allowed values for <type>enum</> types.
! The letter <literal>S</literal> adds the listing of system
! objects; without <literal>S</literal>, only non-system
objects are shown.
</para>
</listitem>
--- 1217,1224 ----
class="parameter">pattern</replaceable>. The command form
<literal>\dT+</literal> shows extra information, namely the type's internal name, size, and
allowed values for <type>enum</> types.
! The letter <literal>A</literal> adds the listing of system
! objects; without <literal>A</literal>, only non-system
objects are shown.
</para>
</listitem>
Index: src/bin/psql/command.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/command.c,v
retrieving revision 1.202
diff -c -c -r1.202 command.c
*** src/bin/psql/command.c 20 Jan 2009 02:13:42 -0000 1.202
--- src/bin/psql/command.c 20 Jan 2009 03:54:20 -0000
***************
*** 334,346 ****
OT_NORMAL, NULL, true);
show_verbose = strchr(cmd, '+') ? true : false;
! show_system = strchr(cmd, 'S') ? true : false;
switch (cmd[1])
{
case '\0':
case '+':
! case 'S':
if (pattern)
success = describeTableDetails(pattern, show_verbose, show_system);
else
--- 334,346 ----
OT_NORMAL, NULL, true);
show_verbose = strchr(cmd, '+') ? true : false;
! show_system = strchr(cmd, 'A') ? true : false;
switch (cmd[1])
{
case '\0':
case '+':
! case 'A':
if (pattern)
success = describeTableDetails(pattern, show_verbose, show_system);
else
Index: src/bin/psql/describe.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/describe.c,v
retrieving revision 1.197
diff -c -c -r1.197 describe.c
*** src/bin/psql/describe.c 20 Jan 2009 02:13:42 -0000 1.197
--- src/bin/psql/describe.c 20 Jan 2009 03:54:20 -0000
***************
*** 1007,1013 ****
schemaname, relationname);
break;
case 's':
! /* not used as of 8.2, but keep it for backwards compatibility */
printfPQExpBuffer(&title, _("Special relation \"%s.%s\""),
schemaname, relationname);
break;
--- 1007,1013 ----
schemaname, relationname);
break;
case 's':
! /* used in <= 8.1.X for special; keep for backward compatibility */
printfPQExpBuffer(&title, _("Special relation \"%s.%s\""),
schemaname, relationname);
break;
Index: src/bin/psql/help.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/help.c,v
retrieving revision 1.138
diff -c -c -r1.138 help.c
*** src/bin/psql/help.c 7 Jan 2009 03:05:26 -0000 1.138
--- src/bin/psql/help.c 20 Jan 2009 03:54:20 -0000
***************
*** 196,229 ****
fprintf(output, _("Informational\n"));
fprintf(output, _(" Modifiers: S = show system objects + = Additional detail\n"));
fprintf(output, _(" \\l[+] list all databases\n"));
! fprintf(output, _(" \\d[S+] list tables, views, and sequences\n"));
! fprintf(output, _(" \\d[S+] NAME describe table, view, sequence, or index\n"));
! fprintf(output, _(" \\da[S] [PATTERN] list aggregate functions\n"));
fprintf(output, _(" \\db[+] [PATTERN] list tablespaces\n"));
! fprintf(output, _(" \\dc[S] [PATTERN] list conversions\n"));
fprintf(output, _(" \\dC [PATTERN] list casts\n"));
! fprintf(output, _(" \\dd[S] [PATTERN] show comments on objects\n"));
! fprintf(output, _(" \\dD[S] [PATTERN] list domains\n"));
fprintf(output, _(" \\des[+] [PATTERN] list foreign servers\n"));
fprintf(output, _(" \\deu[+] [PATTERN] list user mappings\n"));
fprintf(output, _(" \\dew[+] [PATTERN] list foreign-data wrappers\n"));
! fprintf(output, _(" \\df[S+] [PATTERN] list functions\n"));
fprintf(output, _(" \\dF[+] [PATTERN] list text search configurations\n"));
fprintf(output, _(" \\dFd[+] [PATTERN] list text search dictionaries\n"));
fprintf(output, _(" \\dFp[+] [PATTERN] list text search parsers\n"));
fprintf(output, _(" \\dFt[+] [PATTERN] list text search templates\n"));
fprintf(output, _(" \\dg [PATTERN] list roles (groups)\n"));
! fprintf(output, _(" \\di[S+] [PATTERN] list indexes\n"));
fprintf(output, _(" \\dl list large objects, same as \\lo_list\n"));
fprintf(output, _(" \\dn[+] [PATTERN] list schemas\n"));
! fprintf(output, _(" \\do[S] [PATTERN] list operators\n"));
fprintf(output, _(" \\dp [PATTERN] list table, view, and sequence access privileges\n"));
fprintf(output, _(" \\z [PATTERN] same as \\dp\n"));
! fprintf(output, _(" \\ds[S+] [PATTERN] list sequences\n"));
! fprintf(output, _(" \\dt[S+] [PATTERN] list tables\n"));
! fprintf(output, _(" \\dT[S+] [PATTERN] list data types\n"));
fprintf(output, _(" \\du [PATTERN] list roles (users)\n"));
! fprintf(output, _(" \\dv[S+] [PATTERN] list views\n"));
fprintf(output, "\n");
fprintf(output, _("Formatting\n"));
--- 196,229 ----
fprintf(output, _("Informational\n"));
fprintf(output, _(" Modifiers: S = show system objects + = Additional detail\n"));
fprintf(output, _(" \\l[+] list all databases\n"));
! fprintf(output, _(" \\d[A+] list tables, views, and sequences\n"));
! fprintf(output, _(" \\d[A+] NAME describe table, view, sequence, or index\n"));
! fprintf(output, _(" \\da[A] [PATTERN] list aggregate functions\n"));
fprintf(output, _(" \\db[+] [PATTERN] list tablespaces\n"));
! fprintf(output, _(" \\dc[A] [PATTERN] list conversions\n"));
fprintf(output, _(" \\dC [PATTERN] list casts\n"));
! fprintf(output, _(" \\dd[A] [PATTERN] show comments on objects\n"));
! fprintf(output, _(" \\dD[A] [PATTERN] list domains\n"));
fprintf(output, _(" \\des[+] [PATTERN] list foreign servers\n"));
fprintf(output, _(" \\deu[+] [PATTERN] list user mappings\n"));
fprintf(output, _(" \\dew[+] [PATTERN] list foreign-data wrappers\n"));
! fprintf(output, _(" \\df[A+] [PATTERN] list functions\n"));
fprintf(output, _(" \\dF[+] [PATTERN] list text search configurations\n"));
fprintf(output, _(" \\dFd[+] [PATTERN] list text search dictionaries\n"));
fprintf(output, _(" \\dFp[+] [PATTERN] list text search parsers\n"));
fprintf(output, _(" \\dFt[+] [PATTERN] list text search templates\n"));
fprintf(output, _(" \\dg [PATTERN] list roles (groups)\n"));
! fprintf(output, _(" \\di[A+] [PATTERN] list indexes\n"));
fprintf(output, _(" \\dl list large objects, same as \\lo_list\n"));
fprintf(output, _(" \\dn[+] [PATTERN] list schemas\n"));
! fprintf(output, _(" \\do[A] [PATTERN] list operators\n"));
fprintf(output, _(" \\dp [PATTERN] list table, view, and sequence access privileges\n"));
fprintf(output, _(" \\z [PATTERN] same as \\dp\n"));
! fprintf(output, _(" \\ds[A+] [PATTERN] list sequences\n"));
! fprintf(output, _(" \\dt[A+] [PATTERN] list tables\n"));
! fprintf(output, _(" \\dT[A+] [PATTERN] list data types\n"));
fprintf(output, _(" \\du [PATTERN] list roles (users)\n"));
! fprintf(output, _(" \\dv[A+] [PATTERN] list views\n"));
fprintf(output, "\n");
fprintf(output, _("Formatting\n"));
> Here is what I hope is a consensus patch. It adds 'A' to show all > objects, including system ones. It turns out that this is how 'S' works > now in CVS, but 'S' is unclear because it suggests just system objects; > 'A' for show 'all' objects seems clearer. I think it's probably fine for "S" to mean "include system objects" rather than "show only system objects". Everyone should be relatively used to "S" by now; I think it's less confusing to keep the same letter even if the behavior has been adjusted somewhat. Though others may disagree? (Although this met with some earlier opposition, mostly from Tom IIRC, I still think it might be useful to have a setting to control which types of system objects are displayed by default: the setting could be interpreted as a list of characters X for which \dX would include system objects even without S. This would allow people who liked the old behavior to mostly recreate it.) ...Robert
Robert Haas wrote: > > Here is what I hope is a consensus patch. It adds 'A' to show all > > objects, including system ones. It turns out that this is how 'S' works > > now in CVS, but 'S' is unclear because it suggests just system objects; > > 'A' for show 'all' objects seems clearer. > > I think it's probably fine for "S" to mean "include system objects" > rather than "show only system objects". Everyone should be relatively > used to "S" by now; I think it's less confusing to keep the same > letter even if the behavior has been adjusted somewhat. Though others > may disagree? OK, so you are saying you like the behavior in current CVS, which uses 'S' as you described. In thinking last night, I am now wondering if a letter is really the right symbol for this. We already have letter flags which control object type selection, but the system table addition is kind of independent of those flags, like '+' now. I am thinking maybe '&' is the right symbol rather than 'A' or 'S'. \df and \df& '&' would stand for "and system objects". We could use '*' but that might be confused with a wildcard symbol. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
Bruce Momjian escribió: > In thinking last night, I am now wondering if a letter is really the > right symbol for this. We already have letter flags which control > object type selection, but the system table addition is kind of > independent of those flags, like '+' now. I am thinking maybe '&' is > the right symbol rather than 'A' or 'S'. & is probably going to be useful as a modifier when we have concurrent psql, so I suggest you do not use it here. Or maybe not, but in any case see http://archives.postgresql.org/message-id/8204.1207689056%40sss.pgh.pa.us before you use &. -- Alvaro Herrera http://www.CommandPrompt.com/ PostgreSQL Replication, Consulting, Custom Development, 24x7 support
-----BEGIN PGP SIGNED MESSAGE----- Hash: RIPEMD160 > In thinking last night, I am now wondering if a letter is really the > right symbol for this. We already have letter flags which control > object type selection, but the system table addition is kind of > independent of those flags, like '+' now. I am thinking maybe '&' is > the right symbol rather than 'A' or 'S'. What problem are we trying to solve here that is not already solved by using 'S' for system tables, which has been in use in psql for over a decade now? - -- Greg Sabino Mullane greg@turnstep.com End Point Corporation PGP Key: 0x14964AC8 200901201026 http://biglumber.com/x/web?pk=2529DF6AB8F79407E94445B4BC9B906714964AC8 -----BEGIN PGP SIGNATURE----- iEYEAREDAAYFAkl17psACgkQvJuQZxSWSsjdRACgoAJPOBsWYPf420KLl/7tuPTa By0AoORZBVnszD5SmGUpKvBHR7YFES7r =AILx -----END PGP SIGNATURE-----
Le mardi 20 janvier 2009, Bruce Momjian a écrit : > Robert Haas wrote: > > > Here is what I hope is a consensus patch. It adds 'A' to show all > > > objects, including system ones. It turns out that this is how 'S' > > > works now in CVS, but 'S' is unclear because it suggests just system > > > objects; 'A' for show 'all' objects seems clearer. > > > > I think it's probably fine for "S" to mean "include system objects" > > rather than "show only system objects". Everyone should be relatively > > used to "S" by now; I think it's less confusing to keep the same > > letter even if the behavior has been adjusted somewhat. Though others > > may disagree? I still think that given a pattern, psql commands should simply mimic whatever is the server way of using search_path. I'd really like \df foo and \d foo to follow the same rules as my production queries wrt to how to find objects when I'm too lazy to schema qualify their name. Now, it's been advocated for the sake of simplicity to have with-pattern and without-pattern options behave roughly the same way. I can't find it difficult to explain the two behaviours here, all the more when looking at current \d and \dt differences. What I'd like to propose is for \df without pattern to behave exactly like \df with pattern, *including* wrt to ordering the output. Functions listed in search_path order, pg_catalog implicitly part of it, but as its *last* element. Or whatever server object lookup code sayth. > '&' would stand for "and system objects". We could use '*' but that > might be confused with a wildcard symbol. If you insist on treating system object differently than server itself, I'd prefer for the client not to have me use well known non-alpha keys, which a lot of shells associate to e.g. jobs processing (bash, csh, lftp, some more I'm sure). Regards, -- dim
Bruce, * Bruce Momjian (bruce@momjian.us) wrote: > In thinking last night, I am now wondering if a letter is really the > right symbol for this. We already have letter flags which control > object type selection, but the system table addition is kind of > independent of those flags, like '+' now. I am thinking maybe '&' is > the right symbol rather than 'A' or 'S'. This really feels like over-engineering at this point. I don't particularly like '&', and 'S' has been in use like this for quite some time. Stephen
Alvaro Herrera wrote: > Bruce Momjian escribi?: > > > In thinking last night, I am now wondering if a letter is really the > > right symbol for this. We already have letter flags which control > > object type selection, but the system table addition is kind of > > independent of those flags, like '+' now. I am thinking maybe '&' is > > the right symbol rather than 'A' or 'S'. > > & is probably going to be useful as a modifier when we have concurrent > psql, so I suggest you do not use it here. Or maybe not, but in any > case see > http://archives.postgresql.org/message-id/8204.1207689056%40sss.pgh.pa.us > before you use &. Yea, I thought '&' might be coming for that someday. I figured it wouldn't be used for backslash commands, but why confuse things. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
Greg Sabino Mullane wrote: [ There is text before PGP section. ] > > -----BEGIN PGP SIGNED MESSAGE----- > Hash: RIPEMD160 > > > > In thinking last night, I am now wondering if a letter is really the > > right symbol for this. We already have letter flags which control > > object type selection, but the system table addition is kind of > > independent of those flags, like '+' now. I am thinking maybe '&' is > > the right symbol rather than 'A' or 'S'. > > What problem are we trying to solve here that is not already solved by > using 'S' for system tables, which has been in use in psql for over a > decade now? Well, the 'S' behavior used to be only system, now it is _add_ system. Anyway, 'S' is still probably the best choice. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
Dimitri Fontaine wrote: -- Start of PGP signed section. > Le mardi 20 janvier 2009, Bruce Momjian a ?crit?: > > Robert Haas wrote: > > > > Here is what I hope is a consensus patch. It adds 'A' to show all > > > > objects, including system ones. It turns out that this is how 'S' > > > > works now in CVS, but 'S' is unclear because it suggests just system > > > > objects; 'A' for show 'all' objects seems clearer. > > > > > > I think it's probably fine for "S" to mean "include system objects" > > > rather than "show only system objects". Everyone should be relatively > > > used to "S" by now; I think it's less confusing to keep the same > > > letter even if the behavior has been adjusted somewhat. Though others > > > may disagree? > > I still think that given a pattern, psql commands should simply mimic whatever > is the server way of using search_path. I'd really like \df foo and \d foo to > follow the same rules as my production queries wrt to how to find objects > when I'm too lazy to schema qualify their name. > > Now, it's been advocated for the sake of simplicity to have with-pattern and > without-pattern options behave roughly the same way. I can't find it > difficult to explain the two behaviours here, all the more when looking at > current \d and \dt differences. The \d and \dt differences are fixed/gone in current CVS. > What I'd like to propose is for \df without pattern to behave exactly like \df > with pattern, *including* wrt to ordering the output. Functions listed in > search_path order, pg_catalog implicitly part of it, but as its *last* > element. Or whatever server object lookup code sayth. I personally liked the idea of searching pg_catalog for a pattern, but what turned me against it was this behavior: \dlong list of user tables and then the user wants to see just the tables that begin with 'p': \d p*list of system and user tables that start with 'p' All of a sudden they see many system tables. It is hard to call that behavior logical or expected. One unusual approach would be to search pg_catalog only when a _non-wildcard_ pattern was supplied, so: \d p* would show user tables beginning with 'p', but: \d pg_class would find the 'pg_class' table that is the search path, typically from pg_catalog. It might be a little awkward to document, but might be the most acceptable solution. The very good argument _against_ this solution is that: \d pg_class* would show no rows while: \d pg_class would show the pg_catalog entry. This is also odd and unexpected, which led me to just having people use 'S' when they want pg_catalog involved. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
Bruce Momjian wrote: > Bruce Momjian wrote: >> I know we don't like the current behavior, but I think we need to make >> them consistent first for easy testing and so when we change it, it will >> remain consistent. >> >> I will work on a consensus patch soon for the new behavior. > The "\dXU *.*" commands also display objects from information_schema. IMHO these should also be classified as system objects. It is most annoying to run '\dfU *.*' and see a list of information_schema internal functions show up. Whereas the intent was to see the user defined functions in all schemas. regards, Martin
Martin Pihlak <martin.pihlak@gmail.com> writes: > Bruce Momjian wrote: >> Bruce Momjian wrote: >>> I know we don't like the current behavior, but I think we need to make >>> them consistent first for easy testing and so when we change it, it will >>> remain consistent. >>> >>> I will work on a consensus patch soon for the new behavior. >> > > The "\dXU *.*" commands also display objects from information_schema. IMHO > these should also be classified as system objects. It is most annoying to > run '\dfU *.*' and see a list of information_schema internal functions show up. > Whereas the intent was to see the user defined functions in all schemas. You know I think I've come around to agreeing with one of Tom's proposals. I think we should do the following: \dX : list user objects \dXS : list system objects \dX <pat> : list all matching objects based on search_path \dX *.* : list all objects in all schemas I've basically come to the conclusion that having the output agree with behaviour at run-time is a big advantage and anything else would actually be too dangerous. If you do something like "\dt p*" or "\df a*" and are annoyed by the output you just have to make your pattern something more specific. For tables we already prefix them all with pg_ so one more letter ought to be enough. For functions it would be nice if we could trim the output quite a bit. I wonder if we could rename all our internal functions which implement operators and indexam methods without introducing any backwards compatibility issues. We don't document things like "int4gt" after all. -- Gregory Stark EnterpriseDB http://www.enterprisedb.com Ask me about EnterpriseDB's PostGIS support!
On Friday 16 January 2009 04:09:11 Robert Haas wrote: > I really wonder what is so terrible about the behavrior as implemented > in CVS HEAD. AFAICS, no one except maybe Tom has really specified WHY > they don't like it, just that they don't like it. I'm not sure > whether that's because (1) it's different, and they're used to the old > way; (2) it involves typing an extra character to get the behavior > they want; or (3) there's no way to search user and system functions > simultaneously. Btw., the reason why I didn't like it is that hiding system tables is OK, because you never really interact with them, but hiding system functions is not, because you use those all the time. It has emerged, however, that some people appear to think of \df in terms of "what's available" and some in terms of "what have I done". And those call for different behaviors.
Peter Eisentraut wrote: > On Friday 16 January 2009 04:09:11 Robert Haas wrote: > > I really wonder what is so terrible about the behavrior as implemented > > in CVS HEAD. ?AFAICS, no one except maybe Tom has really specified WHY > > they don't like it, just that they don't like it. ?I'm not sure > > whether that's because (1) it's different, and they're used to the old > > way; (2) it involves typing an extra character to get the behavior > > they want; or (3) there's no way to search user and system functions > > simultaneously. > > Btw., the reason why I didn't like it is that hiding system tables is OK, > because you never really interact with them, but hiding system functions is > not, because you use those all the time. It has emerged, however, that some > people appear to think of \df in terms of "what's available" and some in > terms of "what have I done". And those call for different behaviors. Yep. I thought about what would be the ideal behavior of each backslash command that supports 'S'. Some \d commands are better with just user objects (\dt), while others are better including system objects (\dT), and some are unclear (\df). (You have to love that.) My feeling was to focus on the most used commands (\dt) and figure out how they would behave best, and let the others follow. Arguably the \dtisv are good in current CVS, while it is unclear if \df is better or worse than 8.3, and \dT is certainly worse than 8.3. But frankly, with a very complex backslash API that is already overloaded, I figured having a consistent 'S' to include system objects was the best we are going to be able to do. Once this is out in the field we might get new ideas. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
Bruce Momjian escribió: > But frankly, with a very complex backslash API that is already > overloaded, I figured having a consistent 'S' to include system objects > was the best we are going to be able to do. Once this is out in the > field we might get new ideas. I don't buy this argument. If we're going to break backwards compatibility we should only do so to get a better UI. Not because "we might get new ideas". After all this discussion, I'm not sure I understand why is it so important that all \ commands behave "consistently". Since psql is primarily a user-convenience tool, it seems that it needs to be usable first, consistent second. In most cases, usable means consistent (think having the OK button at the same side of the Cancel button in all dialog boxes), but this is one of the other cases, because the requirements for some situations are clearly at odds in other situations (or as Peter puts it: it is seldom useful to display pg_catalog tables, but it is very often useful to display pg_catalog types). -- Alvaro Herrera http://www.CommandPrompt.com/ PostgreSQL Replication, Consulting, Custom Development, 24x7 support
Alvaro Herrera wrote: > Bruce Momjian escribi?: > > > But frankly, with a very complex backslash API that is already > > overloaded, I figured having a consistent 'S' to include system objects > > was the best we are going to be able to do. Once this is out in the > > field we might get new ideas. > > I don't buy this argument. If we're going to break backwards > compatibility we should only do so to get a better UI. Not because "we > might get new ideas". > > After all this discussion, I'm not sure I understand why is it so > important that all \ commands behave "consistently". Since psql is > primarily a user-convenience tool, it seems that it needs to be usable > first, consistent second. In most cases, usable means consistent (think > having the OK button at the same side of the Cancel button in all dialog > boxes), but this is one of the other cases, because the requirements for > some situations are clearly at odds in other situations (or as Peter > puts it: it is seldom useful to display pg_catalog tables, but it is > very often useful to display pg_catalog types). Well, to do this you are going to need 'U' and 'S' modifiers, and then we have to decide how \df is supposed to behave. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
Bruce Momjian escribió: > Well, to do this you are going to need 'U' and 'S' modifiers, and then > we have to decide how \df is supposed to behave. I think we should have first decided how it was supposed to behave, and later applied any patches. -- Alvaro Herrera http://www.CommandPrompt.com/ PostgreSQL Replication, Consulting, Custom Development, 24x7 support
Alvaro Herrera wrote: > Bruce Momjian escribi?: > > > Well, to do this you are going to need 'U' and 'S' modifiers, and then > > we have to decide how \df is supposed to behave. > > I think we should have first decided how it was supposed to behave, and > later applied any patches. Well, there was a lot of discussion in the Spring that the backslash commands should be consistent, Greg Sabino Mullane went away to work on the patch, but didn't finish until my prodding in October, so I then applied it. \df seemed to be the hot item, and the rest just fell into place. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
Bruce Momjian escribió: > Alvaro Herrera wrote: > > Bruce Momjian escribi?: > > > > > Well, to do this you are going to need 'U' and 'S' modifiers, and then > > > we have to decide how \df is supposed to behave. > > > > I think we should have first decided how it was supposed to behave, and > > later applied any patches. > > Well, there was a lot of discussion in the Spring that the backslash > commands should be consistent, Yeah, apparently the idea that consistency is not necessarily the best guiding principle did not emerge until after the patch was applied :-( -- Alvaro Herrera http://www.CommandPrompt.com/ The PostgreSQL Company - Command Prompt, Inc.
Alvaro Herrera wrote:
> Bruce Momjian escribi?:
> > Alvaro Herrera wrote:
> > > Bruce Momjian escribi?:
> > >
> > > > Well, to do this you are going to need 'U' and 'S' modifiers, and then
> > > > we have to decide how \df is supposed to behave.
> > >
> > > I think we should have first decided how it was supposed to behave, and
> > > later applied any patches.
> >
> > Well, there was a lot of discussion in the Spring that the backslash
> > commands should be consistent,
>
> Yeah, apparently the idea that consistency is not necessarily the best
> guiding principle did not emerge until after the patch was applied :-(
You are seeing that too? ;-)
We certainly needed to get this into CVS so folks could test it, and
\d,\dt was so mangled in their behavior that only fixing it in CVS
allowed people to see a clear picture.
Here is the list we care about, from CVS HEAD:
Informational Modifiers: S = show system objects + = Additional detail \l[+] list all databases
\d[S+] list tables, views, and sequences \d[S+] NAME describe table, view, sequence, or index
\da[S] [PATTERN] list aggregate functions \db[+] [PATTERN] list tablespaces \dc[S] [PATTERN] list
conversions \dC [PATTERN] list casts \dd[S] [PATTERN] show comments on objects \dD[S] [PATTERN]
listdomains \des[+] [PATTERN] list foreign servers \deu[+] [PATTERN] list user mappings \dew[+] [PATTERN]
list foreign-data wrappers \df[S+] [PATTERN] list functions \dF[+] [PATTERN] list text search configurations
\dFd[+] [PATTERN] list text search dictionaries \dFp[+] [PATTERN] list text search parsers \dFt[+] [PATTERN]
list text search templates \dg [PATTERN] list roles (groups) \di[S+] [PATTERN] list indexes \dl
list large objects, same as \lo_list \dn[+] [PATTERN] list schemas \do[S] [PATTERN] list
operators \dp [PATTERN] list table, view, and sequence access privileges \z [PATTERN] same as \dp
\ds[S+] [PATTERN] list sequences \dt[S+] [PATTERN] list tables \dT[S+] [PATTERN] list data types \du
[PATTERN] list roles (users) \dv[S+] [PATTERN] list views
Here are the items I think are best to default to user-only:
\d[S+] list tables, views, and sequences \d[S+] NAME describe table, view, sequence, or
index \df[S+] [PATTERN] list functions \di[S+] [PATTERN] list indexes \ds[S+] [PATTERN] list sequences
\dt[S+] [PATTERN] list tables \dv[S+] [PATTERN] list views \dD[S] [PATTERN] list domains
Here are the ones that should include system objects by default:
\da[S] [PATTERN] list aggregate functions \dc[S] [PATTERN] list conversions \dd[S] [PATTERN] show
commentson objects \do[S] [PATTERN] list operators \dT[S+] [PATTERN] list data types
The lists are pretty close to being the same size, especially since \d
is listed twice.
You will notice some commands, like \dF, are not listed at all because
they don't support 'S'. One new idea would be to remove 'S' support
from the "include system" group and have them default to showing system
objects.
We could add a 'U' flag but that introduces confusion over whether the
command without 'S' or 'U' shows system objects, and would 'S' show only
system objects, or include system objects? And what about 'U'?
-- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB
http://enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
> Here are the items I think are best to default to user-only: [...] > Here are the ones that should include system objects by default: Well, at a minimum, I think it's important for any type of object to have an easy way to exclude system objects, because "show me all of the stuff that didn't come with the database" is a valid use case for any type of item. It's certainly true that the more obscure the item is, the more likely you are to be looking for the system object rather than a user object.But it's really subjective where to put the line: somepeople might put it between table and function (Tom), others might put it between function and aggregate (Bruce), and still others might say there's no object type so exotic that I don't want system objects excluded by default (me). And there isn't any right or wrong answer here: it's just opinions. So maybe we should provide U, S, and A modifiers for every type of object (user, system, all). That doesn't solve the problem of which should be the default for each object type, but at least it guarantees that you can type an extra character to get the behavior you want in any particular case. ...Robert
* Robert Haas (robertmhaas@gmail.com) wrote: > > Here are the items I think are best to default to user-only: > [...] > > Here are the ones that should include system objects by default: [...] > So maybe we should provide U, S, and A modifiers for every type of > object (user, system, all). That doesn't solve the problem of which > should be the default for each object type, but at least it guarantees > that you can type an extra character to get the behavior you want in > any particular case. You know, there's an easy answer to what to set the defaults to, though it might be a bit cheesy- how about the current behavior? Adding functionality (+U or +S or whatever) without breaking backwards compatibility (much). I'm not a huge fan of having \df still list system functions, but it's less of an issue if I can just do \dfU when I want. Of course, for a year or two I'll probably be cursing this thread whenver I pick the wrong one, but that's life. ;) In response to a comment earlier- I definitely like the idea of pre-pending system calls that aren't really 'published' with a 'pg_'. That probably raises some backwords compatability problems, but I still think it's a good idea to try and do at some point. Stephen
Bruce, et al,
* Bruce Momjian (bruce@momjian.us) wrote:
> \dg [PATTERN] list roles (groups)
> \du [PATTERN] list roles (users)
Seeing this list reminded me of a pet-peeve.. \du and \dg actually show
the same info, that's fine, but neither of them show the rolcanlogin
value. As someone who has a bad habit of doing 'create role blah;' for
new users this can get very annoying. I also have people complain to me
that they can't figure out why a new user can't log in after they did
the same thing. Could we get that changed? Or maybe have 'connections'
say something different when you don't have rolcanlogin besides 'no
limit'?
> \dp [PATTERN] list table, view, and sequence access privileges
erp, I don't think I changed this in my column-level privleges patch..
Should we explicitly mention column in this list?
Thanks,
Stephen
Stephen Frost <sfrost@snowman.net> writes:
> Seeing this list reminded me of a pet-peeve.. \du and \dg actually show
> the same info, that's fine, but neither of them show the rolcanlogin
> value.
+1 for fixing that.
>> \dp [PATTERN] list table, view, and sequence access privileges
> erp, I don't think I changed this in my column-level privleges patch..
> Should we explicitly mention column in this list?
No, I think it's good as-is. Adding column here would suggest that
columns are handled exactly parallel to tables, views, or sequences,
which of course isn't the case.
regards, tom lane
On 23 Jan 2009, at 00:03, Tom Lane wrote: > Stephen Frost <sfrost@snowman.net> writes: >> Seeing this list reminded me of a pet-peeve.. \du and \dg actually >> show >> the same info, that's fine, but neither of them show the rolcanlogin >> value. > > +1 for fixing that. was it that easy, or I got it wrong? :)
Attachment
On Sun, Feb 01, 2009 at 04:54:08AM +0000, Grzegorz Jaskiewicz wrote: > > On 23 Jan 2009, at 00:03, Tom Lane wrote: > >> Stephen Frost <sfrost@snowman.net> writes: >>> Seeing this list reminded me of a pet-peeve.. \du and \dg >>> actually show the same info, that's fine, but neither of them show >>> the rolcanlogin value. >> >> +1 for fixing that. > > was it that easy, or I got it wrong? > > :) I think Stephen meant that they should add a column to the output. Stephen? Cheers, David. -- David Fetter <david@fetter.org> http://fetter.org/ Phone: +1 415 235 3778 AIM: dfetter666 Yahoo!: dfetter Skype: davidfetter XMPP: david.fetter@gmail.com Remember to vote! Consider donating to Postgres: http://www.postgresql.org/about/donate
On 1 Feb 2009, at 10:58, David Fetter wrote: > > I think Stephen meant that they should add a column to the output. > Stephen? it's already there. try: psql -E \du ;]
On 1 Feb 2009, at 11:07, Grzegorz Jaskiewicz wrote: > > On 1 Feb 2009, at 10:58, David Fetter wrote: >> >> I think Stephen meant that they should add a column to the output. >> Stephen? > > it's already there. oh sorry, column - as in psql printout's column.... yeah, doable too - lemme see if I can do it.
* David Fetter (david@fetter.org) wrote: > On Sun, Feb 01, 2009 at 04:54:08AM +0000, Grzegorz Jaskiewicz wrote: > > On 23 Jan 2009, at 00:03, Tom Lane wrote: > >> Stephen Frost <sfrost@snowman.net> writes: > >>> Seeing this list reminded me of a pet-peeve.. \du and \dg > >>> actually show the same info, that's fine, but neither of them show > >>> the rolcanlogin value. > >> > >> +1 for fixing that. > > > > was it that easy, or I got it wrong? > > > > :) > > I think Stephen meant that they should add a column to the output. > Stephen? It was, but that was before the output-as-table changes were done. It looks like when those were committed, 'Cannot login' was added as an attribute. Having 'Can login' (as this patch proposes) seems reasonable to me. On a side note, I have to say that I'm not exactly thrilled with the new table-\du, especially since the List of roles isn't set up to break across lines cleanly. So if you have alot of roles granted, and even a couple attributes, it gets ugly.. Stephen
On 1 Feb 2009, at 14:21, Stephen Frost wrote: > > > So if you have alot of roles granted, and even a couple attributes, it > gets ugly.. true. I thought perhaps you guys want to go for table chart USER\t PERM1\t PERM2\t PERM3 foo\to\tx\tx\o bar\tx\to\to\x .... Personaly that would work for me, but that's probably the very argument the whole thread was devoted to.
Stephen Frost wrote: -- Start of PGP signed section. > * David Fetter (david@fetter.org) wrote: > > On Sun, Feb 01, 2009 at 04:54:08AM +0000, Grzegorz Jaskiewicz wrote: > > > On 23 Jan 2009, at 00:03, Tom Lane wrote: > > >> Stephen Frost <sfrost@snowman.net> writes: > > >>> Seeing this list reminded me of a pet-peeve.. \du and \dg > > >>> actually show the same info, that's fine, but neither of them show > > >>> the rolcanlogin value. > > >> > > >> +1 for fixing that. > > > > > > was it that easy, or I got it wrong? > > > > > > :) > > > > I think Stephen meant that they should add a column to the output. > > Stephen? > > It was, but that was before the output-as-table changes were done. It > looks like when those were committed, 'Cannot login' was added as an > attribute. Having 'Can login' (as this patch proposes) seems reasonable > to me. We only document non-default settings, which is why 'can login' was skipped, which I think is logical so I think the existing code is fine. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +
Stephen Frost wrote: -- Start of PGP signed section. > Bruce, et al, > > * Bruce Momjian (bruce@momjian.us) wrote: > > \dg [PATTERN] list roles (groups) > > \du [PATTERN] list roles (users) > > Seeing this list reminded me of a pet-peeve.. \du and \dg actually show > the same info, that's fine, but neither of them show the rolcanlogin > value. As someone who has a bad habit of doing 'create role blah;' for > new users this can get very annoying. I also have people complain to me > that they can't figure out why a new user can't log in after they did > the same thing. Could we get that changed? Or maybe have 'connections' > say something different when you don't have rolcanlogin besides 'no > limit'? \du/\dg shows the "Cannot login" specification, which I think is sufficient. -- Bruce Momjian <bruce@momjian.us> http://momjian.us EnterpriseDB http://enterprisedb.com + If your life is a hard drive, Christ can be your backup. +