rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
postgresql/src/backend/nodes/equalfuncs.c

3106 lines
69 KiB
C
Raw Normal View History

Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
/*-------------------------------------------------------------------------
*
Change my-function-name-- to my_function_name, and optimizer renames.
1999-02-14 00:22:53 +01:00
* equalfuncs.c
Add test code to copy all parse/plan trees. Repair essential omissions in copyfuncs and equalfuncs exposed by regression tests. We still have some work to do: these modules really ought to handle most or all of the utility statement node types. But it's better than it was.
2000-06-29 09:35:57 +02:00
* Equality functions to compare node trees.
*
Phase 1 of read-only-plans project: cause executor state nodes to point to plan nodes, not vice-versa. All executor state nodes now inherit from struct PlanState. Copying of plan trees has been simplified by not storing a list of SubPlans in Plan nodes (eliminating duplicate links). The executor still needs such a list, but it can build it during ExecutorStart since it has to scan the plan tree anyway. No initdb forced since no stored-on-disk structures changed, but you will need a full recompile because of node-numbering changes.
2002-12-05 16:50:39 +01:00
* NOTE: we currently support comparing all node types found in parse
* trees. We do not support comparing executor state trees; there
* is no need for that, and no point in maintaining all the code that
* would be needed. We also do not support comparing Path trees, mainly
* because the circular linkages between RelOptInfo and Path nodes can't
* be handled easily in a simple depth-first traversal.
Add test code to copy all parse/plan trees. Repair essential omissions in copyfuncs and equalfuncs exposed by regression tests. We still have some work to do: these modules really ought to handle most or all of the utility statement node types. But it's better than it was.
2000-06-29 09:35:57 +02:00
*
Phase 1 of read-only-plans project: cause executor state nodes to point to plan nodes, not vice-versa. All executor state nodes now inherit from struct PlanState. Copying of plan trees has been simplified by not storing a list of SubPlans in Plan nodes (eliminating duplicate links). The executor still needs such a list, but it can build it during ExecutorStart since it has to scan the plan tree anyway. No initdb forced since no stored-on-disk structures changed, but you will need a full recompile because of node-numbering changes.
2002-12-05 16:50:39 +01:00
* Currently, in fact, equal() doesn't know how to compare Plan trees
pgindent run.
2003-08-04 02:43:34 +02:00
* either. This might need to be fixed someday.
Add test code to copy all parse/plan trees. Repair essential omissions in copyfuncs and equalfuncs exposed by regression tests. We still have some work to do: these modules really ought to handle most or all of the utility statement node types. But it's better than it was.
2000-06-29 09:35:57 +02:00
*
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
* NOTE: it is intentional that parse location fields (in nodes that have
* one) are not compared. This is because we want, for example, a variable
* "x" to be considered equal() to another reference to "x" in the query.
*
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
*
Update copyright for 2014 Update all files in head, and files COPYRIGHT and legal.sgml in all back branches.
2014-01-07 22:05:30 +01:00
* Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group
Add: * Portions Copyright (c) 1996-2000, PostgreSQL, Inc to all files copyright Regents of Berkeley. Man, that's a lot of files.
2000-01-26 06:58:53 +01:00
* Portions Copyright (c) 1994, Regents of the University of California
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
*
* IDENTIFICATION
Remove cvs keywords from all files.
2010-09-20 22:08:53 +02:00
* src/backend/nodes/equalfuncs.c
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
*
*-------------------------------------------------------------------------
*/
include sem.h added, include string.h neede, from Erik Bertelsen for Ultrix
1997-01-10 21:19:49 +01:00
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
#include "postgres.h"
Final cleanup.
1999-07-16 07:00:38 +02:00
#include "nodes/relation.h"
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
#include "utils/datum.h"
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
/*
pgindent run.
2003-08-04 02:43:34 +02:00
* Macros to simplify comparison of different kinds of fields. Use these
* wherever possible to reduce the chance for silly typos. Note that these
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
* hard-wire the convention that the local variables in an Equal routine are
* named 'a' and 'b'.
*/
/* Compare a simple scalar field (int, float, bool, enum, etc) */
#define COMPARE_SCALAR_FIELD(fldname) \
do { \
if (a->fldname != b->fldname) \
return false; \
} while (0)
/* Compare a field that is a pointer to some kind of Node or Node tree */
#define COMPARE_NODE_FIELD(fldname) \
do { \
if (!equal(a->fldname, b->fldname)) \
return false; \
} while (0)
Replace planner's representation of relation sets, per pghackers discussion. Instead of Lists of integers, we now store variable-length bitmap sets. This should be faster as well as less error-prone.
2003-02-08 21:20:55 +01:00
/* Compare a field that is a pointer to a Bitmapset */
#define COMPARE_BITMAPSET_FIELD(fldname) \
do { \
if (!bms_equal(a->fldname, b->fldname)) \
return false; \
} while (0)
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
/* Compare a field that is a pointer to a C string, or perhaps NULL */
#define COMPARE_STRING_FIELD(fldname) \
do { \
if (!equalstr(a->fldname, b->fldname)) \
return false; \
} while (0)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
/* Macro for comparing string fields that might be NULL */
pgindent run. Make it all clean.
2001-03-22 05:01:46 +01:00
#define equalstr(a, b) \
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
(((a) != NULL && (b) != NULL) ? (strcmp(a, b) == 0) : (a) == (b))
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
/* Compare a field that is a pointer to a simple palloc'd object of size sz */
#define COMPARE_POINTER_FIELD(fldname, sz) \
do { \
if (memcmp(a->fldname, b->fldname, (sz)) != 0) \
return false; \
} while (0)
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
/* Compare a parse location field (this is a no-op, per note above) */
#define COMPARE_LOCATION_FIELD(fldname) \
((void) 0)
Make equal() ignore CoercionForm fields for better planning with casts. This change ensures that the planner will see implicit and explicit casts as equivalent for all purposes, except in the minority of cases where there's actually a semantic difference (as reflected by having a 3-argument cast function). In particular, this fixes cases where the EquivalenceClass machinery failed to consider two references to a varchar column as equivalent if one was implicitly cast to text but the other was explicitly cast to text, as seen in bug #7598 from Vaclav Juza. We have had similar bugs before in other parts of the planner, so I think it's time to fix this problem at the core instead of continuing to band-aid around it. Remove set_coercionform_dontcare(), which represents the band-aid previously in use for allowing matching of index and constraint expressions with inconsistent cast labeling. (We can probably get rid of COERCE_DONTCARE altogether, but I don't think removing that enum value in back branches would be wise; it's possible there's third party code referring to it.) Back-patch to 9.2. We could go back further, and might want to once this has been tested more; but for the moment I won't risk destabilizing plan choices in long-since-stable branches.
2012-10-12 18:10:49 +02:00
/* Compare a CoercionForm field (also a no-op, per comment in primnodes.h) */
#define COMPARE_COERCIONFORM_FIELD(fldname) \
((void) 0)
Add equal() funcs for Case nodes ... amazing we had not detected this omission before. Miscellaneous other cleanups.
1999-07-29 04:45:36 +02:00
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 07:04:48 +02:00
* Stuff from primnodes.h
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
*/
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlias(const Alias *a, const Alias *b)
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
{
COMPARE_STRING_FIELD(aliasname);
COMPARE_NODE_FIELD(colnames);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalRangeVar(const RangeVar *a, const RangeVar *b)
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
{
COMPARE_STRING_FIELD(catalogname);
COMPARE_STRING_FIELD(schemaname);
COMPARE_STRING_FIELD(relname);
COMPARE_SCALAR_FIELD(inhOpt);
Generalize concept of temporary relations to "relation persistence". This commit replaces pg_class.relistemp with pg_class.relpersistence; and also modifies the RangeVar node type to carry relpersistence rather than istemp. It also removes removes rd_istemp from RelationData and instead performs the correct computation based on relpersistence. For clarity, we add three new macros: RelationNeedsWAL(), RelationUsesLocalBuffers(), and RelationUsesTempNamespace(), so that we can clarify the purpose of each check that previous depended on rd_istemp. This is intended as infrastructure for the upcoming unlogged tables patch, as well as for future possible work on global temporary tables.
2010-12-13 18:34:26 +01:00
COMPARE_SCALAR_FIELD(relpersistence);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(alias);
Add a bunch of new error location reports to parse-analysis error messages. There are still some weak spots around JOIN USING and relation alias lists, but most errors reported within backend/parser/ now have locations.
2008-09-01 22:42:46 +02:00
COMPARE_LOCATION_FIELD(location);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 07:04:48 +02:00
Renaming cleanup, no pgindent yet.
1998-09-01 05:29:17 +02:00
return true;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
}
Remove the Query structure from the executor's API. This allows us to stop storing mostly-redundant Query trees in prepared statements, portals, etc. To replace Query, a new node type called PlannedStmt is inserted by the planner at the top of a completed plan tree; this carries just the fields of Query that are still needed at runtime. The statement lists kept in portals etc. now consist of intermixed PlannedStmt and bare utility-statement nodes --- no Query. This incidentally allows us to remove some fields from Query and Plan nodes that shouldn't have been there in the first place. Still to do: simplify the execution-time range table; at the moment the range table passed to the executor still contains Query trees for subqueries. initdb forced due to change of stored rules.
2007-02-20 18:32:18 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalIntoClause(const IntoClause *a, const IntoClause *b)
Remove the Query structure from the executor's API. This allows us to stop storing mostly-redundant Query trees in prepared statements, portals, etc. To replace Query, a new node type called PlannedStmt is inserted by the planner at the top of a completed plan tree; this carries just the fields of Query that are still needed at runtime. The statement lists kept in portals etc. now consist of intermixed PlannedStmt and bare utility-statement nodes --- no Query. This incidentally allows us to remove some fields from Query and Plan nodes that shouldn't have been there in the first place. Still to do: simplify the execution-time range table; at the moment the range table passed to the executor still contains Query trees for subqueries. initdb forced due to change of stored rules.
2007-02-20 18:32:18 +01:00
{
COMPARE_NODE_FIELD(rel);
COMPARE_NODE_FIELD(colNames);
COMPARE_NODE_FIELD(options);
COMPARE_SCALAR_FIELD(onCommit);
COMPARE_STRING_FIELD(tableSpaceName);
Clean up the mess around EXPLAIN and materialized views. Revert the matview-related changes in explain.c's API, as per recent complaint from Robert Haas. The reason for these appears to have been principally some ill-considered choices around having intorel_startup do what ought to be parse-time checking, plus a poor arrangement for passing it the view parsetree it needs to store into pg_rewrite when creating a materialized view. Do the latter by having parse analysis stick a copy into the IntoClause, instead of doing it at runtime. (On the whole, I seriously question the choice to represent CREATE MATERIALIZED VIEW as a variant of SELECT INTO/CREATE TABLE AS, because that means injecting even more complexity into what was already a horrid legacy kluge. However, I didn't go so far as to rethink that choice ... yet.) I also moved several error checks into matview parse analysis, and made the check for external Params in a matview more accurate. In passing, clean things up a bit more around interpretOidsOption(), and fix things so that we can use that to force no-oids for views, sequences, etc, thereby eliminating the need to cons up "oids = false" options when creating them. catversion bump due to change in IntoClause. (I wonder though if we really need readfuncs/outfuncs support for IntoClause anymore.)
2013-04-13 01:25:20 +02:00
COMPARE_NODE_FIELD(viewQuery);
Fix unsupported options in CREATE TABLE ... AS EXECUTE. The WITH [NO] DATA option was not supported, nor the ability to specify replacement column names; the former limitation wasn't even documented, as per recent complaint from Naoya Anzai. Fix by moving the responsibility for supporting these options into the executor. It actually takes less code this way ... catversion bump due to change in representation of IntoClause, which might affect stored rules.
2011-11-25 05:21:06 +01:00
COMPARE_SCALAR_FIELD(skipData);
Remove the Query structure from the executor's API. This allows us to stop storing mostly-redundant Query trees in prepared statements, portals, etc. To replace Query, a new node type called PlannedStmt is inserted by the planner at the top of a completed plan tree; this carries just the fields of Query that are still needed at runtime. The statement lists kept in portals etc. now consist of intermixed PlannedStmt and bare utility-statement nodes --- no Query. This incidentally allows us to remove some fields from Query and Plan nodes that shouldn't have been there in the first place. Still to do: simplify the execution-time range table; at the moment the range table passed to the executor still contains Query trees for subqueries. initdb forced due to change of stored rules.
2007-02-20 18:32:18 +01:00
return true;
}
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
/*
* We don't need an _equalExpr because Expr is an abstract supertype which
pgindent run.
2003-08-04 02:43:34 +02:00
* should never actually get instantiated. Also, since it has no common
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
* fields except NodeTag, there's no need for a helper routine to factor
* out comparing the common fields...
*/
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalVar(const Var *a, const Var *b)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(varno);
COMPARE_SCALAR_FIELD(varattno);
COMPARE_SCALAR_FIELD(vartype);
COMPARE_SCALAR_FIELD(vartypmod);
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
COMPARE_SCALAR_FIELD(varcollid);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(varlevelsup);
COMPARE_SCALAR_FIELD(varnoold);
COMPARE_SCALAR_FIELD(varoattno);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 07:04:48 +02:00
Renaming cleanup, no pgindent yet.
1998-09-01 05:29:17 +02:00
return true;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
}
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalConst(const Const *a, const Const *b)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(consttype);
Fix up the remaining places where the expression node structure would lose available information about the typmod of an expression; namely, Const, ArrayRef, ArrayExpr, and EXPR and ARRAY SubLinks. In the ArrayExpr and SubLink cases it wasn't really the data structure's fault, but exprTypmod() being lazy. This seems like a good idea in view of the expected increase in typmod usage from Teodor's work to allow user-defined types to have typmods. In particular this responds to the concerns we had about eliminating the special-purpose hack that exprTypmod() used to have for BPCHAR Consts. We can now tell whether or not such a Const has been cast to a specific length, and report or display properly if so. initdb forced due to changes in stored rules.
2007-03-17 01:11:05 +01:00
COMPARE_SCALAR_FIELD(consttypmod);
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
COMPARE_SCALAR_FIELD(constcollid);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(constlen);
COMPARE_SCALAR_FIELD(constisnull);
COMPARE_SCALAR_FIELD(constbyval);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 19:17:23 +02:00
Clean up handling of explicit NULL constants. Cases like SELECT null::text; SELECT int4fac(null); work as expected now. In some cases a NULL must be surrounded by parentheses: SELECT 2 + null; fails SELECT 2 + (null); OK This is a grammatical ambiguity that seems difficult to avoid. Other than that, NULLs seem to behave about like you'd expect. The internal implementation is that NULL constants are typed as UNKNOWN (like untyped string constants) until the parser can deduce the right type.
1999-12-24 07:43:34 +01:00
/*
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 19:17:23 +02:00
* We treat all NULL constants of the same type as equal. Someday this
Standard pgindent run for 8.1.
2005-10-15 04:49:52 +02:00
* might need to change? But datumIsEqual doesn't work on nulls, so...
Clean up handling of explicit NULL constants. Cases like SELECT null::text; SELECT int4fac(null); work as expected now. In some cases a NULL must be surrounded by parentheses: SELECT 2 + null; fails SELECT 2 + (null); OK This is a grammatical ambiguity that seems difficult to avoid. Other than that, NULLs seem to behave about like you'd expect. The internal implementation is that NULL constants are typed as UNKNOWN (like untyped string constants) until the parser can deduce the right type.
1999-12-24 07:43:34 +01:00
*/
if (a->constisnull)
return true;
First stage of reclaiming memory in executor by resetting short-term memory contexts. Currently, only leaks in expressions executed as quals or projections are handled. Clean up some old dead cruft in executor while at it --- unused fields in state nodes, that sort of thing.
2000-07-12 04:37:39 +02:00
return datumIsEqual(a->constvalue, b->constvalue,
a->constbyval, a->constlen);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
}
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalParam(const Param *a, const Param *b)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(paramkind);
Simplify ParamListInfo data structure to support only numbered parameters, not named ones, and replace linear searches of the list with array indexing. The named-parameter support has been dead code for many years anyway, and recent profiling suggests that the searching was costing a noticeable amount of performance for complex queries.
2006-04-22 03:26:01 +02:00
COMPARE_SCALAR_FIELD(paramid);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(paramtype);
Add a paramtypmod field to Param nodes. This is dead weight for Params representing externally-supplied values, since the APIs that carry such values only specify type not typmod. However, for PARAM_SUBLINK Params it is handy to carry the typmod of the sublink's output column. This is a much cleaner solution for the recently reported 'could not find pathkey item to sort' and 'failed to find unique expression in subplan tlist' bugs than my original 8.2-compatible patch. Besides, someday we might want to support typmods for external parameters ...
2006-12-10 23:13:27 +01:00
COMPARE_SCALAR_FIELD(paramtypmod);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(paramcollid);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 07:04:48 +02:00
Renaming cleanup, no pgindent yet.
1998-09-01 05:29:17 +02:00
return true;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
}
Add equal() funcs for Case nodes ... amazing we had not detected this omission before. Miscellaneous other cleanups.
1999-07-29 04:45:36 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAggref(const Aggref *a, const Aggref *b)
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
{
COMPARE_SCALAR_FIELD(aggfnoid);
COMPARE_SCALAR_FIELD(aggtype);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(aggcollid);
COMPARE_SCALAR_FIELD(inputcollid);
Support ordered-set (WITHIN GROUP) aggregates. This patch introduces generic support for ordered-set and hypothetical-set aggregate functions, as well as implementations of the instances defined in SQL:2008 (percentile_cont(), percentile_disc(), rank(), dense_rank(), percent_rank(), cume_dist()). We also added mode() though it is not in the spec, as well as versions of percentile_cont() and percentile_disc() that can compute multiple percentile values in one pass over the data. Unlike the original submission, this patch puts full control of the sorting process in the hands of the aggregate's support functions. To allow the support functions to find out how they're supposed to sort, a new API function AggGetAggref() is added to nodeAgg.c. This allows retrieval of the aggregate call's Aggref node, which may have other uses beyond the immediate need. There is also support for ordered-set aggregates to install cleanup callback functions, so that they can be sure that infrastructure such as tuplesort objects gets cleaned up. In passing, make some fixes in the recently-added support for variadic aggregates, and make some editorial adjustments in the recent FILTER additions for aggregates. Also, simplify use of IsBinaryCoercible() by allowing it to succeed whenever the target type is ANY or ANYELEMENT. It was inconsistent that it dealt with other polymorphic target types but not these. Atri Sharma and Andrew Gierth; reviewed by Pavel Stehule and Vik Fearing, and rather heavily editorialized upon by Tom Lane
2013-12-23 22:11:35 +01:00
COMPARE_NODE_FIELD(aggdirectargs);
Aggregate functions now support multiple input arguments. I also took the opportunity to treat COUNT(*) as a zero-argument aggregate instead of the old hack that equated it to COUNT(1); this is materially cleaner (no more weird ANYOID cases) and ought to be at least a tiny bit faster. Original patch by Sergey Koposov; review, documentation, simple regression tests, pg_dump and psql support by moi.
2006-07-27 21:52:07 +02:00
COMPARE_NODE_FIELD(args);
Support ORDER BY within aggregate function calls, at long last providing a non-kluge method for controlling the order in which values are fed to an aggregate function. At the same time eliminate the old implementation restriction that DISTINCT was only supported for single-argument aggregates. Possibly release-notable behavioral change: formerly, agg(DISTINCT x) dropped null values of x unconditionally. Now, it does so only if the agg transition function is strict; otherwise nulls are treated as DISTINCT normally would, ie, you get one copy. Andrew Gierth, reviewed by Hitoshi Harada
2009-12-15 18:57:48 +01:00
COMPARE_NODE_FIELD(aggorder);
COMPARE_NODE_FIELD(aggdistinct);
Implement the FILTER clause for aggregate function calls. This is SQL-standard with a few extensions, namely support for subqueries and outer references in clause expressions. catversion bump due to change in Aggref and WindowFunc. David Fetter, reviewed by Dean Rasheed.
2013-07-17 02:15:36 +02:00
COMPARE_NODE_FIELD(aggfilter);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_SCALAR_FIELD(aggstar);
Allow aggregate functions to be VARIADIC. There's no inherent reason why an aggregate function can't be variadic (even VARIADIC ANY) if its transition function can handle the case. Indeed, this patch to add the feature touches none of the planner or executor, and little of the parser; the main missing stuff was DDL and pg_dump support. It is true that variadic aggregates can create the same sort of ambiguity about parameters versus ORDER BY keys that was complained of when we (briefly) had both one- and two-argument forms of string_agg(). However, the policy formed in response to that discussion only said that we'd not create any built-in aggregates with varying numbers of arguments, not that we shouldn't allow users to do it. So the logical extension of that is we can allow users to make variadic aggregates as long as we're wary about shipping any such in core. In passing, this patch allows aggregate function arguments to be named, to the extent of remembering the names in pg_proc and dumping them in pg_dump. You can't yet call an aggregate using named-parameter notation. That seems like a likely future extension, but it'll take some work, and it's not what this patch is really about. Likewise, there's still some work needed to make window functions handle VARIADIC fully, but I left that for another day. initdb forced because of new aggvariadic field in Aggref parse nodes.
2013-09-03 23:08:38 +02:00
COMPARE_SCALAR_FIELD(aggvariadic);
Support ordered-set (WITHIN GROUP) aggregates. This patch introduces generic support for ordered-set and hypothetical-set aggregate functions, as well as implementations of the instances defined in SQL:2008 (percentile_cont(), percentile_disc(), rank(), dense_rank(), percent_rank(), cume_dist()). We also added mode() though it is not in the spec, as well as versions of percentile_cont() and percentile_disc() that can compute multiple percentile values in one pass over the data. Unlike the original submission, this patch puts full control of the sorting process in the hands of the aggregate's support functions. To allow the support functions to find out how they're supposed to sort, a new API function AggGetAggref() is added to nodeAgg.c. This allows retrieval of the aggregate call's Aggref node, which may have other uses beyond the immediate need. There is also support for ordered-set aggregates to install cleanup callback functions, so that they can be sure that infrastructure such as tuplesort objects gets cleaned up. In passing, make some fixes in the recently-added support for variadic aggregates, and make some editorial adjustments in the recent FILTER additions for aggregates. Also, simplify use of IsBinaryCoercible() by allowing it to succeed whenever the target type is ANY or ANYELEMENT. It was inconsistent that it dealt with other polymorphic target types but not these. Atri Sharma and Andrew Gierth; reviewed by Pavel Stehule and Vik Fearing, and rather heavily editorialized upon by Tom Lane
2013-12-23 22:11:35 +01:00
COMPARE_SCALAR_FIELD(aggkind);
Support ORDER BY within aggregate function calls, at long last providing a non-kluge method for controlling the order in which values are fed to an aggregate function. At the same time eliminate the old implementation restriction that DISTINCT was only supported for single-argument aggregates. Possibly release-notable behavioral change: formerly, agg(DISTINCT x) dropped null values of x unconditionally. Now, it does so only if the agg transition function is strict; otherwise nulls are treated as DISTINCT normally would, ie, you get one copy. Andrew Gierth, reviewed by Hitoshi Harada
2009-12-15 18:57:48 +01:00
COMPARE_SCALAR_FIELD(agglevelsup);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
return true;
}
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalWindowFunc(const WindowFunc *a, const WindowFunc *b)
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
{
COMPARE_SCALAR_FIELD(winfnoid);
COMPARE_SCALAR_FIELD(wintype);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(wincollid);
COMPARE_SCALAR_FIELD(inputcollid);
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
COMPARE_NODE_FIELD(args);
Implement the FILTER clause for aggregate function calls. This is SQL-standard with a few extensions, namely support for subqueries and outer references in clause expressions. catversion bump due to change in Aggref and WindowFunc. David Fetter, reviewed by Dean Rasheed.
2013-07-17 02:15:36 +02:00
COMPARE_NODE_FIELD(aggfilter);
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
COMPARE_SCALAR_FIELD(winref);
COMPARE_SCALAR_FIELD(winstar);
COMPARE_SCALAR_FIELD(winagg);
COMPARE_LOCATION_FIELD(location);
return true;
}
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalArrayRef(const ArrayRef *a, const ArrayRef *b)
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
{
First phase of work on array improvements. ARRAY[x,y,z] constructor expressions, ARRAY(sub-SELECT) expressions, some array functions. Polymorphic functions using ANYARRAY/ANYELEMENT argument and return types. Some regression tests in place, documentation is lacking. Joe Conway, with some kibitzing from Tom Lane.
2003-04-09 01:20:04 +02:00
COMPARE_SCALAR_FIELD(refarraytype);
COMPARE_SCALAR_FIELD(refelemtype);
Fix up the remaining places where the expression node structure would lose available information about the typmod of an expression; namely, Const, ArrayRef, ArrayExpr, and EXPR and ARRAY SubLinks. In the ArrayExpr and SubLink cases it wasn't really the data structure's fault, but exprTypmod() being lazy. This seems like a good idea in view of the expected increase in typmod usage from Teodor's work to allow user-defined types to have typmods. In particular this responds to the concerns we had about eliminating the special-purpose hack that exprTypmod() used to have for BPCHAR Consts. We can now tell whether or not such a Const has been cast to a specific length, and report or display properly if so. initdb forced due to changes in stored rules.
2007-03-17 01:11:05 +01:00
COMPARE_SCALAR_FIELD(reftypmod);
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
COMPARE_SCALAR_FIELD(refcollid);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_NODE_FIELD(refupperindexpr);
COMPARE_NODE_FIELD(reflowerindexpr);
COMPARE_NODE_FIELD(refexpr);
COMPARE_NODE_FIELD(refassgnexpr);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalFuncExpr(const FuncExpr *a, const FuncExpr *b)
Add equal() funcs for Case nodes ... amazing we had not detected this omission before. Miscellaneous other cleanups.
1999-07-29 04:45:36 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(funcid);
COMPARE_SCALAR_FIELD(funcresulttype);
COMPARE_SCALAR_FIELD(funcretset);
Add infrastructure for storing a VARIADIC ANY function's VARIADIC flag. Originally we didn't bother to mark FuncExprs with any indication whether VARIADIC had been given in the source text, because there didn't seem to be any need for it at runtime. However, because we cannot fold a VARIADIC ANY function's arguments into an array (since they're not necessarily all the same type), we do actually need that information at runtime if VARIADIC ANY functions are to respond unsurprisingly to use of the VARIADIC keyword. Add the missing field, and also fix ruleutils.c so that VARIADIC ANY function calls are dumped properly. Extracted from a larger patch that also fixes concat() and format() (the only two extant VARIADIC ANY functions) to behave properly when VARIADIC is specified. This portion seems appropriate to review and commit separately. Pavel Stehule
2013-01-22 02:25:26 +01:00
COMPARE_SCALAR_FIELD(funcvariadic);
Make equal() ignore CoercionForm fields for better planning with casts. This change ensures that the planner will see implicit and explicit casts as equivalent for all purposes, except in the minority of cases where there's actually a semantic difference (as reflected by having a 3-argument cast function). In particular, this fixes cases where the EquivalenceClass machinery failed to consider two references to a varchar column as equivalent if one was implicitly cast to text but the other was explicitly cast to text, as seen in bug #7598 from Vaclav Juza. We have had similar bugs before in other parts of the planner, so I think it's time to fix this problem at the core instead of continuing to band-aid around it. Remove set_coercionform_dontcare(), which represents the band-aid previously in use for allowing matching of index and constraint expressions with inconsistent cast labeling. (We can probably get rid of COERCE_DONTCARE altogether, but I don't think removing that enum value in back branches would be wise; it's possible there's third party code referring to it.) Back-patch to 9.2. We could go back further, and might want to once this has been tested more; but for the moment I won't risk destabilizing plan choices in long-since-stable branches.
2012-10-12 18:10:49 +02:00
COMPARE_COERCIONFORM_FIELD(funcformat);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(funccollid);
COMPARE_SCALAR_FIELD(inputcollid);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_NODE_FIELD(args);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Add equal() funcs for Case nodes ... amazing we had not detected this omission before. Miscellaneous other cleanups.
1999-07-29 04:45:36 +02:00
return true;
}
Support use of function argument names to identify which actual arguments match which function parameters. The syntax uses AS, for example funcname(value AS arg1, anothervalue AS arg2) Pavel Stehule
2009-10-08 04:39:25 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalNamedArgExpr(const NamedArgExpr *a, const NamedArgExpr *b)
Support use of function argument names to identify which actual arguments match which function parameters. The syntax uses AS, for example funcname(value AS arg1, anothervalue AS arg2) Pavel Stehule
2009-10-08 04:39:25 +02:00
{
COMPARE_NODE_FIELD(arg);
COMPARE_STRING_FIELD(name);
COMPARE_SCALAR_FIELD(argnumber);
COMPARE_LOCATION_FIELD(location);
return true;
}
equal() needs a case for Aggref nodes, as shown by: regression=> select sum(q1) from int8_tbl group by q2 order by sum(q1); NOTICE: equal: don't know whether nodes of type 107 are equal
1999-06-06 19:46:40 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalOpExpr(const OpExpr *a, const OpExpr *b)
equal() needs a case for Aggref nodes, as shown by: regression=> select sum(q1) from int8_tbl group by q2 order by sum(q1); NOTICE: equal: don't know whether nodes of type 107 are equal
1999-06-06 19:46:40 +02:00
{
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_SCALAR_FIELD(opno);
pgindent run.
2003-08-04 02:43:34 +02:00
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
/*
pgindent run.
2003-08-04 02:43:34 +02:00
* Special-case opfuncid: it is allowable for it to differ if one node
Standard pgindent run for 8.1.
2005-10-15 04:49:52 +02:00
* contains zero and the other doesn't. This just means that the one node
* isn't as far along in the parse/plan pipeline and hasn't had the
* opfuncid cache filled yet.
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
*/
if (a->opfuncid != b->opfuncid &&
a->opfuncid != 0 &&
b->opfuncid != 0)
return false;
COMPARE_SCALAR_FIELD(opresulttype);
COMPARE_SCALAR_FIELD(opretset);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(opcollid);
COMPARE_SCALAR_FIELD(inputcollid);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_NODE_FIELD(args);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDistinctExpr(const DistinctExpr *a, const DistinctExpr *b)
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
{
COMPARE_SCALAR_FIELD(opno);
pgindent run.
2003-08-04 02:43:34 +02:00
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
/*
pgindent run.
2003-08-04 02:43:34 +02:00
* Special-case opfuncid: it is allowable for it to differ if one node
Standard pgindent run for 8.1.
2005-10-15 04:49:52 +02:00
* contains zero and the other doesn't. This just means that the one node
* isn't as far along in the parse/plan pipeline and hasn't had the
* opfuncid cache filled yet.
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
*/
if (a->opfuncid != b->opfuncid &&
a->opfuncid != 0 &&
b->opfuncid != 0)
return false;
COMPARE_SCALAR_FIELD(opresulttype);
COMPARE_SCALAR_FIELD(opretset);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(opcollid);
COMPARE_SCALAR_FIELD(inputcollid);
COMPARE_NODE_FIELD(args);
COMPARE_LOCATION_FIELD(location);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalNullIfExpr(const NullIfExpr *a, const NullIfExpr *b)
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
{
COMPARE_SCALAR_FIELD(opno);
/*
* Special-case opfuncid: it is allowable for it to differ if one node
* contains zero and the other doesn't. This just means that the one node
* isn't as far along in the parse/plan pipeline and hasn't had the
* opfuncid cache filled yet.
*/
if (a->opfuncid != b->opfuncid &&
a->opfuncid != 0 &&
b->opfuncid != 0)
return false;
COMPARE_SCALAR_FIELD(opresulttype);
COMPARE_SCALAR_FIELD(opretset);
COMPARE_SCALAR_FIELD(opcollid);
COMPARE_SCALAR_FIELD(inputcollid);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_NODE_FIELD(args);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
return true;
}
Support expressions of the form 'scalar op ANY (array)' and 'scalar op ALL (array)', where the operator is applied between the lefthand scalar and each element of the array. The operator must yield boolean; the result of the construct is the OR or AND of the per-element results, respectively. Original coding by Joe Conway, after an idea of Peter's. Rewritten by Tom to keep the implementation strictly separate from subqueries.
2003-06-29 02:33:44 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalScalarArrayOpExpr(const ScalarArrayOpExpr *a, const ScalarArrayOpExpr *b)
Support expressions of the form 'scalar op ANY (array)' and 'scalar op ALL (array)', where the operator is applied between the lefthand scalar and each element of the array. The operator must yield boolean; the result of the construct is the OR or AND of the per-element results, respectively. Original coding by Joe Conway, after an idea of Peter's. Rewritten by Tom to keep the implementation strictly separate from subqueries.
2003-06-29 02:33:44 +02:00
{
COMPARE_SCALAR_FIELD(opno);
pgindent run.
2003-08-04 02:43:34 +02:00
Support expressions of the form 'scalar op ANY (array)' and 'scalar op ALL (array)', where the operator is applied between the lefthand scalar and each element of the array. The operator must yield boolean; the result of the construct is the OR or AND of the per-element results, respectively. Original coding by Joe Conway, after an idea of Peter's. Rewritten by Tom to keep the implementation strictly separate from subqueries.
2003-06-29 02:33:44 +02:00
/*
pgindent run.
2003-08-04 02:43:34 +02:00
* Special-case opfuncid: it is allowable for it to differ if one node
Standard pgindent run for 8.1.
2005-10-15 04:49:52 +02:00
* contains zero and the other doesn't. This just means that the one node
* isn't as far along in the parse/plan pipeline and hasn't had the
* opfuncid cache filled yet.
Support expressions of the form 'scalar op ANY (array)' and 'scalar op ALL (array)', where the operator is applied between the lefthand scalar and each element of the array. The operator must yield boolean; the result of the construct is the OR or AND of the per-element results, respectively. Original coding by Joe Conway, after an idea of Peter's. Rewritten by Tom to keep the implementation strictly separate from subqueries.
2003-06-29 02:33:44 +02:00
*/
if (a->opfuncid != b->opfuncid &&
a->opfuncid != 0 &&
b->opfuncid != 0)
return false;
COMPARE_SCALAR_FIELD(useOr);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(inputcollid);
Support expressions of the form 'scalar op ANY (array)' and 'scalar op ALL (array)', where the operator is applied between the lefthand scalar and each element of the array. The operator must yield boolean; the result of the construct is the OR or AND of the per-element results, respectively. Original coding by Joe Conway, after an idea of Peter's. Rewritten by Tom to keep the implementation strictly separate from subqueries.
2003-06-29 02:33:44 +02:00
COMPARE_NODE_FIELD(args);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Support expressions of the form 'scalar op ANY (array)' and 'scalar op ALL (array)', where the operator is applied between the lefthand scalar and each element of the array. The operator must yield boolean; the result of the construct is the OR or AND of the per-element results, respectively. Original coding by Joe Conway, after an idea of Peter's. Rewritten by Tom to keep the implementation strictly separate from subqueries.
2003-06-29 02:33:44 +02:00
return true;
}
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalBoolExpr(const BoolExpr *a, const BoolExpr *b)
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
{
COMPARE_SCALAR_FIELD(boolop);
COMPARE_NODE_FIELD(args);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
equal() needs a case for Aggref nodes, as shown by: regression=> select sum(q1) from int8_tbl group by q2 order by sum(q1); NOTICE: equal: don't know whether nodes of type 107 are equal
1999-06-06 19:46:40 +02:00
return true;
}
Implement constant-expression simplification per Bernard Frankpitt, plus some improvements from yours truly. The simplifier depends on the proiscachable field of pg_proc to tell it whether a function is safe to pre-evaluate --- things like nextval() are not, for example. Update pg_proc.h to contain reasonable cacheability information; as of 6.5.* hardly any functions were marked cacheable. I may have erred too far in the other direction; see recent mail to pghackers for more info. This update does not force an initdb, exactly, but you won't see much benefit from the simplifier until you do one.
1999-09-26 04:28:44 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalSubLink(const SubLink *a, const SubLink *b)
Implement constant-expression simplification per Bernard Frankpitt, plus some improvements from yours truly. The simplifier depends on the proiscachable field of pg_proc to tell it whether a function is safe to pre-evaluate --- things like nextval() are not, for example. Update pg_proc.h to contain reasonable cacheability information; as of 6.5.* hardly any functions were marked cacheable. I may have erred too far in the other direction; see recent mail to pghackers for more info. This update does not force an initdb, exactly, but you won't see much benefit from the simplifier until you do one.
1999-09-26 04:28:44 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(subLinkType);
Implement SQL-compliant treatment of row comparisons for < <= > >= cases (previously we only did = and <> correctly). Also, allow row comparisons with any operators that are in btree opclasses, not only those with these specific names. This gets rid of a whole lot of indefensible assumptions about the behavior of particular operators based on their names ... though it's still true that IN and NOT IN expand to "= ANY". The patch adds a RowCompareExpr expression node type, and makes some changes in the representation of ANY/ALL/ROWCOMPARE SubLinks so that they can share code with RowCompareExpr. I have not yet done anything about making RowCompareExpr an indexable operator, but will look at that soon. initdb forced due to changes in stored rules.
2005-12-28 02:30:02 +01:00
COMPARE_NODE_FIELD(testexpr);
Further tweaking of parsetree & plantree representation of SubLinks. Simplify SubLink by storing just a List of operator OIDs, instead of a list of incomplete OpExprs --- that was a bizarre and bulky choice, with no redeeming social value since we have to build new OpExprs anyway when forming the plan tree.
2003-01-10 22:08:15 +01:00
COMPARE_NODE_FIELD(operName);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(subselect);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Implement constant-expression simplification per Bernard Frankpitt, plus some improvements from yours truly. The simplifier depends on the proiscachable field of pg_proc to tell it whether a function is safe to pre-evaluate --- things like nextval() are not, for example. Update pg_proc.h to contain reasonable cacheability information; as of 6.5.* hardly any functions were marked cacheable. I may have erred too far in the other direction; see recent mail to pghackers for more info. This update does not force an initdb, exactly, but you won't see much benefit from the simplifier until you do one.
1999-09-26 04:28:44 +02:00
Modify array operations to include array's element type OID in the array header, and to compute sizing and alignment of array elements the same way normal tuple access operations do --- viz, using the tupmacs.h macros att_addlength and att_align. This makes the world safe for arrays of cstrings or intervals, and should make it much easier to write array-type-polymorphic functions; as examples see the cleanups of array_out and contrib/array_iterator. By Joe Conway and Tom Lane.
2002-08-26 19:54:02 +02:00
return true;
First cut at full support for OUTER JOINs. There are still a few loose ends to clean up (see my message of same date to pghackers), but mostly it works. INITDB REQUIRED!
2000-09-12 23:07:18 +02:00
}
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalSubPlan(const SubPlan *a, const SubPlan *b)
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
{
Clean up plantree representation of SubPlan-s --- SubLink does not appear in the planned representation of a subplan at all any more, only SubPlan. This means subselect.c doesn't scribble on its input anymore, which seems like a good thing; and there are no longer three different possible interpretations of a SubLink. Simplify node naming and improve comments in primnodes.h. No change to stored rules, though.
2002-12-14 01:17:59 +01:00
COMPARE_SCALAR_FIELD(subLinkType);
Implement SQL-compliant treatment of row comparisons for < <= > >= cases (previously we only did = and <> correctly). Also, allow row comparisons with any operators that are in btree opclasses, not only those with these specific names. This gets rid of a whole lot of indefensible assumptions about the behavior of particular operators based on their names ... though it's still true that IN and NOT IN expand to "= ANY". The patch adds a RowCompareExpr expression node type, and makes some changes in the representation of ANY/ALL/ROWCOMPARE SubLinks so that they can share code with RowCompareExpr. I have not yet done anything about making RowCompareExpr an indexable operator, but will look at that soon. initdb forced due to changes in stored rules.
2005-12-28 02:30:02 +01:00
COMPARE_NODE_FIELD(testexpr);
Reimplement the linked list data structure used throughout the backend. In the past, we used a 'Lispy' linked list implementation: a "list" was merely a pointer to the head node of the list. The problem with that design is that it makes lappend() and length() linear time. This patch fixes that problem (and others) by maintaining a count of the list length and a pointer to the tail node along with each head node pointer. A "list" is now a pointer to a structure containing some meta-data about the list; the head and tail pointers in that structure refer to ListCell structures that maintain the actual linked list of nodes. The function names of the list API have also been changed to, I hope, be more logically consistent. By default, the old function names are still available; they will be disabled-by-default once the rest of the tree has been updated to use the new API names.
2004-05-26 06:41:50 +02:00
COMPARE_NODE_FIELD(paramIds);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_SCALAR_FIELD(plan_id);
Change EXPLAIN output so that subplans and initplans (particularly CTEs) are individually labeled, rather than just grouped under an "InitPlan" or "SubPlan" heading. This in turn makes it possible for decompilation of a subplan reference to usefully identify which subplan it's referencing. I also made InitPlans identify which parameter symbol(s) they compute, so that references to those parameters elsewhere in the plan tree can be connected to the initplan that will be executed. Per a gripe from Robert Haas about EXPLAIN output of a WITH query being inadequate, plus some longstanding pet peeves of my own.
2009-04-05 21:59:40 +02:00
COMPARE_STRING_FIELD(plan_name);
Turn the rangetable used by the executor into a flat list, and avoid storing useless substructure for its RangeTblEntry nodes. (I chose to keep using the same struct node type and just zero out the link fields for unneeded info, rather than making a separate ExecRangeTblEntry type --- it seemed too fragile to have two different rangetable representations.) Along the way, put subplans into a list in the toplevel PlannedStmt node, and have SubPlan nodes refer to them by list index instead of direct pointers. Vadim wanted to do that years ago, but I never understood what he was on about until now. It makes things a *whole* lot more robust, because we can stop worrying about duplicate processing of subplans during expression tree traversals. That's been a constant source of bugs, and it's finally gone. There are some consequent simplifications yet to be made, like not using a separate EState for subplans in the executor, but I'll tackle that later.
2007-02-22 23:00:26 +01:00
COMPARE_SCALAR_FIELD(firstColType);
Make SubPlan nodes carry the result's typmod as well as datatype OID. This is for consistency with the (relatively) recent addition of typmod to SubLink. An example of why it's a good idea is to be seen in the recent "failed to locate grouping columns" bug, which wouldn't have happened if a SubPlan exposed the same typmod info as the SubLink it was derived from. This could be back-patched, since it doesn't affect any on-disk data format, but for the moment it doesn't seem necessary to do so.
2009-03-10 23:09:26 +01:00
COMPARE_SCALAR_FIELD(firstColTypmod);
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
COMPARE_SCALAR_FIELD(firstColCollation);
Further tweaking of parsetree & plantree representation of SubLinks. Simplify SubLink by storing just a List of operator OIDs, instead of a list of incomplete OpExprs --- that was a bizarre and bulky choice, with no redeeming social value since we have to build new OpExprs anyway when forming the plan tree.
2003-01-10 22:08:15 +01:00
COMPARE_SCALAR_FIELD(useHashTable);
COMPARE_SCALAR_FIELD(unknownEqFalse);
Reimplement the linked list data structure used throughout the backend. In the past, we used a 'Lispy' linked list implementation: a "list" was merely a pointer to the head node of the list. The problem with that design is that it makes lappend() and length() linear time. This patch fixes that problem (and others) by maintaining a count of the list length and a pointer to the tail node along with each head node pointer. A "list" is now a pointer to a structure containing some meta-data about the list; the head and tail pointers in that structure refer to ListCell structures that maintain the actual linked list of nodes. The function names of the list API have also been changed to, I hope, be more logically consistent. By default, the old function names are still available; they will be disabled-by-default once the rest of the tree has been updated to use the new API names.
2004-05-26 06:41:50 +02:00
COMPARE_NODE_FIELD(setParam);
COMPARE_NODE_FIELD(parParam);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_NODE_FIELD(args);
Arrange to convert EXISTS subqueries that are equivalent to hashable IN subqueries into the same thing you'd have gotten from IN (except always with unknownEqFalse = true, so as to get the proper semantics for an EXISTS). I believe this fixes the last case within CVS HEAD in which an EXISTS could give worse performance than an equivalent IN subquery. The tricky part of this is that if the upper query probes the EXISTS for only a few rows, the hashing implementation can actually be worse than the default, and therefore we need to make a cost-based decision about which way to use. But at the time when the planner generates plans for subqueries, it doesn't really know how many times the subquery will be executed. The least invasive solution seems to be to generate both plans and postpone the choice until execution. Therefore, in a query that has been optimized this way, EXPLAIN will show two subplans for the EXISTS, of which only one will actually get executed. There is a lot more that could be done based on this infrastructure: in particular it's interesting to consider switching to the hash plan if we start out using the non-hashed plan but find a lot more upper rows going by than we expected. I have therefore left some minor inefficiencies in place, such as initializing both subplans even though we will currently only use one.
2008-08-22 02:16:04 +02:00
COMPARE_SCALAR_FIELD(startup_cost);
COMPARE_SCALAR_FIELD(per_call_cost);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlternativeSubPlan(const AlternativeSubPlan *a, const AlternativeSubPlan *b)
Arrange to convert EXISTS subqueries that are equivalent to hashable IN subqueries into the same thing you'd have gotten from IN (except always with unknownEqFalse = true, so as to get the proper semantics for an EXISTS). I believe this fixes the last case within CVS HEAD in which an EXISTS could give worse performance than an equivalent IN subquery. The tricky part of this is that if the upper query probes the EXISTS for only a few rows, the hashing implementation can actually be worse than the default, and therefore we need to make a cost-based decision about which way to use. But at the time when the planner generates plans for subqueries, it doesn't really know how many times the subquery will be executed. The least invasive solution seems to be to generate both plans and postpone the choice until execution. Therefore, in a query that has been optimized this way, EXPLAIN will show two subplans for the EXISTS, of which only one will actually get executed. There is a lot more that could be done based on this infrastructure: in particular it's interesting to consider switching to the hash plan if we start out using the non-hashed plan but find a lot more upper rows going by than we expected. I have therefore left some minor inefficiencies in place, such as initializing both subplans even though we will currently only use one.
2008-08-22 02:16:04 +02:00
{
COMPARE_NODE_FIELD(subplans);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
return true;
}
Remove 'func_tlist' from Func expression nodes, likewise 'param_tlist' from Param nodes, per discussion a few days ago on pghackers. Add new expression node type FieldSelect that implements the functionality where it's actually needed. Clean up some other unused fields in Func nodes as well. NOTE: initdb forced due to change in stored expression trees for rules.
2000-08-08 17:43:12 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalFieldSelect(const FieldSelect *a, const FieldSelect *b)
Remove 'func_tlist' from Func expression nodes, likewise 'param_tlist' from Param nodes, per discussion a few days ago on pghackers. Add new expression node type FieldSelect that implements the functionality where it's actually needed. Clean up some other unused fields in Func nodes as well. NOTE: initdb forced due to change in stored expression trees for rules.
2000-08-08 17:43:12 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(fieldnum);
COMPARE_SCALAR_FIELD(resulttype);
COMPARE_SCALAR_FIELD(resulttypmod);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(resultcollid);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
Remove 'func_tlist' from Func expression nodes, likewise 'param_tlist' from Param nodes, per discussion a few days ago on pghackers. Add new expression node type FieldSelect that implements the functionality where it's actually needed. Clean up some other unused fields in Func nodes as well. NOTE: initdb forced due to change in stored expression trees for rules.
2000-08-08 17:43:12 +02:00
return true;
}
Support assignment to subfields of composite columns in UPDATE and INSERT. As a side effect, cause subscripts in INSERT targetlists to do something more or less sensible; previously we evaluated such subscripts and then effectively ignored them. Another side effect is that UPDATE-ing an element or slice of an array value that is NULL now produces a non-null result, namely an array containing just the assigned-to positions.
2004-06-09 21:08:20 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalFieldStore(const FieldStore *a, const FieldStore *b)
Support assignment to subfields of composite columns in UPDATE and INSERT. As a side effect, cause subscripts in INSERT targetlists to do something more or less sensible; previously we evaluated such subscripts and then effectively ignored them. Another side effect is that UPDATE-ing an element or slice of an array value that is NULL now produces a non-null result, namely an array containing just the assigned-to positions.
2004-06-09 21:08:20 +02:00
{
COMPARE_NODE_FIELD(arg);
COMPARE_NODE_FIELD(newvals);
COMPARE_NODE_FIELD(fieldnums);
COMPARE_SCALAR_FIELD(resulttype);
return true;
}
Create a new expression node type RelabelType, which exists solely to represent the result of a binary-compatible type coercion. At runtime it just evaluates its argument --- but during type resolution, exprType will pick up the output type of the RelabelType node instead of the type of the argument. This solves some longstanding problems with dropped type coercions, an example being 'select now()::abstime::int4' which used to produce date-formatted output, not an integer, because the coercion to int4 was dropped on the floor.
2000-02-20 22:32:16 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalRelabelType(const RelabelType *a, const RelabelType *b)
Create a new expression node type RelabelType, which exists solely to represent the result of a binary-compatible type coercion. At runtime it just evaluates its argument --- but during type resolution, exprType will pick up the output type of the RelabelType node instead of the type of the argument. This solves some longstanding problems with dropped type coercions, an example being 'select now()::abstime::int4' which used to produce date-formatted output, not an integer, because the coercion to int4 was dropped on the floor.
2000-02-20 22:32:16 +01:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(resulttype);
COMPARE_SCALAR_FIELD(resulttypmod);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(resultcollid);
Make equal() ignore CoercionForm fields for better planning with casts. This change ensures that the planner will see implicit and explicit casts as equivalent for all purposes, except in the minority of cases where there's actually a semantic difference (as reflected by having a 3-argument cast function). In particular, this fixes cases where the EquivalenceClass machinery failed to consider two references to a varchar column as equivalent if one was implicitly cast to text but the other was explicitly cast to text, as seen in bug #7598 from Vaclav Juza. We have had similar bugs before in other parts of the planner, so I think it's time to fix this problem at the core instead of continuing to band-aid around it. Remove set_coercionform_dontcare(), which represents the band-aid previously in use for allowing matching of index and constraint expressions with inconsistent cast labeling. (We can probably get rid of COERCE_DONTCARE altogether, but I don't think removing that enum value in back branches would be wise; it's possible there's third party code referring to it.) Back-patch to 9.2. We could go back further, and might want to once this has been tested more; but for the moment I won't risk destabilizing plan choices in long-since-stable branches.
2012-10-12 18:10:49 +02:00
COMPARE_COERCIONFORM_FIELD(relabelformat);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Create a new expression node type RelabelType, which exists solely to represent the result of a binary-compatible type coercion. At runtime it just evaluates its argument --- but during type resolution, exprType will pick up the output type of the RelabelType node instead of the type of the argument. This solves some longstanding problems with dropped type coercions, an example being 'select now()::abstime::int4' which used to produce date-formatted output, not an integer, because the coercion to int4 was dropped on the floor.
2000-02-20 22:32:16 +01:00
return true;
}
Downgrade implicit casts to text to be assignment-only, except for the ones from the other string-category types; this eliminates a lot of surprising interpretations that the parser could formerly make when there was no directly applicable operator. Create a general mechanism that supports casts to and from the standard string types (text,varchar,bpchar) for *every* datatype, by invoking the datatype's I/O functions. These new casts are assignment-only in the to-string direction, explicit-only in the other, and therefore should create no surprising behavior. Remove a bunch of thereby-obsoleted datatype-specific casting functions. The "general mechanism" is a new expression node type CoerceViaIO that can actually convert between *any* two datatypes if their external text representations are compatible. This is more general than needed for the immediate feature, but might be useful in plpgsql or other places in future. This commit does nothing about the issue that applying the concatenation operator || to non-text types will now fail, often with strange error messages due to misinterpreting the operator as array concatenation. Since it often (not always) worked before, we should either make it succeed or at least give a more user-friendly error; but details are still under debate. Peter Eisentraut and Tom Lane
2007-06-05 23:31:09 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCoerceViaIO(const CoerceViaIO *a, const CoerceViaIO *b)
Downgrade implicit casts to text to be assignment-only, except for the ones from the other string-category types; this eliminates a lot of surprising interpretations that the parser could formerly make when there was no directly applicable operator. Create a general mechanism that supports casts to and from the standard string types (text,varchar,bpchar) for *every* datatype, by invoking the datatype's I/O functions. These new casts are assignment-only in the to-string direction, explicit-only in the other, and therefore should create no surprising behavior. Remove a bunch of thereby-obsoleted datatype-specific casting functions. The "general mechanism" is a new expression node type CoerceViaIO that can actually convert between *any* two datatypes if their external text representations are compatible. This is more general than needed for the immediate feature, but might be useful in plpgsql or other places in future. This commit does nothing about the issue that applying the concatenation operator || to non-text types will now fail, often with strange error messages due to misinterpreting the operator as array concatenation. Since it often (not always) worked before, we should either make it succeed or at least give a more user-friendly error; but details are still under debate. Peter Eisentraut and Tom Lane
2007-06-05 23:31:09 +02:00
{
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(resulttype);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(resultcollid);
Make equal() ignore CoercionForm fields for better planning with casts. This change ensures that the planner will see implicit and explicit casts as equivalent for all purposes, except in the minority of cases where there's actually a semantic difference (as reflected by having a 3-argument cast function). In particular, this fixes cases where the EquivalenceClass machinery failed to consider two references to a varchar column as equivalent if one was implicitly cast to text but the other was explicitly cast to text, as seen in bug #7598 from Vaclav Juza. We have had similar bugs before in other parts of the planner, so I think it's time to fix this problem at the core instead of continuing to band-aid around it. Remove set_coercionform_dontcare(), which represents the band-aid previously in use for allowing matching of index and constraint expressions with inconsistent cast labeling. (We can probably get rid of COERCE_DONTCARE altogether, but I don't think removing that enum value in back branches would be wise; it's possible there's third party code referring to it.) Back-patch to 9.2. We could go back further, and might want to once this has been tested more; but for the moment I won't risk destabilizing plan choices in long-since-stable branches.
2012-10-12 18:10:49 +02:00
COMPARE_COERCIONFORM_FIELD(coerceformat);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Downgrade implicit casts to text to be assignment-only, except for the ones from the other string-category types; this eliminates a lot of surprising interpretations that the parser could formerly make when there was no directly applicable operator. Create a general mechanism that supports casts to and from the standard string types (text,varchar,bpchar) for *every* datatype, by invoking the datatype's I/O functions. These new casts are assignment-only in the to-string direction, explicit-only in the other, and therefore should create no surprising behavior. Remove a bunch of thereby-obsoleted datatype-specific casting functions. The "general mechanism" is a new expression node type CoerceViaIO that can actually convert between *any* two datatypes if their external text representations are compatible. This is more general than needed for the immediate feature, but might be useful in plpgsql or other places in future. This commit does nothing about the issue that applying the concatenation operator || to non-text types will now fail, often with strange error messages due to misinterpreting the operator as array concatenation. Since it often (not always) worked before, we should either make it succeed or at least give a more user-friendly error; but details are still under debate. Peter Eisentraut and Tom Lane
2007-06-05 23:31:09 +02:00
return true;
}
Fix array coercion expressions to ensure that the correct volatility is seen by code inspecting the expression. The best way to do this seems to be to drop the original representation as a function invocation, and instead make a special expression node type that represents applying the element-type coercion function to each array element. In this way the element function is exposed and will be checked for volatility. Per report from Guillaume Smet.
2007-03-28 01:21:12 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalArrayCoerceExpr(const ArrayCoerceExpr *a, const ArrayCoerceExpr *b)
Fix array coercion expressions to ensure that the correct volatility is seen by code inspecting the expression. The best way to do this seems to be to drop the original representation as a function invocation, and instead make a special expression node type that represents applying the element-type coercion function to each array element. In this way the element function is exposed and will be checked for volatility. Per report from Guillaume Smet.
2007-03-28 01:21:12 +02:00
{
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(elemfuncid);
COMPARE_SCALAR_FIELD(resulttype);
COMPARE_SCALAR_FIELD(resulttypmod);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(resultcollid);
Fix array coercion expressions to ensure that the correct volatility is seen by code inspecting the expression. The best way to do this seems to be to drop the original representation as a function invocation, and instead make a special expression node type that represents applying the element-type coercion function to each array element. In this way the element function is exposed and will be checked for volatility. Per report from Guillaume Smet.
2007-03-28 01:21:12 +02:00
COMPARE_SCALAR_FIELD(isExplicit);
Make equal() ignore CoercionForm fields for better planning with casts. This change ensures that the planner will see implicit and explicit casts as equivalent for all purposes, except in the minority of cases where there's actually a semantic difference (as reflected by having a 3-argument cast function). In particular, this fixes cases where the EquivalenceClass machinery failed to consider two references to a varchar column as equivalent if one was implicitly cast to text but the other was explicitly cast to text, as seen in bug #7598 from Vaclav Juza. We have had similar bugs before in other parts of the planner, so I think it's time to fix this problem at the core instead of continuing to band-aid around it. Remove set_coercionform_dontcare(), which represents the band-aid previously in use for allowing matching of index and constraint expressions with inconsistent cast labeling. (We can probably get rid of COERCE_DONTCARE altogether, but I don't think removing that enum value in back branches would be wise; it's possible there's third party code referring to it.) Back-patch to 9.2. We could go back further, and might want to once this has been tested more; but for the moment I won't risk destabilizing plan choices in long-since-stable branches.
2012-10-12 18:10:49 +02:00
COMPARE_COERCIONFORM_FIELD(coerceformat);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Fix array coercion expressions to ensure that the correct volatility is seen by code inspecting the expression. The best way to do this seems to be to drop the original representation as a function invocation, and instead make a special expression node type that represents applying the element-type coercion function to each array element. In this way the element function is exposed and will be checked for volatility. Per report from Guillaume Smet.
2007-03-28 01:21:12 +02:00
return true;
}
Instead of supposing (wrongly, in the general case) that the rowtype of an inheritance child table is binary-compatible with the rowtype of its parent, invent an expression node type that does the conversion correctly. Fixes the new bug exhibited by Kris Shannon as well as a lot of old bugs that would only show up when using multiple inheritance or after altering the parent table.
2004-12-12 00:26:51 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalConvertRowtypeExpr(const ConvertRowtypeExpr *a, const ConvertRowtypeExpr *b)
Instead of supposing (wrongly, in the general case) that the rowtype of an inheritance child table is binary-compatible with the rowtype of its parent, invent an expression node type that does the conversion correctly. Fixes the new bug exhibited by Kris Shannon as well as a lot of old bugs that would only show up when using multiple inheritance or after altering the parent table.
2004-12-12 00:26:51 +01:00
{
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(resulttype);
Make equal() ignore CoercionForm fields for better planning with casts. This change ensures that the planner will see implicit and explicit casts as equivalent for all purposes, except in the minority of cases where there's actually a semantic difference (as reflected by having a 3-argument cast function). In particular, this fixes cases where the EquivalenceClass machinery failed to consider two references to a varchar column as equivalent if one was implicitly cast to text but the other was explicitly cast to text, as seen in bug #7598 from Vaclav Juza. We have had similar bugs before in other parts of the planner, so I think it's time to fix this problem at the core instead of continuing to band-aid around it. Remove set_coercionform_dontcare(), which represents the band-aid previously in use for allowing matching of index and constraint expressions with inconsistent cast labeling. (We can probably get rid of COERCE_DONTCARE altogether, but I don't think removing that enum value in back branches would be wise; it's possible there's third party code referring to it.) Back-patch to 9.2. We could go back further, and might want to once this has been tested more; but for the moment I won't risk destabilizing plan choices in long-since-stable branches.
2012-10-12 18:10:49 +02:00
COMPARE_COERCIONFORM_FIELD(convertformat);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Instead of supposing (wrongly, in the general case) that the rowtype of an inheritance child table is binary-compatible with the rowtype of its parent, invent an expression node type that does the conversion correctly. Fixes the new bug exhibited by Kris Shannon as well as a lot of old bugs that would only show up when using multiple inheritance or after altering the parent table.
2004-12-12 00:26:51 +01:00
return true;
}
Split CollateClause into separate raw and analyzed node types. CollateClause is now used only in raw grammar output, and CollateExpr after parse analysis. This is for clarity and to avoid carrying collation names in post-analysis parse trees: that's both wasteful and possibly misleading, since the collation's name could be changed while the parsetree still exists. Also, clean up assorted infelicities and omissions in processing of the node type.
2011-03-11 22:27:51 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCollateExpr(const CollateExpr *a, const CollateExpr *b)
Split CollateClause into separate raw and analyzed node types. CollateClause is now used only in raw grammar output, and CollateExpr after parse analysis. This is for clarity and to avoid carrying collation names in post-analysis parse trees: that's both wasteful and possibly misleading, since the collation's name could be changed while the parsetree still exists. Also, clean up assorted infelicities and omissions in processing of the node type.
2011-03-11 22:27:51 +01:00
{
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(collOid);
COMPARE_LOCATION_FIELD(location);
return true;
}
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCaseExpr(const CaseExpr *a, const CaseExpr *b)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
{
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_SCALAR_FIELD(casetype);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(casecollid);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_NODE_FIELD(arg);
COMPARE_NODE_FIELD(args);
COMPARE_NODE_FIELD(defresult);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCaseWhen(const CaseWhen *a, const CaseWhen *b)
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
{
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_NODE_FIELD(expr);
COMPARE_NODE_FIELD(result);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
First cut at full support for OUTER JOINs. There are still a few loose ends to clean up (see my message of same date to pghackers), but mostly it works. INITDB REQUIRED!
2000-09-12 23:07:18 +02:00
return true;
}
Reimplement CASE val WHEN compval1 THEN ... WHEN compval2 THEN ... END so that the 'val' is computed only once, per recent discussion. The speedup is not much when 'val' is just a simple variable, but could be significant for larger expressions. More importantly this avoids issues with multiple evaluations of a volatile 'val', and it allows the CASE expression to be reverse-listed in its original form by ruleutils.c.
2004-03-17 21:48:43 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCaseTestExpr(const CaseTestExpr *a, const CaseTestExpr *b)
Reimplement CASE val WHEN compval1 THEN ... WHEN compval2 THEN ... END so that the 'val' is computed only once, per recent discussion. The speedup is not much when 'val' is just a simple variable, but could be significant for larger expressions. More importantly this avoids issues with multiple evaluations of a volatile 'val', and it allows the CASE expression to be reverse-listed in its original form by ruleutils.c.
2004-03-17 21:48:43 +01:00
{
COMPARE_SCALAR_FIELD(typeId);
COMPARE_SCALAR_FIELD(typeMod);
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
COMPARE_SCALAR_FIELD(collation);
Reimplement CASE val WHEN compval1 THEN ... WHEN compval2 THEN ... END so that the 'val' is computed only once, per recent discussion. The speedup is not much when 'val' is just a simple variable, but could be significant for larger expressions. More importantly this avoids issues with multiple evaluations of a volatile 'val', and it allows the CASE expression to be reverse-listed in its original form by ruleutils.c.
2004-03-17 21:48:43 +01:00
return true;
}
First phase of work on array improvements. ARRAY[x,y,z] constructor expressions, ARRAY(sub-SELECT) expressions, some array functions. Polymorphic functions using ANYARRAY/ANYELEMENT argument and return types. Some regression tests in place, documentation is lacking. Joe Conway, with some kibitzing from Tom Lane.
2003-04-09 01:20:04 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalArrayExpr(const ArrayExpr *a, const ArrayExpr *b)
First phase of work on array improvements. ARRAY[x,y,z] constructor expressions, ARRAY(sub-SELECT) expressions, some array functions. Polymorphic functions using ANYARRAY/ANYELEMENT argument and return types. Some regression tests in place, documentation is lacking. Joe Conway, with some kibitzing from Tom Lane.
2003-04-09 01:20:04 +02:00
{
COMPARE_SCALAR_FIELD(array_typeid);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(array_collid);
First phase of work on array improvements. ARRAY[x,y,z] constructor expressions, ARRAY(sub-SELECT) expressions, some array functions. Polymorphic functions using ANYARRAY/ANYELEMENT argument and return types. Some regression tests in place, documentation is lacking. Joe Conway, with some kibitzing from Tom Lane.
2003-04-09 01:20:04 +02:00
COMPARE_SCALAR_FIELD(element_typeid);
COMPARE_NODE_FIELD(elements);
Fix ARRAY[] construct so that in multidimensional case, elements can be anything yielding an array of the proper kind, not only sub-ARRAY[] constructs; do subscript checking at runtime not parse time. Also, adjust array_cat to make array || array comply with the SQL99 spec. Joe Conway
2003-08-18 01:43:27 +02:00
COMPARE_SCALAR_FIELD(multidims);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
First phase of work on array improvements. ARRAY[x,y,z] constructor expressions, ARRAY(sub-SELECT) expressions, some array functions. Polymorphic functions using ANYARRAY/ANYELEMENT argument and return types. Some regression tests in place, documentation is lacking. Joe Conway, with some kibitzing from Tom Lane.
2003-04-09 01:20:04 +02:00
return true;
}
Promote row expressions to full-fledged citizens of the expression syntax, rather than allowing them only in a few special cases as before. In particular you can now pass a ROW() construct to a function that accepts a rowtype parameter. Internal generation of RowExprs fixes a number of corner cases that used to not work very well, such as referencing the whole-row result of a JOIN or subquery. This represents a further step in the work I started a month or so back to make rowtype values into first-class citizens.
2004-05-11 00:44:49 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalRowExpr(const RowExpr *a, const RowExpr *b)
Promote row expressions to full-fledged citizens of the expression syntax, rather than allowing them only in a few special cases as before. In particular you can now pass a ROW() construct to a function that accepts a rowtype parameter. Internal generation of RowExprs fixes a number of corner cases that used to not work very well, such as referencing the whole-row result of a JOIN or subquery. This represents a further step in the work I started a month or so back to make rowtype values into first-class citizens.
2004-05-11 00:44:49 +02:00
{
COMPARE_NODE_FIELD(args);
COMPARE_SCALAR_FIELD(row_typeid);
Make equal() ignore CoercionForm fields for better planning with casts. This change ensures that the planner will see implicit and explicit casts as equivalent for all purposes, except in the minority of cases where there's actually a semantic difference (as reflected by having a 3-argument cast function). In particular, this fixes cases where the EquivalenceClass machinery failed to consider two references to a varchar column as equivalent if one was implicitly cast to text but the other was explicitly cast to text, as seen in bug #7598 from Vaclav Juza. We have had similar bugs before in other parts of the planner, so I think it's time to fix this problem at the core instead of continuing to band-aid around it. Remove set_coercionform_dontcare(), which represents the band-aid previously in use for allowing matching of index and constraint expressions with inconsistent cast labeling. (We can probably get rid of COERCE_DONTCARE altogether, but I don't think removing that enum value in back branches would be wise; it's possible there's third party code referring to it.) Back-patch to 9.2. We could go back further, and might want to once this has been tested more; but for the moment I won't risk destabilizing plan choices in long-since-stable branches.
2012-10-12 18:10:49 +02:00
COMPARE_COERCIONFORM_FIELD(row_format);
When expanding a whole-row Var into a RowExpr during ResolveNew(), attach the column alias names of the RTE referenced by the Var to the RowExpr. This is needed to allow ruleutils.c to correctly deparse FieldSelect nodes referencing such a construct. Per my recent bug report. Adding a field to RowExpr forces initdb (because of stored rules changes) so this solution is not back-patchable; which is unfortunate because 8.2 and 8.3 have this issue. But it only affects EXPLAIN for some pretty odd corner cases, so we can probably live without a solution for the back branches.
2008-10-06 19:39:26 +02:00
COMPARE_NODE_FIELD(colnames);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Promote row expressions to full-fledged citizens of the expression syntax, rather than allowing them only in a few special cases as before. In particular you can now pass a ROW() construct to a function that accepts a rowtype parameter. Internal generation of RowExprs fixes a number of corner cases that used to not work very well, such as referencing the whole-row result of a JOIN or subquery. This represents a further step in the work I started a month or so back to make rowtype values into first-class citizens.
2004-05-11 00:44:49 +02:00
return true;
}
Implement SQL-compliant treatment of row comparisons for < <= > >= cases (previously we only did = and <> correctly). Also, allow row comparisons with any operators that are in btree opclasses, not only those with these specific names. This gets rid of a whole lot of indefensible assumptions about the behavior of particular operators based on their names ... though it's still true that IN and NOT IN expand to "= ANY". The patch adds a RowCompareExpr expression node type, and makes some changes in the representation of ANY/ALL/ROWCOMPARE SubLinks so that they can share code with RowCompareExpr. I have not yet done anything about making RowCompareExpr an indexable operator, but will look at that soon. initdb forced due to changes in stored rules.
2005-12-28 02:30:02 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalRowCompareExpr(const RowCompareExpr *a, const RowCompareExpr *b)
Implement SQL-compliant treatment of row comparisons for < <= > >= cases (previously we only did = and <> correctly). Also, allow row comparisons with any operators that are in btree opclasses, not only those with these specific names. This gets rid of a whole lot of indefensible assumptions about the behavior of particular operators based on their names ... though it's still true that IN and NOT IN expand to "= ANY". The patch adds a RowCompareExpr expression node type, and makes some changes in the representation of ANY/ALL/ROWCOMPARE SubLinks so that they can share code with RowCompareExpr. I have not yet done anything about making RowCompareExpr an indexable operator, but will look at that soon. initdb forced due to changes in stored rules.
2005-12-28 02:30:02 +01:00
{
COMPARE_SCALAR_FIELD(rctype);
COMPARE_NODE_FIELD(opnos);
Restructure operator classes to allow improved handling of cross-data-type cases. Operator classes now exist within "operator families". While most families are equivalent to a single class, related classes can be grouped into one family to represent the fact that they are semantically compatible. Cross-type operators are now naturally adjunct parts of a family, without having to wedge them into a particular opclass as we had done originally. This commit restructures the catalogs and cleans up enough of the fallout so that everything still works at least as well as before, but most of the work needed to actually improve the planner's behavior will come later. Also, there are not yet CREATE/DROP/ALTER OPERATOR FAMILY commands; the only way to create a new family right now is to allow CREATE OPERATOR CLASS to make one by default. I owe some more documentation work, too. But that can all be done in smaller pieces once this infrastructure is in place.
2006-12-23 01:43:13 +01:00
COMPARE_NODE_FIELD(opfamilies);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_NODE_FIELD(inputcollids);
Implement SQL-compliant treatment of row comparisons for < <= > >= cases (previously we only did = and <> correctly). Also, allow row comparisons with any operators that are in btree opclasses, not only those with these specific names. This gets rid of a whole lot of indefensible assumptions about the behavior of particular operators based on their names ... though it's still true that IN and NOT IN expand to "= ANY". The patch adds a RowCompareExpr expression node type, and makes some changes in the representation of ANY/ALL/ROWCOMPARE SubLinks so that they can share code with RowCompareExpr. I have not yet done anything about making RowCompareExpr an indexable operator, but will look at that soon. initdb forced due to changes in stored rules.
2005-12-28 02:30:02 +01:00
COMPARE_NODE_FIELD(largs);
COMPARE_NODE_FIELD(rargs);
return true;
}
COALESCE() and NULLIF() are now first-class expressions, not macros that turn into CASE expressions. They evaluate their arguments at most once. Patch by Kris Jurka, review and (very light) editorializing by me.
2003-02-16 03:30:39 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCoalesceExpr(const CoalesceExpr *a, const CoalesceExpr *b)
COALESCE() and NULLIF() are now first-class expressions, not macros that turn into CASE expressions. They evaluate their arguments at most once. Patch by Kris Jurka, review and (very light) editorializing by me.
2003-02-16 03:30:39 +01:00
{
COMPARE_SCALAR_FIELD(coalescetype);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(coalescecollid);
COALESCE() and NULLIF() are now first-class expressions, not macros that turn into CASE expressions. They evaluate their arguments at most once. Patch by Kris Jurka, review and (very light) editorializing by me.
2003-02-16 03:30:39 +01:00
COMPARE_NODE_FIELD(args);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
COALESCE() and NULLIF() are now first-class expressions, not macros that turn into CASE expressions. They evaluate their arguments at most once. Patch by Kris Jurka, review and (very light) editorializing by me.
2003-02-16 03:30:39 +01:00
return true;
}
Add Oracle-compatible GREATEST and LEAST functions. Pavel Stehule
2005-06-27 00:05:42 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalMinMaxExpr(const MinMaxExpr *a, const MinMaxExpr *b)
Add Oracle-compatible GREATEST and LEAST functions. Pavel Stehule
2005-06-27 00:05:42 +02:00
{
COMPARE_SCALAR_FIELD(minmaxtype);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(minmaxcollid);
COMPARE_SCALAR_FIELD(inputcollid);
Add Oracle-compatible GREATEST and LEAST functions. Pavel Stehule
2005-06-27 00:05:42 +02:00
COMPARE_SCALAR_FIELD(op);
COMPARE_NODE_FIELD(args);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Add Oracle-compatible GREATEST and LEAST functions. Pavel Stehule
2005-06-27 00:05:42 +02:00
return true;
}
Code review for XML patch. Instill a bit of sanity in the location of the XmlExpr code in various lists, use a representation that has some hope of reverse-listing correctly (though it's still a de-escaping function shy of correctness), generally try to make it look more like Postgres coding conventions.
2006-12-24 01:29:20 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalXmlExpr(const XmlExpr *a, const XmlExpr *b)
Code review for XML patch. Instill a bit of sanity in the location of the XmlExpr code in various lists, use a representation that has some hope of reverse-listing correctly (though it's still a de-escaping function shy of correctness), generally try to make it look more like Postgres coding conventions.
2006-12-24 01:29:20 +01:00
{
COMPARE_SCALAR_FIELD(op);
COMPARE_STRING_FIELD(name);
COMPARE_NODE_FIELD(named_args);
COMPARE_NODE_FIELD(arg_names);
COMPARE_NODE_FIELD(args);
Implement XMLSERIALIZE for real. Analogously, make the xml to text cast observe the xmloption. Reorganize the representation of the XML option in the parse tree and the API to make it easier to manage and understand. Add regression tests for parsing back XML expressions.
2007-02-03 15:06:56 +01:00
COMPARE_SCALAR_FIELD(xmloption);
COMPARE_SCALAR_FIELD(type);
COMPARE_SCALAR_FIELD(typmod);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Code review for XML patch. Instill a bit of sanity in the location of the XmlExpr code in various lists, use a representation that has some hope of reverse-listing correctly (though it's still a de-escaping function shy of correctness), generally try to make it look more like Postgres coding conventions.
2006-12-24 01:29:20 +01:00
return true;
}
Subselects in FROM clause, per ISO syntax: FROM (SELECT ...) [AS] alias. (Don't forget that an alias is required.) Views reimplemented as expanding to subselect-in-FROM. Grouping, aggregates, DISTINCT in views actually work now (he says optimistically). No UNION support in subselects/views yet, but I have some ideas about that. Rule-related permissions checking moved out of rewriter and into executor. INITDB REQUIRED!
2000-09-29 20:21:41 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalNullTest(const NullTest *a, const NullTest *b)
Subselects in FROM clause, per ISO syntax: FROM (SELECT ...) [AS] alias. (Don't forget that an alias is required.) Views reimplemented as expanding to subselect-in-FROM. Grouping, aggregates, DISTINCT in views actually work now (he says optimistically). No UNION support in subselects/views yet, but I have some ideas about that. Rule-related permissions checking moved out of rewriter and into executor. INITDB REQUIRED!
2000-09-29 20:21:41 +02:00
{
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(nulltesttype);
Add an "argisrow" field to NullTest nodes, following a plan made way back in 8.2beta but never carried out. This avoids repetitive tests of whether the argument is of scalar or composite type. Also, be a bit more paranoid about composite arguments in some places where we previously weren't checking.
2010-01-02 00:03:10 +01:00
COMPARE_SCALAR_FIELD(argisrow);
Subselects in FROM clause, per ISO syntax: FROM (SELECT ...) [AS] alias. (Don't forget that an alias is required.) Views reimplemented as expanding to subselect-in-FROM. Grouping, aggregates, DISTINCT in views actually work now (he says optimistically). No UNION support in subselects/views yet, but I have some ideas about that. Rule-related permissions checking moved out of rewriter and into executor. INITDB REQUIRED!
2000-09-29 20:21:41 +02:00
return true;
}
First cut at full support for OUTER JOINs. There are still a few loose ends to clean up (see my message of same date to pghackers), but mostly it works. INITDB REQUIRED!
2000-09-12 23:07:18 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalBooleanTest(const BooleanTest *a, const BooleanTest *b)
First cut at full support for OUTER JOINs. There are still a few loose ends to clean up (see my message of same date to pghackers), but mostly it works. INITDB REQUIRED!
2000-09-12 23:07:18 +02:00
{
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(booltesttype);
First cut at full support for OUTER JOINs. There are still a few loose ends to clean up (see my message of same date to pghackers), but mostly it works. INITDB REQUIRED!
2000-09-12 23:07:18 +02:00
return true;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
}
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCoerceToDomain(const CoerceToDomain *a, const CoerceToDomain *b)
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
{
COMPARE_NODE_FIELD(arg);
Determine the set of constraints applied to a domain at executor startup, not in the parser; this allows ALTER DOMAIN to work correctly with domain constraint operations stored in rules. Rod Taylor; code review by Tom Lane.
2003-02-03 22:15:45 +01:00
COMPARE_SCALAR_FIELD(resulttype);
COMPARE_SCALAR_FIELD(resulttypmod);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(resultcollid);
Make equal() ignore CoercionForm fields for better planning with casts. This change ensures that the planner will see implicit and explicit casts as equivalent for all purposes, except in the minority of cases where there's actually a semantic difference (as reflected by having a 3-argument cast function). In particular, this fixes cases where the EquivalenceClass machinery failed to consider two references to a varchar column as equivalent if one was implicitly cast to text but the other was explicitly cast to text, as seen in bug #7598 from Vaclav Juza. We have had similar bugs before in other parts of the planner, so I think it's time to fix this problem at the core instead of continuing to band-aid around it. Remove set_coercionform_dontcare(), which represents the band-aid previously in use for allowing matching of index and constraint expressions with inconsistent cast labeling. (We can probably get rid of COERCE_DONTCARE altogether, but I don't think removing that enum value in back branches would be wise; it's possible there's third party code referring to it.) Back-patch to 9.2. We could go back further, and might want to once this has been tested more; but for the moment I won't risk destabilizing plan choices in long-since-stable branches.
2012-10-12 18:10:49 +02:00
COMPARE_COERCIONFORM_FIELD(coercionformat);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
return true;
}
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCoerceToDomainValue(const CoerceToDomainValue *a, const CoerceToDomainValue *b)
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
{
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_SCALAR_FIELD(typeId);
COMPARE_SCALAR_FIELD(typeMod);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(collation);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
return true;
}
Code review for UPDATE tab SET col = DEFAULT patch ... whack it around so it has some chance of working in rules ...
2003-07-03 18:34:26 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalSetToDefault(const SetToDefault *a, const SetToDefault *b)
Code review for UPDATE tab SET col = DEFAULT patch ... whack it around so it has some chance of working in rules ...
2003-07-03 18:34:26 +02:00
{
COMPARE_SCALAR_FIELD(typeId);
COMPARE_SCALAR_FIELD(typeMod);
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
COMPARE_SCALAR_FIELD(collation);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Code review for UPDATE tab SET col = DEFAULT patch ... whack it around so it has some chance of working in rules ...
2003-07-03 18:34:26 +02:00
return true;
}
Support UPDATE/DELETE WHERE CURRENT OF cursor_name, per SQL standard. Along the way, allow FOR UPDATE in non-WITH-HOLD cursors; there may once have been a reason to disallow that, but it seems to work now, and it's really rather necessary if you want to select a row via a cursor and then update it in a concurrent-safe fashion. Original patch by Arul Shaji, rather heavily editorialized by Tom Lane.
2007-06-11 03:16:30 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCurrentOfExpr(const CurrentOfExpr *a, const CurrentOfExpr *b)
Support UPDATE/DELETE WHERE CURRENT OF cursor_name, per SQL standard. Along the way, allow FOR UPDATE in non-WITH-HOLD cursors; there may once have been a reason to disallow that, but it seems to work now, and it's really rather necessary if you want to select a row via a cursor and then update it in a concurrent-safe fashion. Original patch by Arul Shaji, rather heavily editorialized by Tom Lane.
2007-06-11 03:16:30 +02:00
{
COMPARE_SCALAR_FIELD(cvarno);
COMPARE_STRING_FIELD(cursor_name);
Improve UPDATE/DELETE WHERE CURRENT OF so that they can be used from plpgsql with a plpgsql-defined cursor. The underlying mechanism for this is that the main SQL engine will now take "WHERE CURRENT OF $n" where $n is a refcursor parameter. Not sure if we should document that fact or consider it an implementation detail. Per discussion with Pavel Stehule.
2007-06-12 00:22:42 +02:00
COMPARE_SCALAR_FIELD(cursor_param);
Support UPDATE/DELETE WHERE CURRENT OF cursor_name, per SQL standard. Along the way, allow FOR UPDATE in non-WITH-HOLD cursors; there may once have been a reason to disallow that, but it seems to work now, and it's really rather necessary if you want to select a row via a cursor and then update it in a concurrent-safe fashion. Original patch by Arul Shaji, rather heavily editorialized by Tom Lane.
2007-06-11 03:16:30 +02:00
return true;
}
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalTargetEntry(const TargetEntry *a, const TargetEntry *b)
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
{
COMPARE_NODE_FIELD(expr);
Merge Resdom nodes into TargetEntry nodes to simplify code and save a few palloc's. I also chose to eliminate the restype and restypmod fields entirely, since they are redundant with information stored in the node's contained expression; re-examining the expression at need seems simpler and more reliable than trying to keep restype/restypmod up to date. initdb forced due to change in contents of stored rules.
2005-04-06 18:34:07 +02:00
COMPARE_SCALAR_FIELD(resno);
COMPARE_STRING_FIELD(resname);
COMPARE_SCALAR_FIELD(ressortgroupref);
COMPARE_SCALAR_FIELD(resorigtbl);
COMPARE_SCALAR_FIELD(resorigcol);
COMPARE_SCALAR_FIELD(resjunk);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalRangeTblRef(const RangeTblRef *a, const RangeTblRef *b)
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
{
COMPARE_SCALAR_FIELD(rtindex);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalJoinExpr(const JoinExpr *a, const JoinExpr *b)
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
{
COMPARE_SCALAR_FIELD(jointype);
COMPARE_SCALAR_FIELD(isNatural);
COMPARE_NODE_FIELD(larg);
COMPARE_NODE_FIELD(rarg);
Make backend header files C++ safe This alters various incidental uses of C++ key words to use other similar identifiers, so that a C++ compiler won't choke outright. You still (probably) need extern "C" { }; around the inclusion of backend headers. based on a patch by Kurt Harriman <harriman@acm.org> Also add a script cpluspluscheck to check for C++ compatibility in the future. As of right now, this passes without error for me.
2009-07-16 08:33:46 +02:00
COMPARE_NODE_FIELD(usingClause);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
COMPARE_NODE_FIELD(quals);
COMPARE_NODE_FIELD(alias);
COMPARE_SCALAR_FIELD(rtindex);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalFromExpr(const FromExpr *a, const FromExpr *b)
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
{
COMPARE_NODE_FIELD(fromlist);
COMPARE_NODE_FIELD(quals);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
return true;
}
Allow index use with OR clauses.
1998-08-02 00:12:13 +02:00
/*
Add equal() funcs for Case nodes ... amazing we had not detected this omission before. Miscellaneous other cleanups.
1999-07-29 04:45:36 +02:00
* Stuff from relation.h
Allow index use with OR clauses.
1998-08-02 00:12:13 +02:00
*/
Add equal() funcs for Case nodes ... amazing we had not detected this omission before. Miscellaneous other cleanups.
1999-07-29 04:45:36 +02:00
Support for subselects. (Have to re-visit readfuncs.c)
1998-02-13 04:27:47 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalPathKey(const PathKey *a, const PathKey *b)
Support for subselects. (Have to re-visit readfuncs.c)
1998-02-13 04:27:47 +01:00
{
Postpone creation of pathkeys lists to fix bug #8049. This patch gets rid of the concept of, and infrastructure for, non-canonical PathKeys; we now only ever create canonical pathkey lists. The need for non-canonical pathkeys came from the desire to have grouping_planner initialize query_pathkeys and related pathkey lists before calling query_planner. However, since query_planner didn't actually *do* anything with those lists before they'd been made canonical, we can get rid of the whole mess by just not creating the lists at all until the point where we formerly canonicalized them. There are several ways in which we could implement that without making query_planner itself deal with grouping/sorting features (which are supposed to be the province of grouping_planner). I chose to add a callback function to query_planner's API; other alternatives would have required adding more fields to PlannerInfo, which while not bad in itself would create an ABI break for planner-related plugins in the 9.2 release series. This still breaks ABI for anything that calls query_planner directly, but it seems somewhat unlikely that there are any such plugins. I had originally conceived of this change as merely a step on the way to fixing bug #8049 from Teun Hoogendoorn; but it turns out that this fixes that bug all by itself, as per the added regression test. The reason is that now get_eclass_for_sort_expr is adding the ORDER BY expression at the end of EquivalenceClass creation not the start, and so anything that is in a multi-member EquivalenceClass has already been created with correct em_nullable_relids. I am suspicious that there are related scenarios in which we still need to teach get_eclass_for_sort_expr to compute correct nullable_relids, but am not eager to risk destabilizing either 9.2 or 9.3 to fix bugs that are only hypothetical. So for the moment, do this and stop here. Back-patch to 9.2 but not to earlier branches, since they don't exhibit this bug for lack of join-clause-movement logic that depends on em_nullable_relids being correct. (We might have to revisit that choice if any related bugs turn up.) In 9.2, don't change the signature of make_pathkeys_for_sortclauses nor remove canonicalize_pathkeys, so as not to risk more plugin breakage than we have to.
2013-04-29 20:49:01 +02:00
/* We assume pointer equality is sufficient to compare the eclasses */
COMPARE_SCALAR_FIELD(pk_eclass);
Refactor planner's pathkeys data structure to create a separate, explicit representation of equivalence classes of variables. This is an extensive rewrite, but it brings a number of benefits: * planner no longer fails in the presence of "incomplete" operator families that don't offer operators for every possible combination of datatypes. * avoid generating and then discarding redundant equality clauses. * remove bogus assumption that derived equalities always use operators named "=". * mergejoins can work with a variety of sort orders (e.g., descending) now, instead of tying each mergejoinable operator to exactly one sort order. * better recognition of redundant sort columns. * can make use of equalities appearing underneath an outer join.
2007-01-20 21:45:41 +01:00
COMPARE_SCALAR_FIELD(pk_opfamily);
COMPARE_SCALAR_FIELD(pk_strategy);
COMPARE_SCALAR_FIELD(pk_nulls_first);
pgindent run before 6.3 release, with Thomas' requested changes.
1998-02-26 05:46:47 +01:00
Renaming cleanup, no pgindent yet.
1998-09-01 05:29:17 +02:00
return true;
Support for subselects. (Have to re-visit readfuncs.c)
1998-02-13 04:27:47 +01:00
}
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalRestrictInfo(const RestrictInfo *a, const RestrictInfo *b)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(clause);
Add the ability to extract OR indexscan conditions from OR-of-AND join conditions in which each OR subclause includes a constraint on the same relation. This implements the other useful side-effect of conversion to CNF format, without its unpleasant side-effects. As per pghackers discussion of a few weeks ago.
2004-01-05 06:07:36 +01:00
COMPARE_SCALAR_FIELD(is_pushed_down);
Restore the former RestrictInfo field valid_everywhere (but invert the flag sense and rename to "outerjoin_delayed" to more clearly reflect what it means). I had decided that it was redundant in 8.1, but the folly of this is exposed by a bug report from Sebastian Böck. The place where it's needed is to prevent orindxpath.c from cherry-picking arms of an outer-join OR clause to form a relation restriction that isn't actually legal to push down to the relation scan level. There may be some legal cases that this forbids optimizing, but we'd need much closer analysis to determine it.
2005-11-15 00:54:23 +01:00
COMPARE_SCALAR_FIELD(outerjoin_delayed);
Simplify the planner's join clause management by storing join clauses of a relation in a flat 'joininfo' list. The former arrangement grouped the join clauses according to the set of unjoined relids used in each; however, profiling on test cases involving lots of joins proves that that data structure is a net loss. It takes more time to group the join clauses together than is saved by avoiding duplicate tests later. It doesn't help any that there are usually not more than one or two clauses per group ...
2005-06-09 06:19:00 +02:00
COMPARE_BITMAPSET_FIELD(required_relids);
Revise parameterized-path mechanism to fix assorted issues. This patch adjusts the treatment of parameterized paths so that all paths with the same parameterization (same set of required outer rels) for the same relation will have the same rowcount estimate. We cache the rowcount estimates to ensure that property, and hopefully save a few cycles too. Doing this makes it practical for add_path_precheck to operate without a rowcount estimate: it need only assume that paths with different parameterizations never dominate each other, which is close enough to true anyway for coarse filtering, because normally a more-parameterized path should yield fewer rows thanks to having more join clauses to apply. In add_path, we do the full nine yards of comparing rowcount estimates along with everything else, so that we can discard parameterized paths that don't actually have an advantage. This fixes some issues I'd found with add_path rejecting parameterized paths on the grounds that they were more expensive than not-parameterized ones, even though they yielded many fewer rows and hence would be cheaper once subsequent joining was considered. To make the same-rowcounts assumption valid, we have to require that any parameterized path enforce *all* join clauses that could be obtained from the particular set of outer rels, even if not all of them are useful for indexing. This is required at both base scans and joins. It's a good thing anyway since the net impact is that join quals are checked at the lowest practical level in the join tree. Hence, discard the original rather ad-hoc mechanism for choosing parameterization joinquals, and build a better one that has a more principled rule for when clauses can be moved. The original rule was actually buggy anyway for lack of knowledge about which relations are part of an outer join's outer side; getting this right requires adding an outer_relids field to RestrictInfo.
2012-04-19 21:52:46 +02:00
COMPARE_BITMAPSET_FIELD(outer_relids);
Fix planner to restore its previous level of intelligence about pushing constants through full joins, as in select * from tenk1 a full join tenk1 b using (unique1) where unique1 = 42; which should generate a fairly cheap plan where we apply the constraint unique1 = 42 in each relation scan. This had been broken by my patch of 2008-06-27, which is now reverted in favor of a more invasive but hopefully less incorrect approach. That patch was meant to prevent incorrect extraction of OR'd indexclauses from OR conditions above an outer join. To do that correctly we need more information than the outerjoin_delay flag can provide, so add a nullable_relids field to RestrictInfo that records exactly which relations are nulled by outer joins that are underneath a particular qual clause. A side benefit is that we can make the test in create_or_index_quals more specific: it is now smart enough to extract an OR'd indexclause into the outer side of an outer join, even though it must not do so in the inner side. The old coding couldn't distinguish these cases so it could not do either.
2009-04-16 22:42:16 +02:00
COMPARE_BITMAPSET_FIELD(nullable_relids);
pgindent run.
2003-08-04 02:43:34 +02:00
Further work on making use of new statistics in planner. Adjust APIs of costsize.c routines to pass Query root, so that costsize can figure more things out by itself and not be so dependent on its callers to tell it everything it needs to know. Use selectivity of hash or merge clause to estimate number of tuples processed internally in these joins (this is more useful than it would've been before, since eqjoinsel is somewhat more accurate than before).
2001-06-05 07:26:05 +02:00
/*
Standard pgindent run for 8.1.
2005-10-15 04:49:52 +02:00
* We ignore all the remaining fields, since they may not be set yet, and
* should be derivable from the clause anyway.
Further work on making use of new statistics in planner. Adjust APIs of costsize.c routines to pass Query root, so that costsize can figure more things out by itself and not be so dependent on its callers to tell it everything it needs to know. Use selectivity of hash or merge clause to estimate number of tuples processed internally in these joins (this is more useful than it would've been before, since eqjoinsel is somewhat more accurate than before).
2001-06-05 07:26:05 +02:00
*/
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
Renaming cleanup, no pgindent yet.
1998-09-01 05:29:17 +02:00
return true;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
}
Add a concept of "placeholder" variables to the planner. These are variables that represent some expression that we desire to compute below the top level of the plan, and then let that value "bubble up" as though it were a plain Var (ie, a column value). The immediate application is to allow sub-selects to be flattened even when they are below an outer join and have non-nullable output expressions. Formerly we couldn't flatten because such an expression wouldn't properly go to NULL when evaluated above the outer join. Now, we wrap it in a PlaceHolderVar and arrange for the actual evaluation to occur below the outer join. When the resulting Var bubbles up through the join, it will be set to NULL if necessary, yielding the correct results. This fixes a planner limitation that's existed since 7.1. In future we might want to use this mechanism to re-introduce some form of Hellerstein's "expensive functions" optimization, ie place the evaluation of an expensive function at the most suitable point in the plan tree.
2008-10-21 22:42:53 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalPlaceHolderVar(const PlaceHolderVar *a, const PlaceHolderVar *b)
Add a concept of "placeholder" variables to the planner. These are variables that represent some expression that we desire to compute below the top level of the plan, and then let that value "bubble up" as though it were a plain Var (ie, a column value). The immediate application is to allow sub-selects to be flattened even when they are below an outer join and have non-nullable output expressions. Formerly we couldn't flatten because such an expression wouldn't properly go to NULL when evaluated above the outer join. Now, we wrap it in a PlaceHolderVar and arrange for the actual evaluation to occur below the outer join. When the resulting Var bubbles up through the join, it will be set to NULL if necessary, yielding the correct results. This fixes a planner limitation that's existed since 7.1. In future we might want to use this mechanism to re-introduce some form of Hellerstein's "expensive functions" optimization, ie place the evaluation of an expensive function at the most suitable point in the plan tree.
2008-10-21 22:42:53 +02:00
{
/*
8.4 pgindent run, with new combined Linux/FreeBSD/MinGW typedef list provided by Andrew.
2009-06-11 16:49:15 +02:00
* We intentionally do not compare phexpr. Two PlaceHolderVars with the
Add a concept of "placeholder" variables to the planner. These are variables that represent some expression that we desire to compute below the top level of the plan, and then let that value "bubble up" as though it were a plain Var (ie, a column value). The immediate application is to allow sub-selects to be flattened even when they are below an outer join and have non-nullable output expressions. Formerly we couldn't flatten because such an expression wouldn't properly go to NULL when evaluated above the outer join. Now, we wrap it in a PlaceHolderVar and arrange for the actual evaluation to occur below the outer join. When the resulting Var bubbles up through the join, it will be set to NULL if necessary, yielding the correct results. This fixes a planner limitation that's existed since 7.1. In future we might want to use this mechanism to re-introduce some form of Hellerstein's "expensive functions" optimization, ie place the evaluation of an expensive function at the most suitable point in the plan tree.
2008-10-21 22:42:53 +02:00
* same ID and levelsup should be considered equal even if the contained
Fix planner problems with LATERAL references in PlaceHolderVars. The planner largely failed to consider the possibility that a PlaceHolderVar's expression might contain a lateral reference to a Var coming from somewhere outside the PHV's syntactic scope. We had a previous report of a problem in this area, which I tried to fix in a quick-hack way in commit 4da6439bd8553059766011e2a42c6e39df08717f, but Antonin Houska pointed out that there were still some problems, and investigation turned up other issues. This patch largely reverts that commit in favor of a more thoroughly thought-through solution. The new theory is that a PHV's ph_eval_at level cannot be higher than its original syntactic level. If it contains lateral references, those don't change the ph_eval_at level, but rather they create a lateral-reference requirement for the ph_eval_at join relation. The code in joinpath.c needs to handle that. Another issue is that createplan.c wasn't handling nested PlaceHolderVars properly. In passing, push knowledge of lateral-reference checks for join clauses into join_clause_is_movable_to. This is mainly so that FDWs don't need to deal with it. This patch doesn't fix the original join-qual-placement problem reported by Jeremy Evans (and indeed, one of the new regression test cases shows the wrong answer because of that). But the PlaceHolderVar problems need to be fixed before that issue can be addressed, so committing this separately seems reasonable.
2013-08-18 02:22:37 +02:00
* expressions have managed to mutate to different states. This will
* happen during final plan construction when there are nested PHVs, since
* the inner PHV will get replaced by a Param in some copies of the outer
* PHV. Another way in which it can happen is that initplan sublinks
* could get replaced by differently-numbered Params when sublink folding
* is done. (The end result of such a situation would be some
* unreferenced initplans, which is annoying but not really a problem.) On
* the same reasoning, there is no need to examine phrels.
Add a concept of "placeholder" variables to the planner. These are variables that represent some expression that we desire to compute below the top level of the plan, and then let that value "bubble up" as though it were a plain Var (ie, a column value). The immediate application is to allow sub-selects to be flattened even when they are below an outer join and have non-nullable output expressions. Formerly we couldn't flatten because such an expression wouldn't properly go to NULL when evaluated above the outer join. Now, we wrap it in a PlaceHolderVar and arrange for the actual evaluation to occur below the outer join. When the resulting Var bubbles up through the join, it will be set to NULL if necessary, yielding the correct results. This fixes a planner limitation that's existed since 7.1. In future we might want to use this mechanism to re-introduce some form of Hellerstein's "expensive functions" optimization, ie place the evaluation of an expensive function at the most suitable point in the plan tree.
2008-10-21 22:42:53 +02:00
*
* COMPARE_NODE_FIELD(phexpr);
Fix planner problems with LATERAL references in PlaceHolderVars. The planner largely failed to consider the possibility that a PlaceHolderVar's expression might contain a lateral reference to a Var coming from somewhere outside the PHV's syntactic scope. We had a previous report of a problem in this area, which I tried to fix in a quick-hack way in commit 4da6439bd8553059766011e2a42c6e39df08717f, but Antonin Houska pointed out that there were still some problems, and investigation turned up other issues. This patch largely reverts that commit in favor of a more thoroughly thought-through solution. The new theory is that a PHV's ph_eval_at level cannot be higher than its original syntactic level. If it contains lateral references, those don't change the ph_eval_at level, but rather they create a lateral-reference requirement for the ph_eval_at join relation. The code in joinpath.c needs to handle that. Another issue is that createplan.c wasn't handling nested PlaceHolderVars properly. In passing, push knowledge of lateral-reference checks for join clauses into join_clause_is_movable_to. This is mainly so that FDWs don't need to deal with it. This patch doesn't fix the original join-qual-placement problem reported by Jeremy Evans (and indeed, one of the new regression test cases shows the wrong answer because of that). But the PlaceHolderVar problems need to be fixed before that issue can be addressed, so committing this separately seems reasonable.
2013-08-18 02:22:37 +02:00
*
* COMPARE_BITMAPSET_FIELD(phrels);
Add a concept of "placeholder" variables to the planner. These are variables that represent some expression that we desire to compute below the top level of the plan, and then let that value "bubble up" as though it were a plain Var (ie, a column value). The immediate application is to allow sub-selects to be flattened even when they are below an outer join and have non-nullable output expressions. Formerly we couldn't flatten because such an expression wouldn't properly go to NULL when evaluated above the outer join. Now, we wrap it in a PlaceHolderVar and arrange for the actual evaluation to occur below the outer join. When the resulting Var bubbles up through the join, it will be set to NULL if necessary, yielding the correct results. This fixes a planner limitation that's existed since 7.1. In future we might want to use this mechanism to re-introduce some form of Hellerstein's "expensive functions" optimization, ie place the evaluation of an expensive function at the most suitable point in the plan tree.
2008-10-21 22:42:53 +02:00
*/
COMPARE_SCALAR_FIELD(phid);
COMPARE_SCALAR_FIELD(phlevelsup);
return true;
}
IN clauses appearing at top level of WHERE can now be handled as joins. There are two implementation techniques: the executor understands a new JOIN_IN jointype, which emits at most one matching row per left-hand row, or the result of the IN's sub-select can be fed through a DISTINCT filter and then joined as an ordinary relation. Along the way, some minor code cleanup in the optimizer; notably, break out most of the jointree-rearrangement preprocessing in planner.c and put it in a new file prep/prepjointree.c.
2003-01-20 19:55:07 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalSpecialJoinInfo(const SpecialJoinInfo *a, const SpecialJoinInfo *b)
IN clauses appearing at top level of WHERE can now be handled as joins. There are two implementation techniques: the executor understands a new JOIN_IN jointype, which emits at most one matching row per left-hand row, or the result of the IN's sub-select can be fed through a DISTINCT filter and then joined as an ordinary relation. Along the way, some minor code cleanup in the optimizer; notably, break out most of the jointree-rearrangement preprocessing in planner.c and put it in a new file prep/prepjointree.c.
2003-01-20 19:55:07 +01:00
{
Implement SEMI and ANTI joins in the planner and executor. (Semijoins replace the old JOIN_IN code, but antijoins are new functionality.) Teach the planner to convert appropriate EXISTS and NOT EXISTS subqueries into semi and anti joins respectively. Also, LEFT JOINs with suitable upper-level IS NULL filters are recognized as being anti joins. Unify the InClauseInfo and OuterJoinInfo infrastructure into "SpecialJoinInfo". With that change, it becomes possible to associate a SpecialJoinInfo with every join attempt, which permits some cleanup of join selectivity estimation. That needs to be taken much further than this patch does, but the next step is to change the API for oprjoin selectivity functions, which seems like material for a separate patch. So for the moment the output size estimates for semi and especially anti joins are quite bogus.
2008-08-14 20:48:00 +02:00
COMPARE_BITMAPSET_FIELD(min_lefthand);
COMPARE_BITMAPSET_FIELD(min_righthand);
COMPARE_BITMAPSET_FIELD(syn_lefthand);
COMPARE_BITMAPSET_FIELD(syn_righthand);
COMPARE_SCALAR_FIELD(jointype);
COMPARE_SCALAR_FIELD(lhs_strict);
COMPARE_SCALAR_FIELD(delay_upper_joins);
COMPARE_NODE_FIELD(join_quals);
IN clauses appearing at top level of WHERE can now be handled as joins. There are two implementation techniques: the executor understands a new JOIN_IN jointype, which emits at most one matching row per left-hand row, or the result of the IN's sub-select can be fed through a DISTINCT filter and then joined as an ordinary relation. Along the way, some minor code cleanup in the optimizer; notably, break out most of the jointree-rearrangement preprocessing in planner.c and put it in a new file prep/prepjointree.c.
2003-01-20 19:55:07 +01:00
return true;
}
Fix up planner infrastructure to support LATERAL properly. This patch takes care of a number of problems having to do with failure to choose valid join orders and incorrect handling of lateral references pulled up from subqueries. Notable changes: * Add a LateralJoinInfo data structure similar to SpecialJoinInfo, to represent join ordering constraints created by lateral references. (I first considered extending the SpecialJoinInfo structure, but the semantics are different enough that a separate data structure seems better.) Extend join_is_legal() and related functions to prevent trying to form unworkable joins, and to ensure that we will consider joins that satisfy lateral references even if the joins would be clauseless. * Fill in the infrastructure needed for the last few types of relation scan paths to support parameterization. We'd have wanted this eventually anyway, but it is necessary now because a relation that gets pulled up out of a UNION ALL subquery may acquire a reltargetlist containing lateral references, meaning that its paths *have* to be parameterized whether or not we have any code that can push join quals down into the scan. * Compute data about lateral references early in query_planner(), and save in RelOptInfo nodes, to avoid repetitive calculations later. * Assorted corner-case bug fixes. There's probably still some bugs left, but this is a lot closer to being real than it was before.
2012-08-27 04:48:55 +02:00
static bool
_equalLateralJoinInfo(const LateralJoinInfo *a, const LateralJoinInfo *b)
{
COMPARE_BITMAPSET_FIELD(lateral_lhs);
Fix planner problems with LATERAL references in PlaceHolderVars. The planner largely failed to consider the possibility that a PlaceHolderVar's expression might contain a lateral reference to a Var coming from somewhere outside the PHV's syntactic scope. We had a previous report of a problem in this area, which I tried to fix in a quick-hack way in commit 4da6439bd8553059766011e2a42c6e39df08717f, but Antonin Houska pointed out that there were still some problems, and investigation turned up other issues. This patch largely reverts that commit in favor of a more thoroughly thought-through solution. The new theory is that a PHV's ph_eval_at level cannot be higher than its original syntactic level. If it contains lateral references, those don't change the ph_eval_at level, but rather they create a lateral-reference requirement for the ph_eval_at join relation. The code in joinpath.c needs to handle that. Another issue is that createplan.c wasn't handling nested PlaceHolderVars properly. In passing, push knowledge of lateral-reference checks for join clauses into join_clause_is_movable_to. This is mainly so that FDWs don't need to deal with it. This patch doesn't fix the original join-qual-placement problem reported by Jeremy Evans (and indeed, one of the new regression test cases shows the wrong answer because of that). But the PlaceHolderVar problems need to be fixed before that issue can be addressed, so committing this separately seems reasonable.
2013-08-18 02:22:37 +02:00
COMPARE_BITMAPSET_FIELD(lateral_rhs);
Fix up planner infrastructure to support LATERAL properly. This patch takes care of a number of problems having to do with failure to choose valid join orders and incorrect handling of lateral references pulled up from subqueries. Notable changes: * Add a LateralJoinInfo data structure similar to SpecialJoinInfo, to represent join ordering constraints created by lateral references. (I first considered extending the SpecialJoinInfo structure, but the semantics are different enough that a separate data structure seems better.) Extend join_is_legal() and related functions to prevent trying to form unworkable joins, and to ensure that we will consider joins that satisfy lateral references even if the joins would be clauseless. * Fill in the infrastructure needed for the last few types of relation scan paths to support parameterization. We'd have wanted this eventually anyway, but it is necessary now because a relation that gets pulled up out of a UNION ALL subquery may acquire a reltargetlist containing lateral references, meaning that its paths *have* to be parameterized whether or not we have any code that can push join quals down into the scan. * Compute data about lateral references early in query_planner(), and save in RelOptInfo nodes, to avoid repetitive calculations later. * Assorted corner-case bug fixes. There's probably still some bugs left, but this is a lot closer to being real than it was before.
2012-08-27 04:48:55 +02:00
return true;
}
Restructure planner's handling of inheritance. Rather than processing inheritance trees on-the-fly, which pretty well constrained us to considering only one way of planning inheritance, expand inheritance sets during the planner prep phase, and build a side data structure that can be consulted later to find which RTEs are members of which inheritance sets. As proof of concept, use the data structure to plan joins against inheritance sets more efficiently: we can now use indexes on the set members in inner-indexscan joins. (The generated plans could be improved further, but it'll take some executor changes.) This data structure will also support handling UNION ALL subqueries in the same way as inheritance sets, but that aspect of it isn't finished yet.
2006-01-31 22:39:25 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAppendRelInfo(const AppendRelInfo *a, const AppendRelInfo *b)
Restructure planner's handling of inheritance. Rather than processing inheritance trees on-the-fly, which pretty well constrained us to considering only one way of planning inheritance, expand inheritance sets during the planner prep phase, and build a side data structure that can be consulted later to find which RTEs are members of which inheritance sets. As proof of concept, use the data structure to plan joins against inheritance sets more efficiently: we can now use indexes on the set members in inner-indexscan joins. (The generated plans could be improved further, but it'll take some executor changes.) This data structure will also support handling UNION ALL subqueries in the same way as inheritance sets, but that aspect of it isn't finished yet.
2006-01-31 22:39:25 +01:00
{
COMPARE_SCALAR_FIELD(parent_relid);
COMPARE_SCALAR_FIELD(child_relid);
COMPARE_SCALAR_FIELD(parent_reltype);
COMPARE_SCALAR_FIELD(child_reltype);
COMPARE_NODE_FIELD(translated_vars);
COMPARE_SCALAR_FIELD(parent_reloid);
return true;
}
Add a concept of "placeholder" variables to the planner. These are variables that represent some expression that we desire to compute below the top level of the plan, and then let that value "bubble up" as though it were a plain Var (ie, a column value). The immediate application is to allow sub-selects to be flattened even when they are below an outer join and have non-nullable output expressions. Formerly we couldn't flatten because such an expression wouldn't properly go to NULL when evaluated above the outer join. Now, we wrap it in a PlaceHolderVar and arrange for the actual evaluation to occur below the outer join. When the resulting Var bubbles up through the join, it will be set to NULL if necessary, yielding the correct results. This fixes a planner limitation that's existed since 7.1. In future we might want to use this mechanism to re-introduce some form of Hellerstein's "expensive functions" optimization, ie place the evaluation of an expensive function at the most suitable point in the plan tree.
2008-10-21 22:42:53 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalPlaceHolderInfo(const PlaceHolderInfo *a, const PlaceHolderInfo *b)
Add a concept of "placeholder" variables to the planner. These are variables that represent some expression that we desire to compute below the top level of the plan, and then let that value "bubble up" as though it were a plain Var (ie, a column value). The immediate application is to allow sub-selects to be flattened even when they are below an outer join and have non-nullable output expressions. Formerly we couldn't flatten because such an expression wouldn't properly go to NULL when evaluated above the outer join. Now, we wrap it in a PlaceHolderVar and arrange for the actual evaluation to occur below the outer join. When the resulting Var bubbles up through the join, it will be set to NULL if necessary, yielding the correct results. This fixes a planner limitation that's existed since 7.1. In future we might want to use this mechanism to re-introduce some form of Hellerstein's "expensive functions" optimization, ie place the evaluation of an expensive function at the most suitable point in the plan tree.
2008-10-21 22:42:53 +02:00
{
COMPARE_SCALAR_FIELD(phid);
Fix planner problems with LATERAL references in PlaceHolderVars. The planner largely failed to consider the possibility that a PlaceHolderVar's expression might contain a lateral reference to a Var coming from somewhere outside the PHV's syntactic scope. We had a previous report of a problem in this area, which I tried to fix in a quick-hack way in commit 4da6439bd8553059766011e2a42c6e39df08717f, but Antonin Houska pointed out that there were still some problems, and investigation turned up other issues. This patch largely reverts that commit in favor of a more thoroughly thought-through solution. The new theory is that a PHV's ph_eval_at level cannot be higher than its original syntactic level. If it contains lateral references, those don't change the ph_eval_at level, but rather they create a lateral-reference requirement for the ph_eval_at join relation. The code in joinpath.c needs to handle that. Another issue is that createplan.c wasn't handling nested PlaceHolderVars properly. In passing, push knowledge of lateral-reference checks for join clauses into join_clause_is_movable_to. This is mainly so that FDWs don't need to deal with it. This patch doesn't fix the original join-qual-placement problem reported by Jeremy Evans (and indeed, one of the new regression test cases shows the wrong answer because of that). But the PlaceHolderVar problems need to be fixed before that issue can be addressed, so committing this separately seems reasonable.
2013-08-18 02:22:37 +02:00
COMPARE_NODE_FIELD(ph_var); /* should be redundant */
Add a concept of "placeholder" variables to the planner. These are variables that represent some expression that we desire to compute below the top level of the plan, and then let that value "bubble up" as though it were a plain Var (ie, a column value). The immediate application is to allow sub-selects to be flattened even when they are below an outer join and have non-nullable output expressions. Formerly we couldn't flatten because such an expression wouldn't properly go to NULL when evaluated above the outer join. Now, we wrap it in a PlaceHolderVar and arrange for the actual evaluation to occur below the outer join. When the resulting Var bubbles up through the join, it will be set to NULL if necessary, yielding the correct results. This fixes a planner limitation that's existed since 7.1. In future we might want to use this mechanism to re-introduce some form of Hellerstein's "expensive functions" optimization, ie place the evaluation of an expensive function at the most suitable point in the plan tree.
2008-10-21 22:42:53 +02:00
COMPARE_BITMAPSET_FIELD(ph_eval_at);
Fix planner problems with LATERAL references in PlaceHolderVars. The planner largely failed to consider the possibility that a PlaceHolderVar's expression might contain a lateral reference to a Var coming from somewhere outside the PHV's syntactic scope. We had a previous report of a problem in this area, which I tried to fix in a quick-hack way in commit 4da6439bd8553059766011e2a42c6e39df08717f, but Antonin Houska pointed out that there were still some problems, and investigation turned up other issues. This patch largely reverts that commit in favor of a more thoroughly thought-through solution. The new theory is that a PHV's ph_eval_at level cannot be higher than its original syntactic level. If it contains lateral references, those don't change the ph_eval_at level, but rather they create a lateral-reference requirement for the ph_eval_at join relation. The code in joinpath.c needs to handle that. Another issue is that createplan.c wasn't handling nested PlaceHolderVars properly. In passing, push knowledge of lateral-reference checks for join clauses into join_clause_is_movable_to. This is mainly so that FDWs don't need to deal with it. This patch doesn't fix the original join-qual-placement problem reported by Jeremy Evans (and indeed, one of the new regression test cases shows the wrong answer because of that). But the PlaceHolderVar problems need to be fixed before that issue can be addressed, so committing this separately seems reasonable.
2013-08-18 02:22:37 +02:00
COMPARE_BITMAPSET_FIELD(ph_lateral);
Add a concept of "placeholder" variables to the planner. These are variables that represent some expression that we desire to compute below the top level of the plan, and then let that value "bubble up" as though it were a plain Var (ie, a column value). The immediate application is to allow sub-selects to be flattened even when they are below an outer join and have non-nullable output expressions. Formerly we couldn't flatten because such an expression wouldn't properly go to NULL when evaluated above the outer join. Now, we wrap it in a PlaceHolderVar and arrange for the actual evaluation to occur below the outer join. When the resulting Var bubbles up through the join, it will be set to NULL if necessary, yielding the correct results. This fixes a planner limitation that's existed since 7.1. In future we might want to use this mechanism to re-introduce some form of Hellerstein's "expensive functions" optimization, ie place the evaluation of an expensive function at the most suitable point in the plan tree.
2008-10-21 22:42:53 +02:00
COMPARE_BITMAPSET_FIELD(ph_needed);
COMPARE_SCALAR_FIELD(ph_width);
return true;
}
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
Add equality checking for T_Query so that we don't get complaints in UNION regress test. Probably still need some more node types to be handled here, but I'm done for the day...
1999-02-07 01:52:12 +01:00
/*
* Stuff from parsenodes.h
*/
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalQuery(const Query *a, const Query *b)
Add equality checking for T_Query so that we don't get complaints in UNION regress test. Probably still need some more node types to be handled here, but I'm done for the day...
1999-02-07 01:52:12 +01:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(commandType);
COMPARE_SCALAR_FIELD(querySource);
Add some infrastructure for contrib/pg_stat_statements. Add a queryId field to Query and PlannedStmt. This is not used by the core backend, except for being copied around at appropriate times. It's meant to allow plug-ins to track a particular query forward from parse analysis to execution. The queryId is intentionally not dumped into stored rules (and hence this commit doesn't bump catversion). You could argue that choice either way, but it seems better that stored rule strings not have any dependency on plug-ins that might or might not be present. Also, add a post_parse_analyze_hook that gets invoked at the end of parse analysis (but only for top-level analysis of complete queries, not cases such as analyzing a domain's default-value expression). This is mainly meant to be used to compute and assign a queryId, but it could have other applications. Peter Geoghegan
2012-03-27 21:14:13 +02:00
/* we intentionally ignore queryId, since it might not be set */
Portal and memory management infrastructure for extended query protocol. Both plannable queries and utility commands are now always executed within Portals, which have been revamped so that they can handle the load (they used to be good only for single SELECT queries). Restructure code to push command-completion-tag selection logic out of postgres.c, so that it won't have to be duplicated between simple and extended queries. initdb forced due to addition of a field to Query nodes.
2003-05-02 22:54:36 +02:00
COMPARE_SCALAR_FIELD(canSetTag);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(utilityStmt);
COMPARE_SCALAR_FIELD(resultRelation);
COMPARE_SCALAR_FIELD(hasAggs);
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
COMPARE_SCALAR_FIELD(hasWindowFuncs);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(hasSubLinks);
Rearrange the querytree representation of ORDER BY/GROUP BY/DISTINCT items as per my recent proposal: 1. Fold SortClause and GroupClause into a single node type SortGroupClause. We were already relying on them to be struct-equivalent, so using two node tags wasn't accomplishing much except to get in the way of comparing items with equal(). 2. Add an "eqop" field to SortGroupClause to carry the associated equality operator. This is cheap for the parser to get at the same time it's looking up the sort operator, and storing it eliminates the need for repeated not-so-cheap lookups during planning. In future this will also let us represent GROUP/DISTINCT operations on datatypes that have hash opclasses but no btree opclasses (ie, they have equality but no natural sort order). The previous representation simply didn't work for that, since its only indicator of comparison semantics was a sort operator. 3. Add a hasDistinctOn boolean to struct Query to explicitly record whether the distinctClause came from DISTINCT or DISTINCT ON. This allows removing some complicated and not 100% bulletproof code that attempted to figure that out from the distinctClause alone. This patch doesn't in itself create any new capability, but it's necessary infrastructure for future attempts to use hash-based grouping for DISTINCT and UNION/INTERSECT/EXCEPT.
2008-08-02 23:32:01 +02:00
COMPARE_SCALAR_FIELD(hasDistinctOn);
Implement SQL-standard WITH clauses, including WITH RECURSIVE. There are some unimplemented aspects: recursive queries must use UNION ALL (should allow UNION too), and we don't have SEARCH or CYCLE clauses. These might or might not get done for 8.4, but even without them it's a pretty useful feature. There are also a couple of small loose ends and definitional quibbles, which I'll send a memo about to pgsql-hackers shortly. But let's land the patch now so we can get on with other development. Yoshiyuki Asaba, with lots of help from Tatsuo Ishii and Tom Lane
2008-10-04 23:56:55 +02:00
COMPARE_SCALAR_FIELD(hasRecursive);
Support data-modifying commands (INSERT/UPDATE/DELETE) in WITH. This patch implements data-modifying WITH queries according to the semantics that the updates all happen with the same command counter value, and in an unspecified order. Therefore one WITH clause can't see the effects of another, nor can the outer query see the effects other than through the RETURNING values. And attempts to do conflicting updates will have unpredictable results. We'll need to document all that. This commit just fixes the code; documentation updates are waiting on author. Marko Tiikkaja and Hitoshi Harada
2011-02-26 00:56:23 +01:00
COMPARE_SCALAR_FIELD(hasModifyingCTE);
When FOR UPDATE/SHARE is used with LIMIT, put the LockRows plan node underneath the Limit node, not atop it. This fixes the old problem that such a query might unexpectedly return fewer rows than the LIMIT says, due to LockRows discarding updated rows. There is a related problem that LockRows might destroy the sort ordering produced by earlier steps; but fixing that by pushing LockRows below Sort would create serious performance problems that are unjustified in many real-world applications, as well as potential deadlock problems from locking many more rows than expected. Instead, keep the present semantics of applying FOR UPDATE after ORDER BY within a single query level; but allow the user to specify the other way by writing FOR UPDATE in a sub-select. To make that work, track whether FOR UPDATE appeared explicitly in sub-selects or got pushed down from the parent, and don't flatten a sub-select that contained an explicit FOR UPDATE.
2009-10-28 15:55:47 +01:00
COMPARE_SCALAR_FIELD(hasForUpdate);
Implement SQL-standard WITH clauses, including WITH RECURSIVE. There are some unimplemented aspects: recursive queries must use UNION ALL (should allow UNION too), and we don't have SEARCH or CYCLE clauses. These might or might not get done for 8.4, but even without them it's a pretty useful feature. There are also a couple of small loose ends and definitional quibbles, which I'll send a memo about to pgsql-hackers shortly. But let's land the patch now so we can get on with other development. Yoshiyuki Asaba, with lots of help from Tatsuo Ishii and Tom Lane
2008-10-04 23:56:55 +02:00
COMPARE_NODE_FIELD(cteList);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(rtable);
COMPARE_NODE_FIELD(jointree);
COMPARE_NODE_FIELD(targetList);
WITH CHECK OPTION support for auto-updatable VIEWs For simple views which are automatically updatable, this patch allows the user to specify what level of checking should be done on records being inserted or updated. For 'LOCAL CHECK', new tuples are validated against the conditionals of the view they are being inserted into, while for 'CASCADED CHECK' the new tuples are validated against the conditionals for all views involved (from the top down). This option is part of the SQL specification. Dean Rasheed, reviewed by Pavel Stehule
2013-07-18 23:10:16 +02:00
COMPARE_NODE_FIELD(withCheckOptions);
Add INSERT/UPDATE/DELETE RETURNING, with basic docs and regression tests. plpgsql support to come later. Along the way, convert execMain's SELECT INTO support into a DestReceiver, in order to eliminate some ugly special cases. Jonah Harris and Tom Lane
2006-08-12 04:52:06 +02:00
COMPARE_NODE_FIELD(returningList);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(groupClause);
COMPARE_NODE_FIELD(havingQual);
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
COMPARE_NODE_FIELD(windowClause);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(distinctClause);
COMPARE_NODE_FIELD(sortClause);
COMPARE_NODE_FIELD(limitOffset);
COMPARE_NODE_FIELD(limitCount);
Improve the representation of FOR UPDATE/FOR SHARE so that we can support both FOR UPDATE and FOR SHARE in one command, as well as both NOWAIT and normal WAIT behavior. The more general code is actually simpler and cleaner.
2006-04-30 20:30:40 +02:00
COMPARE_NODE_FIELD(rowMarks);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(setOperations);
Recognize functional dependency on primary keys. This allows a table's other columns to be referenced without listing them in GROUP BY, so long as the primary key column(s) are listed in GROUP BY. Eventually we should also allow functional dependency on a UNIQUE constraint when the columns are marked NOT NULL, but that has to wait until NOT NULL constraints are represented in pg_constraint, because we need to have pg_constraint OIDs for all the conditions needed to ensure functional dependency. Peter Eisentraut, reviewed by Alex Hunsaker and Tom Lane
2010-08-07 04:44:09 +02:00
COMPARE_NODE_FIELD(constraintDeps);
Add equality checking for T_Query so that we don't get complaints in UNION regress test. Probably still need some more node types to be handled here, but I'm done for the day...
1999-02-07 01:52:12 +01:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalInsertStmt(const InsertStmt *a, const InsertStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(relation);
COMPARE_NODE_FIELD(cols);
COMPARE_NODE_FIELD(selectStmt);
Add INSERT/UPDATE/DELETE RETURNING, with basic docs and regression tests. plpgsql support to come later. Along the way, convert execMain's SELECT INTO support into a DestReceiver, in order to eliminate some ugly special cases. Jonah Harris and Tom Lane
2006-08-12 04:52:06 +02:00
COMPARE_NODE_FIELD(returningList);
Allow WITH clauses to be attached to INSERT, UPDATE, DELETE statements. This is not the hoped-for facility of using INSERT/UPDATE/DELETE inside a WITH, but rather the other way around. It seems useful in its own right anyway. Note: catversion bumped because, although the contents of stored rules might look compatible, there's actually a subtle semantic change. A single Query containing a WITH and INSERT...VALUES now represents writing the WITH before the INSERT, not before the VALUES. While it's not clear that that matters to anyone, it seems like a good idea to have it cited in the git history for catversion.h. Original patch by Marko Tiikkaja, with updating and cleanup by Hitoshi Harada.
2010-10-16 01:53:59 +02:00
COMPARE_NODE_FIELD(withClause);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDeleteStmt(const DeleteStmt *a, const DeleteStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(relation);
Add a "USING" clause to DELETE, which is equivalent to the FROM clause in UPDATE. We also now issue a NOTICE if a query has _any_ implicit range table entries -- in the past, we would only warn about implicit RTEs in SELECTs with at least one explicit RTE. As a result of the warning change, 25 of the regression tests had to be updated. I also took the opportunity to remove some bogus whitespace differences between some of the float4 and float8 variants. I believe I have correctly updated all the platform-specific variants, but let me know if that's not the case. Original patch for DELETE ... USING from Euler Taveira de Oliveira, reworked by Neil Conway.
2005-04-07 03:51:41 +02:00
COMPARE_NODE_FIELD(usingClause);
Add INSERT/UPDATE/DELETE RETURNING, with basic docs and regression tests. plpgsql support to come later. Along the way, convert execMain's SELECT INTO support into a DestReceiver, in order to eliminate some ugly special cases. Jonah Harris and Tom Lane
2006-08-12 04:52:06 +02:00
COMPARE_NODE_FIELD(whereClause);
COMPARE_NODE_FIELD(returningList);
Allow WITH clauses to be attached to INSERT, UPDATE, DELETE statements. This is not the hoped-for facility of using INSERT/UPDATE/DELETE inside a WITH, but rather the other way around. It seems useful in its own right anyway. Note: catversion bumped because, although the contents of stored rules might look compatible, there's actually a subtle semantic change. A single Query containing a WITH and INSERT...VALUES now represents writing the WITH before the INSERT, not before the VALUES. While it's not clear that that matters to anyone, it seems like a good idea to have it cited in the git history for catversion.h. Original patch by Marko Tiikkaja, with updating and cleanup by Hitoshi Harada.
2010-10-16 01:53:59 +02:00
COMPARE_NODE_FIELD(withClause);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalUpdateStmt(const UpdateStmt *a, const UpdateStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(relation);
COMPARE_NODE_FIELD(targetList);
COMPARE_NODE_FIELD(whereClause);
COMPARE_NODE_FIELD(fromClause);
Add INSERT/UPDATE/DELETE RETURNING, with basic docs and regression tests. plpgsql support to come later. Along the way, convert execMain's SELECT INTO support into a DestReceiver, in order to eliminate some ugly special cases. Jonah Harris and Tom Lane
2006-08-12 04:52:06 +02:00
COMPARE_NODE_FIELD(returningList);
Allow WITH clauses to be attached to INSERT, UPDATE, DELETE statements. This is not the hoped-for facility of using INSERT/UPDATE/DELETE inside a WITH, but rather the other way around. It seems useful in its own right anyway. Note: catversion bumped because, although the contents of stored rules might look compatible, there's actually a subtle semantic change. A single Query containing a WITH and INSERT...VALUES now represents writing the WITH before the INSERT, not before the VALUES. While it's not clear that that matters to anyone, it seems like a good idea to have it cited in the git history for catversion.h. Original patch by Marko Tiikkaja, with updating and cleanup by Hitoshi Harada.
2010-10-16 01:53:59 +02:00
COMPARE_NODE_FIELD(withClause);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalSelectStmt(const SelectStmt *a, const SelectStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(distinctClause);
Modify processing of DECLARE CURSOR and EXPLAIN so that they can resolve the types of unspecified parameters when submitted via extended query protocol. This worked in 8.2 but I had broken it during plancache changes. DECLARE CURSOR is now treated almost exactly like a plain SELECT through parse analysis, rewrite, and planning; only just before sending to the executor do we divert it away to ProcessUtility. This requires a special-case check in a number of places, but practically all of them were already special-casing SELECT INTO, so it's not too ugly. (Maybe it would be a good idea to merge the two by treating IntoClause as a form of utility statement? Not going to worry about that now, though.) That approach doesn't work for EXPLAIN, however, so for that I punted and used a klugy solution of running parse analysis an extra time if under extended query protocol.
2007-04-28 00:05:49 +02:00
COMPARE_NODE_FIELD(intoClause);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(targetList);
COMPARE_NODE_FIELD(fromClause);
COMPARE_NODE_FIELD(whereClause);
COMPARE_NODE_FIELD(groupClause);
COMPARE_NODE_FIELD(havingClause);
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
COMPARE_NODE_FIELD(windowClause);
Add support for multi-row VALUES clauses as part of INSERT statements (e.g. "INSERT ... VALUES (...), (...), ...") and elsewhere as allowed by the spec. (e.g. similar to a FROM clause subselect). initdb required. Joe Conway and Tom Lane.
2006-08-02 03:59:48 +02:00
COMPARE_NODE_FIELD(valuesLists);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(sortClause);
COMPARE_NODE_FIELD(limitOffset);
COMPARE_NODE_FIELD(limitCount);
Add NOWAIT option to SELECT FOR UPDATE/SHARE. Original patch by Hans-Juergen Schoenig, revisions by Karel Zak and Tom Lane.
2005-08-01 22:31:16 +02:00
COMPARE_NODE_FIELD(lockingClause);
Fix WITH attached to a nested set operation (UNION/INTERSECT/EXCEPT). Parse analysis neglected to cover the case of a WITH clause attached to an intermediate-level set operation; it only handled WITH at the top level or WITH attached to a leaf-level SELECT. Per report from Adam Mackler. In HEAD, I rearranged the order of SelectStmt's fields to put withClause with the other fields that can appear on non-leaf SelectStmts. In back branches, leave it alone to avoid a possible ABI break for third-party code. Back-patch to 8.4 where WITH support was added.
2012-07-31 23:56:21 +02:00
COMPARE_NODE_FIELD(withClause);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(op);
COMPARE_SCALAR_FIELD(all);
COMPARE_NODE_FIELD(larg);
COMPARE_NODE_FIELD(rarg);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Reimplementation of UNION/INTERSECT/EXCEPT. INTERSECT/EXCEPT now meet the SQL92 semantics, including support for ALL option. All three can be used in subqueries and views. DISTINCT and ORDER BY work now in views, too. This rewrite fixes many problems with cross-datatype UNIONs and INSERT/SELECT where the SELECT yields different datatypes than the INSERT needs. I did that by making UNION subqueries and SELECT in INSERT be treated like subselects-in-FROM, thereby allowing an extra level of targetlist where the datatype conversions can be inserted safely. INITDB NEEDED!
2000-10-05 21:11:39 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalSetOperationStmt(const SetOperationStmt *a, const SetOperationStmt *b)
Reimplementation of UNION/INTERSECT/EXCEPT. INTERSECT/EXCEPT now meet the SQL92 semantics, including support for ALL option. All three can be used in subqueries and views. DISTINCT and ORDER BY work now in views, too. This rewrite fixes many problems with cross-datatype UNIONs and INSERT/SELECT where the SELECT yields different datatypes than the INSERT needs. I did that by making UNION subqueries and SELECT in INSERT be treated like subselects-in-FROM, thereby allowing an extra level of targetlist where the datatype conversions can be inserted safely. INITDB NEEDED!
2000-10-05 21:11:39 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(op);
COMPARE_SCALAR_FIELD(all);
COMPARE_NODE_FIELD(larg);
COMPARE_NODE_FIELD(rarg);
Reimplement the linked list data structure used throughout the backend. In the past, we used a 'Lispy' linked list implementation: a "list" was merely a pointer to the head node of the list. The problem with that design is that it makes lappend() and length() linear time. This patch fixes that problem (and others) by maintaining a count of the list length and a pointer to the tail node along with each head node pointer. A "list" is now a pointer to a structure containing some meta-data about the list; the head and tail pointers in that structure refer to ListCell structures that maintain the actual linked list of nodes. The function names of the list API have also been changed to, I hope, be more logically consistent. By default, the old function names are still available; they will be disabled-by-default once the rest of the tree has been updated to use the new API names.
2004-05-26 06:41:50 +02:00
COMPARE_NODE_FIELD(colTypes);
Fix UNION/INTERSECT/EXCEPT so that when two inputs being merged have same data type and same typmod, we show that typmod as the output typmod, rather than generic -1. This responds to several complaints over the past few years about UNIONs unexpectedly dropping length or precision info.
2006-08-10 04:36:29 +02:00
COMPARE_NODE_FIELD(colTypmods);
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
COMPARE_NODE_FIELD(colCollations);
Teach the system how to use hashing for UNION. (INTERSECT/EXCEPT will follow, but seem like a separate patch since most of the remaining work is on the executor side.) I took the opportunity to push selection of the grouping operators for set operations into the parser where it belongs. Otherwise this is just a small exercise in making prepunion.c consider both alternatives. As with the recent DISTINCT patch, this means we can UNION on datatypes that can hash but not sort, and it means that UNION without ORDER BY is no longer certain to produce sorted output.
2008-08-07 03:11:52 +02:00
COMPARE_NODE_FIELD(groupClauses);
Reimplementation of UNION/INTERSECT/EXCEPT. INTERSECT/EXCEPT now meet the SQL92 semantics, including support for ALL option. All three can be used in subqueries and views. DISTINCT and ORDER BY work now in views, too. This rewrite fixes many problems with cross-datatype UNIONs and INSERT/SELECT where the SELECT yields different datatypes than the INSERT needs. I did that by making UNION subqueries and SELECT in INSERT be treated like subselects-in-FROM, thereby allowing an extra level of targetlist where the datatype conversions can be inserted safely. INITDB NEEDED!
2000-10-05 21:11:39 +02:00
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterTableStmt(const AlterTableStmt *a, const AlterTableStmt *b)
Add equality checking for T_Query so that we don't get complaints in UNION regress test. Probably still need some more node types to be handled here, but I'm done for the day...
1999-02-07 01:52:12 +01:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(relation);
ALTER TABLE rewrite. New cool stuff: * ALTER ... ADD COLUMN with defaults and NOT NULL constraints works per SQL spec. A default is implemented by rewriting the table with the new value stored in each row. * ALTER COLUMN TYPE. You can change a column's datatype to anything you want, so long as you can specify how to convert the old value. Rewrites the table. (Possible future improvement: optimize no-op conversions such as varchar(N) to varchar(N+1).) * Multiple ALTER actions in a single ALTER TABLE command. You can perform any number of column additions, type changes, and constraint additions with only one pass over the table contents. Basic documentation provided in ALTER TABLE ref page, but some more docs work is needed. Original patch from Rod Taylor, additional work from Tom Lane.
2004-05-05 06:48:48 +02:00
COMPARE_NODE_FIELD(cmds);
Code review for ALTER INDEX patch.
2004-08-22 02:08:28 +02:00
COMPARE_SCALAR_FIELD(relkind);
ALTER <thing> [IF EXISTS] ... allows silent DDL if required, e.g. ALTER FOREIGN TABLE IF EXISTS foo RENAME TO bar Pavel Stehule
2012-01-24 00:25:04 +01:00
COMPARE_SCALAR_FIELD(missing_ok);
ALTER TABLE rewrite. New cool stuff: * ALTER ... ADD COLUMN with defaults and NOT NULL constraints works per SQL spec. A default is implemented by rewriting the table with the new value stored in each row. * ALTER COLUMN TYPE. You can change a column's datatype to anything you want, so long as you can specify how to convert the old value. Rewrites the table. (Possible future improvement: optimize no-op conversions such as varchar(N) to varchar(N+1).) * Multiple ALTER actions in a single ALTER TABLE command. You can perform any number of column additions, type changes, and constraint additions with only one pass over the table contents. Basic documentation provided in ALTER TABLE ref page, but some more docs work is needed. Original patch from Rod Taylor, additional work from Tom Lane.
2004-05-05 06:48:48 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterTableCmd(const AlterTableCmd *a, const AlterTableCmd *b)
ALTER TABLE rewrite. New cool stuff: * ALTER ... ADD COLUMN with defaults and NOT NULL constraints works per SQL spec. A default is implemented by rewriting the table with the new value stored in each row. * ALTER COLUMN TYPE. You can change a column's datatype to anything you want, so long as you can specify how to convert the old value. Rewrites the table. (Possible future improvement: optimize no-op conversions such as varchar(N) to varchar(N+1).) * Multiple ALTER actions in a single ALTER TABLE command. You can perform any number of column additions, type changes, and constraint additions with only one pass over the table contents. Basic documentation provided in ALTER TABLE ref page, but some more docs work is needed. Original patch from Rod Taylor, additional work from Tom Lane.
2004-05-05 06:48:48 +02:00
{
COMPARE_SCALAR_FIELD(subtype);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(name);
COMPARE_NODE_FIELD(def);
COMPARE_SCALAR_FIELD(behavior);
DROP IF EXISTS for columns and constraints. Andres Freund.
2009-07-20 04:42:28 +02:00
COMPARE_SCALAR_FIELD(missing_ok);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Re-addd Rod's ALTER DOMAIN patch.
2002-12-06 06:00:34 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterDomainStmt(const AlterDomainStmt *a, const AlterDomainStmt *b)
Re-addd Rod's ALTER DOMAIN patch.
2002-12-06 06:00:34 +01:00
{
COMPARE_SCALAR_FIELD(subtype);
Make backend header files C++ safe This alters various incidental uses of C++ key words to use other similar identifiers, so that a C++ compiler won't choke outright. You still (probably) need extern "C" { }; around the inclusion of backend headers. based on a patch by Kurt Harriman <harriman@acm.org> Also add a script cpluspluscheck to check for C++ compatibility in the future. As of right now, this passes without error for me.
2009-07-16 08:33:46 +02:00
COMPARE_NODE_FIELD(typeName);
Re-addd Rod's ALTER DOMAIN patch.
2002-12-06 06:00:34 +01:00
COMPARE_STRING_FIELD(name);
COMPARE_NODE_FIELD(def);
COMPARE_SCALAR_FIELD(behavior);
Improve ALTER DOMAIN / DROP CONSTRAINT with nonexistent constraint ALTER DOMAIN / DROP CONSTRAINT on a nonexistent constraint name did not report any error. Now it reports an error. The IF EXISTS option was added to get the usual behavior of ignoring nonexistent objects to drop.
2012-01-05 18:48:55 +01:00
COMPARE_SCALAR_FIELD(missing_ok);
Re-addd Rod's ALTER DOMAIN patch.
2002-12-06 06:00:34 +01:00
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalGrantStmt(const GrantStmt *a, const GrantStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(is_grant);
Support GRANT/REVOKE ON ALL TABLES/SEQUENCES/FUNCTIONS IN SCHEMA. Petr Jelinek
2009-10-12 22:39:42 +02:00
COMPARE_SCALAR_FIELD(targtype);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(objtype);
COMPARE_NODE_FIELD(objects);
Reimplement the linked list data structure used throughout the backend. In the past, we used a 'Lispy' linked list implementation: a "list" was merely a pointer to the head node of the list. The problem with that design is that it makes lappend() and length() linear time. This patch fixes that problem (and others) by maintaining a count of the list length and a pointer to the tail node along with each head node pointer. A "list" is now a pointer to a structure containing some meta-data about the list; the head and tail pointers in that structure refer to ListCell structures that maintain the actual linked list of nodes. The function names of the list API have also been changed to, I hope, be more logically consistent. By default, the old function names are still available; they will be disabled-by-default once the rest of the tree has been updated to use the new API names.
2004-05-26 06:41:50 +02:00
COMPARE_NODE_FIELD(privileges);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(grantees);
Grant options, and cascading revoke. Grant options are allowed only for users right now, not groups. Extension of has_foo_privileges functions to query the grant options. Extension of aclitem type to store grantor.
2003-01-24 00:39:07 +01:00
COMPARE_SCALAR_FIELD(grant_option);
COMPARE_SCALAR_FIELD(behavior);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Allow GRANT/REVOKE to/from more than one user per invocation. Command tag for GRANT/REVOKE is now just that, not "CHANGE". On the way, migrate some of the aclitem internal representation away from the parser and build a real parse tree instead. Also add some 'const' qualifiers.
2001-06-10 01:21:55 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalPrivGrantee(const PrivGrantee *a, const PrivGrantee *b)
Allow GRANT/REVOKE to/from more than one user per invocation. Command tag for GRANT/REVOKE is now just that, not "CHANGE". On the way, migrate some of the aclitem internal representation away from the parser and build a real parse tree instead. Also add some 'const' qualifiers.
2001-06-10 01:21:55 +02:00
{
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
COMPARE_STRING_FIELD(rolname);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
return true;
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
}
Allow GRANT/REVOKE to/from more than one user per invocation. Command tag for GRANT/REVOKE is now just that, not "CHANGE". On the way, migrate some of the aclitem internal representation away from the parser and build a real parse tree instead. Also add some 'const' qualifiers.
2001-06-10 01:21:55 +02:00
Privileges on functions and procedural languages
2002-02-19 00:11:58 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalFuncWithArgs(const FuncWithArgs *a, const FuncWithArgs *b)
Privileges on functions and procedural languages
2002-02-19 00:11:58 +01:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(funcname);
COMPARE_NODE_FIELD(funcargs);
return true;
Privileges on functions and procedural languages
2002-02-19 00:11:58 +01:00
}
Support column-level privileges, as required by SQL standard. Stephen Frost, with help from KaiGai Kohei and others
2009-01-22 21:16:10 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAccessPriv(const AccessPriv *a, const AccessPriv *b)
Support column-level privileges, as required by SQL standard. Stephen Frost, with help from KaiGai Kohei and others
2009-01-22 21:16:10 +01:00
{
COMPARE_STRING_FIELD(priv_name);
COMPARE_NODE_FIELD(cols);
return true;
}
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalGrantRoleStmt(const GrantRoleStmt *a, const GrantRoleStmt *b)
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
{
COMPARE_NODE_FIELD(granted_roles);
COMPARE_NODE_FIELD(grantee_roles);
COMPARE_SCALAR_FIELD(is_grant);
COMPARE_SCALAR_FIELD(admin_opt);
COMPARE_STRING_FIELD(grantor);
COMPARE_SCALAR_FIELD(behavior);
return true;
}
Create an ALTER DEFAULT PRIVILEGES command, which allows users to adjust the privileges that will be applied to subsequently-created objects. Such adjustments are always per owning role, and can be restricted to objects created in particular schemas too. A notable benefit is that users can override the traditional default privilege settings, eg, the PUBLIC EXECUTE privilege traditionally granted by default for functions. Petr Jelinek
2009-10-05 21:24:49 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *a, const AlterDefaultPrivilegesStmt *b)
Create an ALTER DEFAULT PRIVILEGES command, which allows users to adjust the privileges that will be applied to subsequently-created objects. Such adjustments are always per owning role, and can be restricted to objects created in particular schemas too. A notable benefit is that users can override the traditional default privilege settings, eg, the PUBLIC EXECUTE privilege traditionally granted by default for functions. Petr Jelinek
2009-10-05 21:24:49 +02:00
{
COMPARE_NODE_FIELD(options);
COMPARE_NODE_FIELD(action);
return true;
}
Restructure parsetree representation of DECLARE CURSOR: now it's a utility statement (DeclareCursorStmt) with a SELECT query dangling from it, rather than a SELECT query with a few unusual fields in it. Add code to determine whether a planned query can safely be run backwards. If DECLARE CURSOR specifies SCROLL, ensure that the plan can be run backwards by adding a Materialize plan node if it can't. Without SCROLL, you get an error if you try to fetch backwards from a cursor that can't handle it. (There is still some discussion about what the exact behavior should be, but this is necessary infrastructure in any case.) Along the way, make EXPLAIN DECLARE CURSOR work.
2003-03-10 04:53:52 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDeclareCursorStmt(const DeclareCursorStmt *a, const DeclareCursorStmt *b)
Restructure parsetree representation of DECLARE CURSOR: now it's a utility statement (DeclareCursorStmt) with a SELECT query dangling from it, rather than a SELECT query with a few unusual fields in it. Add code to determine whether a planned query can safely be run backwards. If DECLARE CURSOR specifies SCROLL, ensure that the plan can be run backwards by adding a Materialize plan node if it can't. Without SCROLL, you get an error if you try to fetch backwards from a cursor that can't handle it. (There is still some discussion about what the exact behavior should be, but this is necessary infrastructure in any case.) Along the way, make EXPLAIN DECLARE CURSOR work.
2003-03-10 04:53:52 +01:00
{
COMPARE_STRING_FIELD(portalname);
COMPARE_SCALAR_FIELD(options);
COMPARE_NODE_FIELD(query);
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalClosePortalStmt(const ClosePortalStmt *a, const ClosePortalStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(portalname);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalClusterStmt(const ClusterStmt *a, const ClusterStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(relation);
COMPARE_STRING_FIELD(indexname);
CLUSTER VERBOSE and corresponding clusterdb --verbose option Jim Cox and Peter Eisentraut
2008-11-24 09:46:04 +01:00
COMPARE_SCALAR_FIELD(verbose);
Add equality checking for T_Query so that we don't get complaints in UNION regress test. Probably still need some more node types to be handled here, but I'm done for the day...
1999-02-07 01:52:12 +01:00
return true;
}
Hmm, equalfuncs didn't know about SortClause or GroupClause nodes...
2000-01-31 02:21:39 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCopyStmt(const CopyStmt *a, const CopyStmt *b)
Hmm, equalfuncs didn't know about SortClause or GroupClause nodes...
2000-01-31 02:21:39 +01:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(relation);
Extend COPY to support COPY (SELECT ...) TO ... Bernd Helmle
2006-08-31 01:34:22 +02:00
COMPARE_NODE_FIELD(query);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(attlist);
COMPARE_SCALAR_FIELD(is_from);
Add support for piping COPY to/from an external program. This includes backend "COPY TO/FROM PROGRAM '...'" syntax, and corresponding psql \copy syntax. Like with reading/writing files, the backend version is superuser-only, and in the psql version, the program is run in the client. In the passing, the psql \copy STDIN/STDOUT syntax is subtly changed: if you the stdin/stdout is quoted, it's now interpreted as a filename. For example, "\copy foo from 'stdin'" now reads from a file called 'stdin', not from standard input. Before this, there was no way to specify a filename called stdin, stdout, pstdin or pstdout. This creates a new function in pgport, wait_result_to_str(), which can be used to convert the exit status of a process, as returned by wait(3), to a human-readable string. Etsuro Fujita, reviewed by Amit Kapila.
2013-02-27 17:17:21 +01:00
COMPARE_SCALAR_FIELD(is_program);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(filename);
COMPARE_NODE_FIELD(options);
Hmm, equalfuncs didn't know about SortClause or GroupClause nodes...
2000-01-31 02:21:39 +01:00
return true;
}
Add test code to copy all parse/plan trees. Repair essential omissions in copyfuncs and equalfuncs exposed by regression tests. We still have some work to do: these modules really ought to handle most or all of the utility statement node types. But it's better than it was.
2000-06-29 09:35:57 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateStmt(const CreateStmt *a, const CreateStmt *b)
Add test code to copy all parse/plan trees. Repair essential omissions in copyfuncs and equalfuncs exposed by regression tests. We still have some work to do: these modules really ought to handle most or all of the utility statement node types. But it's better than it was.
2000-06-29 09:35:57 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(relation);
COMPARE_NODE_FIELD(tableElts);
COMPARE_NODE_FIELD(inhRelations);
Type table feature This adds the CREATE TABLE name OF type command, per SQL standard.
2010-01-29 00:21:13 +01:00
COMPARE_NODE_FIELD(ofTypename);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(constraints);
Add FILLFACTOR to CREATE INDEX. ITAGAKI Takahiro
2006-07-02 04:23:23 +02:00
COMPARE_NODE_FIELD(options);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(oncommit);
Tablespaces. Alternate database locations are dead, long live tablespaces. There are various things left to do: contrib dbsize and oid2name modules need work, and so does the documentation. Also someone should think about COMMENT ON TABLESPACE and maybe RENAME TABLESPACE. Also initlocation is dead, it just doesn't know it yet. Gavin Sherry and Tom Lane.
2004-06-18 08:14:31 +02:00
COMPARE_STRING_FIELD(tablespacename);
CREATE TABLE IF NOT EXISTS. Reviewed by Bernd Helmle.
2010-07-26 01:21:22 +02:00
COMPARE_SCALAR_FIELD(if_not_exists);
Add test code to copy all parse/plan trees. Repair essential omissions in copyfuncs and equalfuncs exposed by regression tests. We still have some work to do: these modules really ought to handle most or all of the utility statement node types. But it's better than it was.
2000-06-29 09:35:57 +02:00
return true;
}
Includes: - LIKE <subtable> [ INCLUDING DEFAULTS | EXCLUDING DEFAULTS ] - Quick cleanup of analyze.c function prototypes. - New non-reserved keywords (INCLUDING, EXCLUDING, DEFAULTS), SQL 200X Opted not to extend for check constraints at this time. As per the definition that it's user defined columns, OIDs are NOT inherited. Doc and Source patches attached. -- Rod Taylor <rbt@rbt.ca>
2003-06-25 05:40:19 +02:00
static bool
Rename the internal structures of the CREATE TABLE (LIKE ...) facility The original implementation of this interpreted it as a kind of "inheritance" facility and named all the internal structures accordingly. This turned out to be very confusing, because it has nothing to do with the INHERITS feature. So rename all the internal parser infrastructure, update the comments, adjust the error messages, and split up the regression tests.
2012-01-07 13:58:13 +01:00
_equalTableLikeClause(const TableLikeClause *a, const TableLikeClause *b)
Includes: - LIKE <subtable> [ INCLUDING DEFAULTS | EXCLUDING DEFAULTS ] - Quick cleanup of analyze.c function prototypes. - New non-reserved keywords (INCLUDING, EXCLUDING, DEFAULTS), SQL 200X Opted not to extend for check constraints at this time. As per the definition that it's user defined columns, OIDs are NOT inherited. Doc and Source patches attached. -- Rod Taylor <rbt@rbt.ca>
2003-06-25 05:40:19 +02:00
{
COMPARE_NODE_FIELD(relation);
CREATE LIKE INCLUDING COMMENTS and STORAGE, and INCLUDING ALL shortcut. Itagaki Takahiro.
2009-10-12 21:49:24 +02:00
COMPARE_SCALAR_FIELD(options);
Includes: - LIKE <subtable> [ INCLUDING DEFAULTS | EXCLUDING DEFAULTS ] - Quick cleanup of analyze.c function prototypes. - New non-reserved keywords (INCLUDING, EXCLUDING, DEFAULTS), SQL 200X Opted not to extend for check constraints at this time. As per the definition that it's user defined columns, OIDs are NOT inherited. Doc and Source patches attached. -- Rod Taylor <rbt@rbt.ca>
2003-06-25 05:40:19 +02:00
return true;
}
Add equal() funcs for Case nodes ... amazing we had not detected this omission before. Miscellaneous other cleanups.
1999-07-29 04:45:36 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDefineStmt(const DefineStmt *a, const DefineStmt *b)
Add equal() funcs for Case nodes ... amazing we had not detected this omission before. Miscellaneous other cleanups.
1999-07-29 04:45:36 +02:00
{
Get rid of last few vestiges of parsetree dependency on grammar token codes, per discussion from last March. parse.h should now be included *only* by gram.y, scan.l, keywords.c, parser.c. This prevents surprising misbehavior after seemingly-trivial grammar adjustments.
2003-02-10 05:44:47 +01:00
COMPARE_SCALAR_FIELD(kind);
Support the syntax CREATE AGGREGATE aggname (input_type) (parameter_list) along with the old syntax where the input type was named in the parameter list. This fits more naturally with the way that the aggregate is identified in DROP AGGREGATE and other utility commands; furthermore it has a natural extension to handle multiple-input aggregates, where the basetype-parameter method would get ugly. In fact, this commit fixes the grammar and all the utility commands to support multiple-input aggregates; but DefineAggregate rejects it because the executor isn't fixed yet. I didn't do anything about treating agg(*) as a zero-input aggregate instead of artificially making it a one-input aggregate, but that should be considered in combination with supporting multi-input aggregates.
2006-04-15 19:45:46 +02:00
COMPARE_SCALAR_FIELD(oldstyle);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(defnames);
Support the syntax CREATE AGGREGATE aggname (input_type) (parameter_list) along with the old syntax where the input type was named in the parameter list. This fits more naturally with the way that the aggregate is identified in DROP AGGREGATE and other utility commands; furthermore it has a natural extension to handle multiple-input aggregates, where the basetype-parameter method would get ugly. In fact, this commit fixes the grammar and all the utility commands to support multiple-input aggregates; but DefineAggregate rejects it because the executor isn't fixed yet. I didn't do anything about treating agg(*) as a zero-input aggregate instead of artificially making it a one-input aggregate, but that should be considered in combination with supporting multi-input aggregates.
2006-04-15 19:45:46 +02:00
COMPARE_NODE_FIELD(args);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(definition);
Add equal() funcs for Case nodes ... amazing we had not detected this omission before. Miscellaneous other cleanups.
1999-07-29 04:45:36 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDropStmt(const DropStmt *a, const DropStmt *b)
Add equal() funcs for Case nodes ... amazing we had not detected this omission before. Miscellaneous other cleanups.
1999-07-29 04:45:36 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(objects);
Further consolidation of DROP statement handling. This gets rid of an impressive amount of duplicative code, with only minimal behavior changes. DROP FOREIGN DATA WRAPPER now requires object ownership rather than superuser privileges, matching the documentation we already have. We also eliminate the historical warning about dropping a built-in function as unuseful. All operations are now performed in the same order for all object types handled by dropcmds.c. KaiGai Kohei, with minor revisions by me
2011-11-18 03:31:29 +01:00
COMPARE_NODE_FIELD(arguments);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(removeType);
COMPARE_SCALAR_FIELD(behavior);
Clean up after DROP IF EXISTS patch.
2005-11-21 00:24:12 +01:00
COMPARE_SCALAR_FIELD(missing_ok);
Add DROP INDEX CONCURRENTLY [IF EXISTS], uses ShareUpdateExclusiveLock
2012-04-06 11:21:40 +02:00
COMPARE_SCALAR_FIELD(concurrent);
Add equal() funcs for Case nodes ... amazing we had not detected this omission before. Miscellaneous other cleanups.
1999-07-29 04:45:36 +02:00
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalTruncateStmt(const TruncateStmt *a, const TruncateStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Generalize TRUNCATE to support truncating multiple tables in one command. This is useful because we can allow truncation of tables referenced by foreign keys, so long as the referencing table is truncated in the same command. Alvaro Herrera
2005-01-27 04:19:37 +01:00
COMPARE_NODE_FIELD(relations);
Add a RESTART (without parameter) option to ALTER SEQUENCE, allowing a sequence to be reset to its original starting value. This requires adding the original start value to the set of parameters (columns) of a sequence object, which is a user-visible change with potential compatibility implications; it also forces initdb. Also add hopefully-SQL-compatible RESTART/CONTINUE IDENTITY options to TRUNCATE TABLE. RESTART IDENTITY executes ALTER SEQUENCE RESTART for all sequences "owned by" any of the truncated relations. CONTINUE IDENTITY is a no-op option. Zoltan Boszormenyi
2008-05-17 01:36:05 +02:00
COMPARE_SCALAR_FIELD(restart_seqs);
Add CASCADE option to TRUNCATE. Joachim Wieland
2006-03-03 04:30:54 +01:00
COMPARE_SCALAR_FIELD(behavior);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Add equality checking for T_Query so that we don't get complaints in UNION regress test. Probably still need some more node types to be handled here, but I'm done for the day...
1999-02-07 01:52:12 +01:00
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCommentStmt(const CommentStmt *a, const CommentStmt *b)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(objtype);
COMPARE_NODE_FIELD(objname);
COMPARE_NODE_FIELD(objargs);
COMPARE_STRING_FIELD(comment);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 07:04:48 +02:00
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Add a SECURITY LABEL command. This is intended as infrastructure to support integration with label-based mandatory access control systems such as SE-Linux. Further changes (mostly hooks) will be needed, but this is a big chunk of it. KaiGai Kohei and Robert Haas
2010-09-28 02:55:27 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalSecLabelStmt(const SecLabelStmt *a, const SecLabelStmt *b)
Add a SECURITY LABEL command. This is intended as infrastructure to support integration with label-based mandatory access control systems such as SE-Linux. Further changes (mostly hooks) will be needed, but this is a big chunk of it. KaiGai Kohei and Robert Haas
2010-09-28 02:55:27 +02:00
{
COMPARE_SCALAR_FIELD(objtype);
COMPARE_NODE_FIELD(objname);
COMPARE_NODE_FIELD(objargs);
COMPARE_STRING_FIELD(provider);
COMPARE_STRING_FIELD(label);
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalFetchStmt(const FetchStmt *a, const FetchStmt *b)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(direction);
COMPARE_SCALAR_FIELD(howMany);
COMPARE_STRING_FIELD(portalname);
COMPARE_SCALAR_FIELD(ismove);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 07:04:48 +02:00
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalIndexStmt(const IndexStmt *a, const IndexStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(idxname);
COMPARE_NODE_FIELD(relation);
COMPARE_STRING_FIELD(accessMethod);
Tablespaces. Alternate database locations are dead, long live tablespaces. There are various things left to do: contrib dbsize and oid2name modules need work, and so does the documentation. Also someone should think about COMMENT ON TABLESPACE and maybe RENAME TABLESPACE. Also initlocation is dead, it just doesn't know it yet. Gavin Sherry and Tom Lane.
2004-06-18 08:14:31 +02:00
COMPARE_STRING_FIELD(tableSpace);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(indexParams);
Add FILLFACTOR to CREATE INDEX. ITAGAKI Takahiro
2006-07-02 04:23:23 +02:00
COMPARE_NODE_FIELD(options);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(whereClause);
Add exclusion constraints, which generalize the concept of uniqueness to support any indexable commutative operator, not just equality. Two rows violate the exclusion constraint if "row1.col OP row2.col" is TRUE for each of the columns in the constraint. Jeff Davis, reviewed by Robert Haas
2009-12-07 06:22:23 +01:00
COMPARE_NODE_FIELD(excludeOpNames);
Avoid pre-determining index names during CREATE TABLE LIKE parsing. Formerly, when trying to copy both indexes and comments, CREATE TABLE LIKE had to pre-assign names to indexes that had comments, because it made up an explicit CommentStmt command to apply the comment and so it had to know the name for the index. This creates bad interactions with other indexes, as shown in bug #6734 from Daniele Varrazzo: the preassignment logic couldn't take any other indexes into account so it could choose a conflicting name. To fix, add a field to IndexStmt that allows it to carry a comment to be assigned to the new index. (This isn't a user-exposed feature of CREATE INDEX, only an internal option.) Now we don't need preassignment of index names in any situation. I also took the opportunity to refactor DefineIndex to accept the IndexStmt as such, rather than passing all its fields individually in a mile-long parameter list. Back-patch to 9.2, but no further, because it seems too dangerous to change IndexStmt or DefineIndex's API in released branches. The bug exists back to 9.0 where CREATE TABLE LIKE grew the ability to copy comments, but given the lack of prior complaints we'll just let it go unfixed before 9.2.
2012-07-16 19:25:18 +02:00
COMPARE_STRING_FIELD(idxcomment);
Implement ALTER TABLE ADD UNIQUE/PRIMARY KEY USING INDEX. This feature allows a unique or pkey constraint to be created using an already-existing unique index. While the constraint isn't very functionally different from the bare index, it's nice to be able to do that for documentation purposes. The main advantage over just issuing a plain ALTER TABLE ADD UNIQUE/PRIMARY KEY is that the index can be created with CREATE INDEX CONCURRENTLY, so that there is not a long interval where the table is locked against updates. On the way, refactor some of the code in DefineIndex() and index_create() so that we don't have to pass through those functions in order to create the index constraint's catalog entries. Also, in parse_utilcmd.c, pass around the ParseState pointer in struct CreateStmtContext to save on notation, and add error location pointers to some error reports that didn't have one before. Gurjeet Singh, reviewed by Steve Singer and Tom Lane
2011-01-25 21:42:03 +01:00
COMPARE_SCALAR_FIELD(indexOid);
Avoid index rebuild for no-rewrite ALTER TABLE .. ALTER TYPE. Noah Misch. Review and minor cosmetic changes by me.
2011-07-18 17:02:48 +02:00
COMPARE_SCALAR_FIELD(oldNode);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(unique);
COMPARE_SCALAR_FIELD(primary);
COMPARE_SCALAR_FIELD(isconstraint);
Support deferrable uniqueness constraints. The current implementation fires an AFTER ROW trigger for each tuple that looks like it might be non-unique according to the index contents at the time of insertion. This works well as long as there aren't many conflicts, but won't scale to massive unique-key reassignments. Improving that case is a TODO item. Dean Rasheed
2009-07-29 22:56:21 +02:00
COMPARE_SCALAR_FIELD(deferrable);
COMPARE_SCALAR_FIELD(initdeferred);
Add the ability to create indexes 'concurrently', that is, without blocking concurrent writes to the table. Greg Stark, with a little help from Tom Lane.
2006-08-25 06:06:58 +02:00
COMPARE_SCALAR_FIELD(concurrent);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 07:04:48 +02:00
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateFunctionStmt(const CreateFunctionStmt *a, const CreateFunctionStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(replace);
COMPARE_NODE_FIELD(funcname);
Apply the core parts of Dennis Bjorklund's patch to allow function parameters to be declared with names. pg_proc has a column to store names, and CREATE FUNCTION can insert data into it, but that's all as yet. I need to do more work on the pg_dump and plpgsql portions of the patch before committing those, but I thought I'd get the bulky changes in before the tree drifts under me. initdb forced due to pg_proc change.
2004-01-07 00:55:19 +01:00
COMPARE_NODE_FIELD(parameters);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(returnType);
COMPARE_NODE_FIELD(options);
COMPARE_NODE_FIELD(withClause);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 07:04:48 +02:00
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Apply the core parts of Dennis Bjorklund's patch to allow function parameters to be declared with names. pg_proc has a column to store names, and CREATE FUNCTION can insert data into it, but that's all as yet. I need to do more work on the pg_dump and plpgsql portions of the patch before committing those, but I thought I'd get the bulky changes in before the tree drifts under me. initdb forced due to pg_proc change.
2004-01-07 00:55:19 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalFunctionParameter(const FunctionParameter *a, const FunctionParameter *b)
Apply the core parts of Dennis Bjorklund's patch to allow function parameters to be declared with names. pg_proc has a column to store names, and CREATE FUNCTION can insert data into it, but that's all as yet. I need to do more work on the pg_dump and plpgsql portions of the patch before committing those, but I thought I'd get the bulky changes in before the tree drifts under me. initdb forced due to pg_proc change.
2004-01-07 00:55:19 +01:00
{
COMPARE_STRING_FIELD(name);
COMPARE_NODE_FIELD(argType);
Fix grammar for IN/OUT/INOUT parameters. This commit doesn't actually implement any new feature, it just pushes the 'not implemented' error message deeper into the backend. I also tweaked the grammar to accept Oracle-ish parameter syntax (parameter name first), as well as the SQL99 standard syntax (parameter mode first), since it was easy and people will doubtless try to use both anyway.
2005-03-29 19:58:51 +02:00
COMPARE_SCALAR_FIELD(mode);
Default values for function arguments Pavel Stehule, with some tweaks by Peter Eisentraut
2008-12-04 18:51:28 +01:00
COMPARE_NODE_FIELD(defexpr);
Apply the core parts of Dennis Bjorklund's patch to allow function parameters to be declared with names. pg_proc has a column to store names, and CREATE FUNCTION can insert data into it, but that's all as yet. I need to do more work on the pg_dump and plpgsql portions of the patch before committing those, but I thought I'd get the bulky changes in before the tree drifts under me. initdb forced due to pg_proc change.
2004-01-07 00:55:19 +01:00
return true;
}
Allow ALTER FUNCTION to change a function's strictness, volatility, and whether or not it is a security definer. Changing a function's strictness is required by SQL2003, and the other capabilities make sense. Also, allow an optional RESTRICT noise word to be specified, for SQL conformance. Some trivial regression tests added and the documentation has been updated.
2005-03-14 01:19:37 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterFunctionStmt(const AlterFunctionStmt *a, const AlterFunctionStmt *b)
Allow ALTER FUNCTION to change a function's strictness, volatility, and whether or not it is a security definer. Changing a function's strictness is required by SQL2003, and the other capabilities make sense. Also, allow an optional RESTRICT noise word to be specified, for SQL conformance. Some trivial regression tests added and the documentation has been updated.
2005-03-14 01:19:37 +01:00
{
COMPARE_NODE_FIELD(func);
COMPARE_NODE_FIELD(actions);
return true;
}
Implement the DO statement to support execution of PL code without having to create a function for it. Procedural languages now have an additional entry point, namely a function to execute an inline code block. This seemed a better design than trying to hide the transient-ness of the code from the PL. As of this patch, only plpgsql has an inline handler, but probably people will soon write handlers for the other standard PLs. In passing, remove the long-dead LANCOMPILER option of CREATE LANGUAGE. Petr Jelinek
2009-09-23 01:43:43 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDoStmt(const DoStmt *a, const DoStmt *b)
Implement the DO statement to support execution of PL code without having to create a function for it. Procedural languages now have an additional entry point, namely a function to execute an inline code block. This seemed a better design than trying to hide the transient-ness of the code from the PL. As of this patch, only plpgsql has an inline handler, but probably people will soon write handlers for the other standard PLs. In passing, remove the long-dead LANCOMPILER option of CREATE LANGUAGE. Petr Jelinek
2009-09-23 01:43:43 +02:00
{
COMPARE_NODE_FIELD(args);
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalRenameStmt(const RenameStmt *a, const RenameStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Add ALTER object SET SCHEMA capability for a limited but useful set of object kinds (tables, functions, types). Documentation is not here yet. Original code by Bernd Helmle, extensive rework by Bruce Momjian and Tom Lane.
2005-08-01 06:03:59 +02:00
COMPARE_SCALAR_FIELD(renameType);
Fix various infelicities in node functions. Mostly, this consists of adding support for fields which exist in the structure but aren't handled by copy/equal/outfuncs; but the create foreign table case can actually produce garbage output. Noah Misch
2012-04-18 16:43:16 +02:00
COMPARE_SCALAR_FIELD(relationType);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(relation);
First batch of object rename commands.
2003-06-27 16:45:32 +02:00
COMPARE_NODE_FIELD(object);
COMPARE_NODE_FIELD(objarg);
COMPARE_STRING_FIELD(subname);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(newname);
Propagate ALTER TYPE operations to typed tables This adds RESTRICT/CASCADE flags to ALTER TYPE ... ADD/DROP/ALTER/ RENAME ATTRIBUTE to control whether to alter typed tables as well.
2010-11-23 21:50:17 +01:00
COMPARE_SCALAR_FIELD(behavior);
ALTER <thing> [IF EXISTS] ... allows silent DDL if required, e.g. ALTER FOREIGN TABLE IF EXISTS foo RENAME TO bar Pavel Stehule
2012-01-24 00:25:04 +01:00
COMPARE_SCALAR_FIELD(missing_ok);
Add ALTER object SET SCHEMA capability for a limited but useful set of object kinds (tables, functions, types). Documentation is not here yet. Original code by Bernd Helmle, extensive rework by Bruce Momjian and Tom Lane.
2005-08-01 06:03:59 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt *a, const AlterObjectSchemaStmt *b)
Add ALTER object SET SCHEMA capability for a limited but useful set of object kinds (tables, functions, types). Documentation is not here yet. Original code by Bernd Helmle, extensive rework by Bruce Momjian and Tom Lane.
2005-08-01 06:03:59 +02:00
{
COMPARE_SCALAR_FIELD(objectType);
COMPARE_NODE_FIELD(relation);
COMPARE_NODE_FIELD(object);
COMPARE_NODE_FIELD(objarg);
COMPARE_STRING_FIELD(newschema);
ALTER <thing> [IF EXISTS] ... allows silent DDL if required, e.g. ALTER FOREIGN TABLE IF EXISTS foo RENAME TO bar Pavel Stehule
2012-01-24 00:25:04 +01:00
COMPARE_SCALAR_FIELD(missing_ok);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Support renaming of tablespaces, and changing the owners of aggregates, conversions, functions, operators, operator classes, schemas, types, and tablespaces. Fold the existing implementations of alter domain owner and alter database owner in with these. Christopher Kings-Lynne
2004-06-25 23:55:59 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterOwnerStmt(const AlterOwnerStmt *a, const AlterOwnerStmt *b)
Support renaming of tablespaces, and changing the owners of aggregates, conversions, functions, operators, operator classes, schemas, types, and tablespaces. Fold the existing implementations of alter domain owner and alter database owner in with these. Christopher Kings-Lynne
2004-06-25 23:55:59 +02:00
{
Add ALTER object SET SCHEMA capability for a limited but useful set of object kinds (tables, functions, types). Documentation is not here yet. Original code by Bernd Helmle, extensive rework by Bruce Momjian and Tom Lane.
2005-08-01 06:03:59 +02:00
COMPARE_SCALAR_FIELD(objectType);
Support renaming of tablespaces, and changing the owners of aggregates, conversions, functions, operators, operator classes, schemas, types, and tablespaces. Fold the existing implementations of alter domain owner and alter database owner in with these. Christopher Kings-Lynne
2004-06-25 23:55:59 +02:00
COMPARE_NODE_FIELD(relation);
COMPARE_NODE_FIELD(object);
COMPARE_NODE_FIELD(objarg);
COMPARE_STRING_FIELD(newowner);
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalRuleStmt(const RuleStmt *a, const RuleStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(relation);
COMPARE_STRING_FIELD(rulename);
COMPARE_NODE_FIELD(whereClause);
COMPARE_SCALAR_FIELD(event);
COMPARE_SCALAR_FIELD(instead);
COMPARE_NODE_FIELD(actions);
COMPARE_SCALAR_FIELD(replace);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalNotifyStmt(const NotifyStmt *a, const NotifyStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Add a bunch of new error location reports to parse-analysis error messages. There are still some weak spots around JOIN USING and relation alias lists, but most errors reported within backend/parser/ now have locations.
2008-09-01 22:42:46 +02:00
COMPARE_STRING_FIELD(conditionname);
Replace the pg_listener-based LISTEN/NOTIFY mechanism with an in-memory queue. In addition, add support for a "payload" string to be passed along with each notify event. This implementation should be significantly more efficient than the old one, and is also more compatible with Hot Standby usage. There is not yet any facility for HS slaves to receive notifications generated on the master, although such a thing is possible in future. Joachim Wieland, reviewed by Jeff Davis; also hacked on by me.
2010-02-16 23:34:57 +01:00
COMPARE_STRING_FIELD(payload);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalListenStmt(const ListenStmt *a, const ListenStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Add a bunch of new error location reports to parse-analysis error messages. There are still some weak spots around JOIN USING and relation alias lists, but most errors reported within backend/parser/ now have locations.
2008-09-01 22:42:46 +02:00
COMPARE_STRING_FIELD(conditionname);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalUnlistenStmt(const UnlistenStmt *a, const UnlistenStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Add a bunch of new error location reports to parse-analysis error messages. There are still some weak spots around JOIN USING and relation alias lists, but most errors reported within backend/parser/ now have locations.
2008-09-01 22:42:46 +02:00
COMPARE_STRING_FIELD(conditionname);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalTransactionStmt(const TransactionStmt *a, const TransactionStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Get rid of last few vestiges of parsetree dependency on grammar token codes, per discussion from last March. parse.h should now be included *only* by gram.y, scan.l, keywords.c, parser.c. This prevents surprising misbehavior after seemingly-trivial grammar adjustments.
2003-02-10 05:44:47 +01:00
COMPARE_SCALAR_FIELD(kind);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(options);
Two-phase commit. Original patch by Heikki Linnakangas, with additional hacking by Alvaro Herrera and Tom Lane.
2005-06-18 00:32:51 +02:00
COMPARE_STRING_FIELD(gid);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Tom Lane wrote: > There's no longer a separate call to heap_storage_create in that routine > --- the right place to make the test is now in the storage_create > boolean parameter being passed to heap_create. A simple change, but > it passeth patch's understanding ... Thanks. Attached is a patch against cvs tip as of 8:30 PM PST or so. Turned out that even after fixing the failed hunks, there was a new spot in bufmgr.c which needed to be fixed (related to temp relations; RelationUpdateNumberOfBlocks). But thankfully the regression test code caught it :-) Joe Conway
2002-08-15 18:36:08 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCompositeTypeStmt(const CompositeTypeStmt *a, const CompositeTypeStmt *b)
Tom Lane wrote: > There's no longer a separate call to heap_storage_create in that routine > --- the right place to make the test is now in the storage_create > boolean parameter being passed to heap_create. A simple change, but > it passeth patch's understanding ... Thanks. Attached is a patch against cvs tip as of 8:30 PM PST or so. Turned out that even after fixing the failed hunks, there was a new spot in bufmgr.c which needed to be fixed (related to temp relations; RelationUpdateNumberOfBlocks). But thankfully the regression test code caught it :-) Joe Conway
2002-08-15 18:36:08 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(typevar);
COMPARE_NODE_FIELD(coldeflist);
Tom Lane wrote: > There's no longer a separate call to heap_storage_create in that routine > --- the right place to make the test is now in the storage_create > boolean parameter being passed to heap_create. A simple change, but > it passeth patch's understanding ... Thanks. Attached is a patch against cvs tip as of 8:30 PM PST or so. Turned out that even after fixing the failed hunks, there was a new spot in bufmgr.c which needed to be fixed (related to temp relations; RelationUpdateNumberOfBlocks). But thankfully the regression test code caught it :-) Joe Conway
2002-08-15 18:36:08 +02:00
return true;
}
Support enum data types. Along the way, use macros for the values of pg_type.typtype whereever practical. Tom Dunstan, with some kibitzing from Tom Lane.
2007-04-02 05:49:42 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateEnumStmt(const CreateEnumStmt *a, const CreateEnumStmt *b)
Support enum data types. Along the way, use macros for the values of pg_type.typtype whereever practical. Tom Dunstan, with some kibitzing from Tom Lane.
2007-04-02 05:49:42 +02:00
{
Make backend header files C++ safe This alters various incidental uses of C++ key words to use other similar identifiers, so that a C++ compiler won't choke outright. You still (probably) need extern "C" { }; around the inclusion of backend headers. based on a patch by Kurt Harriman <harriman@acm.org> Also add a script cpluspluscheck to check for C++ compatibility in the future. As of right now, this passes without error for me.
2009-07-16 08:33:46 +02:00
COMPARE_NODE_FIELD(typeName);
Support enum data types. Along the way, use macros for the values of pg_type.typtype whereever practical. Tom Dunstan, with some kibitzing from Tom Lane.
2007-04-02 05:49:42 +02:00
COMPARE_NODE_FIELD(vals);
return true;
}
Support range data types. Selectivity estimation functions are missing for some range type operators, which is a TODO. Jeff Davis
2011-11-03 12:16:28 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateRangeStmt(const CreateRangeStmt *a, const CreateRangeStmt *b)
Support range data types. Selectivity estimation functions are missing for some range type operators, which is a TODO. Jeff Davis
2011-11-03 12:16:28 +01:00
{
COMPARE_NODE_FIELD(typeName);
COMPARE_NODE_FIELD(params);
return true;
}
Allow new values to be added to an existing enum type. After much expenditure of effort, we've got this to the point where the performance penalty is pretty minimal in typical cases. Andrew Dunstan, reviewed by Brendan Jurd, Dean Rasheed, and Tom Lane
2010-10-25 05:04:37 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterEnumStmt(const AlterEnumStmt *a, const AlterEnumStmt *b)
Allow new values to be added to an existing enum type. After much expenditure of effort, we've got this to the point where the performance penalty is pretty minimal in typical cases. Andrew Dunstan, reviewed by Brendan Jurd, Dean Rasheed, and Tom Lane
2010-10-25 05:04:37 +02:00
{
COMPARE_NODE_FIELD(typeName);
COMPARE_STRING_FIELD(newVal);
COMPARE_STRING_FIELD(newValNeighbor);
COMPARE_SCALAR_FIELD(newValIsAfter);
Allow IF NOT EXISTS when add a new enum label. If the label is already in the enum the statement becomes a no-op. This will reduce the pain that comes from our not allowing this operation inside a transaction block. Andrew Dunstan, reviewed by Tom Lane and Magnus Hagander.
2012-09-22 18:53:31 +02:00
COMPARE_SCALAR_FIELD(skipIfExists);
Allow new values to be added to an existing enum type. After much expenditure of effort, we've got this to the point where the performance penalty is pretty minimal in typical cases. Andrew Dunstan, reviewed by Brendan Jurd, Dean Rasheed, and Tom Lane
2010-10-25 05:04:37 +02:00
return true;
}
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalViewStmt(const ViewStmt *a, const ViewStmt *b)
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
{
COMPARE_NODE_FIELD(view);
COMPARE_NODE_FIELD(aliases);
COMPARE_NODE_FIELD(query);
COMPARE_SCALAR_FIELD(replace);
Fix various infelicities in node functions. Mostly, this consists of adding support for fields which exist in the structure but aren't handled by copy/equal/outfuncs; but the create foreign table case can actually produce garbage output. Noah Misch
2012-04-18 16:43:16 +02:00
COMPARE_NODE_FIELD(options);
WITH CHECK OPTION support for auto-updatable VIEWs For simple views which are automatically updatable, this patch allows the user to specify what level of checking should be done on records being inserted or updated. For 'LOCAL CHECK', new tuples are validated against the conditionals of the view they are being inserted into, while for 'CASCADED CHECK' the new tuples are validated against the conditionals for all views involved (from the top down). This option is part of the SQL specification. Dean Rasheed, reviewed by Pavel Stehule
2013-07-18 23:10:16 +02:00
COMPARE_SCALAR_FIELD(withCheckOption);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalLoadStmt(const LoadStmt *a, const LoadStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(filename);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Add DOMAIN support. Includes manual pages and regression tests, from Rod Taylor.
2002-03-19 03:18:25 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateDomainStmt(const CreateDomainStmt *a, const CreateDomainStmt *b)
Add DOMAIN support. Includes manual pages and regression tests, from Rod Taylor.
2002-03-19 03:18:25 +01:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(domainname);
Make backend header files C++ safe This alters various incidental uses of C++ key words to use other similar identifiers, so that a C++ compiler won't choke outright. You still (probably) need extern "C" { }; around the inclusion of backend headers. based on a patch by Kurt Harriman <harriman@acm.org> Also add a script cpluspluscheck to check for C++ compatibility in the future. As of right now, this passes without error for me.
2009-07-16 08:33:46 +02:00
COMPARE_NODE_FIELD(typeName);
Remove collation information from TypeName, where it does not belong. The initial collations patch treated a COLLATE spec as part of a TypeName, following what can only be described as brain fade on the part of the SQL committee. It's a lot more reasonable to treat COLLATE as a syntactically separate object, so that it can be added in only the productions where it actually belongs, rather than needing to reject it in a boatload of places where it doesn't belong (something the original patch mostly failed to do). In addition this change lets us meet the spec's requirement to allow COLLATE anywhere in the clauses of a ColumnDef, and it avoids unfriendly behavior for constructs such as "foo::type COLLATE collation". To do this, pull collation information out of TypeName and put it in ColumnDef instead, thus reverting most of the collation-related changes in parse_type.c's API. I made one additional structural change, which was to use a ColumnDef as an intermediate node in AT_AlterColumnType AlterTableCmd nodes. This provides enough room to get rid of the "transform" wart in AlterTableCmd too, since the ColumnDef can carry the USING expression easily enough. Also fix some other minor bugs that have crept in in the same areas, like failure to copy recently-added fields of ColumnDef in copyfuncs.c. While at it, document the formerly secret ability to specify a collation in ALTER TABLE ALTER COLUMN TYPE, ALTER TYPE ADD ATTRIBUTE, and ALTER TYPE ALTER ATTRIBUTE TYPE; and correct some misstatements about what the default collation selection will be when COLLATE is omitted. BTW, the three-parameter form of format_type() should go away too, since it just contributes to the confusion in this area; but I'll do that in a separate patch.
2011-03-10 04:38:52 +01:00
COMPARE_NODE_FIELD(collClause);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(constraints);
Add DOMAIN support. Includes manual pages and regression tests, from Rod Taylor.
2002-03-19 03:18:25 +01:00
return true;
}
Implement CREATE/DROP OPERATOR CLASS. Work still remains: need more documentation (xindex.sgml should be rewritten), need to teach pg_dump about it, need to update contrib modules that currently build pg_opclass entries by hand. Original patch by Bill Studenmund, grammar adjustments and general update for 7.3 by Tom Lane.
2002-07-30 00:14:11 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateOpClassStmt(const CreateOpClassStmt *a, const CreateOpClassStmt *b)
Implement CREATE/DROP OPERATOR CLASS. Work still remains: need more documentation (xindex.sgml should be rewritten), need to teach pg_dump about it, need to update contrib modules that currently build pg_opclass entries by hand. Original patch by Bill Studenmund, grammar adjustments and general update for 7.3 by Tom Lane.
2002-07-30 00:14:11 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(opclassname);
Restructure operator classes to allow improved handling of cross-data-type cases. Operator classes now exist within "operator families". While most families are equivalent to a single class, related classes can be grouped into one family to represent the fact that they are semantically compatible. Cross-type operators are now naturally adjunct parts of a family, without having to wedge them into a particular opclass as we had done originally. This commit restructures the catalogs and cleans up enough of the fallout so that everything still works at least as well as before, but most of the work needed to actually improve the planner's behavior will come later. Also, there are not yet CREATE/DROP/ALTER OPERATOR FAMILY commands; the only way to create a new family right now is to allow CREATE OPERATOR CLASS to make one by default. I owe some more documentation work, too. But that can all be done in smaller pieces once this infrastructure is in place.
2006-12-23 01:43:13 +01:00
COMPARE_NODE_FIELD(opfamilyname);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(amname);
COMPARE_NODE_FIELD(datatype);
COMPARE_NODE_FIELD(items);
COMPARE_SCALAR_FIELD(isDefault);
Implement CREATE/DROP OPERATOR CLASS. Work still remains: need more documentation (xindex.sgml should be rewritten), need to teach pg_dump about it, need to update contrib modules that currently build pg_opclass entries by hand. Original patch by Bill Studenmund, grammar adjustments and general update for 7.3 by Tom Lane.
2002-07-30 00:14:11 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateOpClassItem(const CreateOpClassItem *a, const CreateOpClassItem *b)
Implement CREATE/DROP OPERATOR CLASS. Work still remains: need more documentation (xindex.sgml should be rewritten), need to teach pg_dump about it, need to update contrib modules that currently build pg_opclass entries by hand. Original patch by Bill Studenmund, grammar adjustments and general update for 7.3 by Tom Lane.
2002-07-30 00:14:11 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(itemtype);
COMPARE_NODE_FIELD(name);
COMPARE_NODE_FIELD(args);
COMPARE_SCALAR_FIELD(number);
Create the system catalog infrastructure needed for KNNGIST. This commit adds columns amoppurpose and amopsortfamily to pg_amop, and column amcanorderbyop to pg_am. For the moment all the entries in amcanorderbyop are "false", since the underlying support isn't there yet. Also, extend the CREATE OPERATOR CLASS/ALTER OPERATOR FAMILY commands with [ FOR SEARCH | FOR ORDER BY sort_operator_family ] clauses to allow the new columns of pg_amop to be populated, and create pg_dump support for dumping that information. I also added some documentation, although it's perhaps a bit premature given that the feature doesn't do anything useful yet. Teodor Sigaev, Robert Haas, Tom Lane
2010-11-24 20:20:39 +01:00
COMPARE_NODE_FIELD(order_family);
Add CREATE/ALTER/DROP OPERATOR FAMILY commands, also COMMENT ON OPERATOR FAMILY; and add FAMILY option to CREATE OPERATOR CLASS to allow adding a class to a pre-existing family. Per previous discussion. Man, what a tedious lot of cutting and pasting ...
2007-01-23 06:07:18 +01:00
COMPARE_NODE_FIELD(class_args);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(storedtype);
Implement CREATE/DROP OPERATOR CLASS. Work still remains: need more documentation (xindex.sgml should be rewritten), need to teach pg_dump about it, need to update contrib modules that currently build pg_opclass entries by hand. Original patch by Bill Studenmund, grammar adjustments and general update for 7.3 by Tom Lane.
2002-07-30 00:14:11 +02:00
return true;
}
Add CREATE/ALTER/DROP OPERATOR FAMILY commands, also COMMENT ON OPERATOR FAMILY; and add FAMILY option to CREATE OPERATOR CLASS to allow adding a class to a pre-existing family. Per previous discussion. Man, what a tedious lot of cutting and pasting ...
2007-01-23 06:07:18 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateOpFamilyStmt(const CreateOpFamilyStmt *a, const CreateOpFamilyStmt *b)
Add CREATE/ALTER/DROP OPERATOR FAMILY commands, also COMMENT ON OPERATOR FAMILY; and add FAMILY option to CREATE OPERATOR CLASS to allow adding a class to a pre-existing family. Per previous discussion. Man, what a tedious lot of cutting and pasting ...
2007-01-23 06:07:18 +01:00
{
COMPARE_NODE_FIELD(opfamilyname);
COMPARE_STRING_FIELD(amname);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterOpFamilyStmt(const AlterOpFamilyStmt *a, const AlterOpFamilyStmt *b)
Add CREATE/ALTER/DROP OPERATOR FAMILY commands, also COMMENT ON OPERATOR FAMILY; and add FAMILY option to CREATE OPERATOR CLASS to allow adding a class to a pre-existing family. Per previous discussion. Man, what a tedious lot of cutting and pasting ...
2007-01-23 06:07:18 +01:00
{
COMPARE_NODE_FIELD(opfamilyname);
COMPARE_STRING_FIELD(amname);
COMPARE_SCALAR_FIELD(isDrop);
COMPARE_NODE_FIELD(items);
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreatedbStmt(const CreatedbStmt *a, const CreatedbStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(dbname);
COMPARE_NODE_FIELD(options);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Add per-user and per-database connection limit options. This patch also includes preliminary update of pg_dumpall for roles. Petr Jelinek, with review by Bruce Momjian and Tom Lane.
2005-07-31 19:19:22 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterDatabaseStmt(const AlterDatabaseStmt *a, const AlterDatabaseStmt *b)
Add per-user and per-database connection limit options. This patch also includes preliminary update of pg_dumpall for roles. Petr Jelinek, with review by Bruce Momjian and Tom Lane.
2005-07-31 19:19:22 +02:00
{
COMPARE_STRING_FIELD(dbname);
COMPARE_NODE_FIELD(options);
return true;
}
User and database-specific session defaults for run-time configuration variables. New commands ALTER DATABASE ... SET and ALTER USER ... SET.
2002-03-01 23:45:19 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterDatabaseSetStmt(const AlterDatabaseSetStmt *a, const AlterDatabaseSetStmt *b)
User and database-specific session defaults for run-time configuration variables. New commands ALTER DATABASE ... SET and ALTER USER ... SET.
2002-03-01 23:45:19 +01:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(dbname);
Support SET FROM CURRENT in CREATE/ALTER FUNCTION, ALTER DATABASE, ALTER ROLE. (Actually, it works as a plain statement too, but I didn't document that because it seems a bit useless.) Unify VariableResetStmt with VariableSetStmt, and clean up some ancient cruft in the representation of same.
2007-09-03 20:46:30 +02:00
COMPARE_NODE_FIELD(setstmt);
User and database-specific session defaults for run-time configuration variables. New commands ALTER DATABASE ... SET and ALTER USER ... SET.
2002-03-01 23:45:19 +01:00
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDropdbStmt(const DropdbStmt *a, const DropdbStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(dbname);
DROP DATABASE IF EXISTS variant
2005-11-22 16:24:18 +01:00
COMPARE_SCALAR_FIELD(missing_ok);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalVacuumStmt(const VacuumStmt *a, const VacuumStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Provide a parenthesized-options syntax for VACUUM, analogous to that recently adopted for EXPLAIN. This will allow additional options to be implemented in future without having to make them fully-reserved keywords. The old syntax remains available for existing options, however. Itagaki Takahiro
2009-11-16 22:32:07 +01:00
COMPARE_SCALAR_FIELD(options);
Fix recently-understood problems with handling of XID freezing, particularly in PITR scenarios. We now WAL-log the replacement of old XIDs with FrozenTransactionId, so that such replacement is guaranteed to propagate to PITR slave databases. Also, rather than relying on hint-bit updates to be preserved, pg_clog is not truncated until all instances of an XID are known to have been replaced by FrozenTransactionId. Add new GUC variables and pg_autovacuum columns to allow management of the freezing policy, so that users can trade off the size of pg_clog against the amount of freezing work done. Revise the already-existing code that forces autovacuum of tables approaching the wraparound point to make it more bulletproof; also, revise the autovacuum logic so that anti-wraparound vacuuming is done per-table rather than per-database. initdb forced because of changes in pg_class, pg_database, and pg_autovacuum catalogs. Heikki Linnakangas, Simon Riggs, and Tom Lane.
2006-11-05 23:42:10 +01:00
COMPARE_SCALAR_FIELD(freeze_min_age);
Add vacuum_freeze_table_age GUC option, to control when VACUUM should ignore the visibility map and scan the whole table, to advance relfrozenxid.
2009-01-16 14:27:24 +01:00
COMPARE_SCALAR_FIELD(freeze_table_age);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(relation);
COMPARE_NODE_FIELD(va_cols);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalExplainStmt(const ExplainStmt *a, const ExplainStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(query);
Extend EXPLAIN to allow generic options to be specified. The original syntax made it difficult to add options without making them into reserved words. This change parenthesizes the options to avoid that problem, and makes provision for an explicit (and perhaps non-Boolean) value for each option. The original syntax is still supported, but only for the two original options ANALYZE and VERBOSE. As a test case, add a COSTS option that can suppress the planner cost estimates. This may be useful for including EXPLAIN output in the regression tests, which are otherwise unable to cope with cross-platform variations in cost estimates. Robert Haas
2009-07-27 01:34:18 +02:00
COMPARE_NODE_FIELD(options);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Restructure SELECT INTO's parsetree representation into CreateTableAsStmt. Making this operation look like a utility statement seems generally a good idea, and particularly so in light of the desire to provide command triggers for utility statements. The original choice of representing it as SELECT with an IntoClause appendage had metastasized into rather a lot of places, unfortunately, so that this patch is a great deal more complicated than one might at first expect. In particular, keeping EXPLAIN working for SELECT INTO and CREATE TABLE AS subcommands required restructuring some EXPLAIN-related APIs. Add-on code that calls ExplainOnePlan or ExplainOneUtility, or uses ExplainOneQuery_hook, will need adjustment. Also, the cases PREPARE ... SELECT INTO and CREATE RULE ... SELECT INTO, which formerly were accepted though undocumented, are no longer accepted. The PREPARE case can be replaced with use of CREATE TABLE AS EXECUTE. The CREATE RULE case doesn't seem to have much real-world use (since the rule would work only once before failing with "table already exists"), so we'll not bother with that one. Both SELECT INTO and CREATE TABLE AS still return a command tag of "SELECT nnnn". There was some discussion of returning "CREATE TABLE nnnn", but for the moment backwards compatibility wins the day. Andres Freund and Tom Lane
2012-03-20 02:37:19 +01:00
static bool
_equalCreateTableAsStmt(const CreateTableAsStmt *a, const CreateTableAsStmt *b)
{
COMPARE_NODE_FIELD(query);
COMPARE_NODE_FIELD(into);
Add a materialized view relations. A materialized view has a rule just like a view and a heap and other physical properties like a table. The rule is only used to populate the table, references in queries refer to the materialized data. This is a minimal implementation, but should still be useful in many cases. Currently data is only populated "on demand" by the CREATE MATERIALIZED VIEW and REFRESH MATERIALIZED VIEW statements. It is expected that future releases will add incremental updates with various timings, and that a more refined concept of defining what is "fresh" data will be developed. At some point it may even be possible to have queries use a materialized in place of references to underlying tables, but that requires the other above-mentioned features to be working first. Much of the documentation work by Robert Haas. Review by Noah Misch, Thom Brown, Robert Haas, Marko Tiikkaja Security review by KaiGai Kohei, with a decision on how best to implement sepgsql still pending.
2013-03-04 01:23:31 +01:00
COMPARE_SCALAR_FIELD(relkind);
Restructure SELECT INTO's parsetree representation into CreateTableAsStmt. Making this operation look like a utility statement seems generally a good idea, and particularly so in light of the desire to provide command triggers for utility statements. The original choice of representing it as SELECT with an IntoClause appendage had metastasized into rather a lot of places, unfortunately, so that this patch is a great deal more complicated than one might at first expect. In particular, keeping EXPLAIN working for SELECT INTO and CREATE TABLE AS subcommands required restructuring some EXPLAIN-related APIs. Add-on code that calls ExplainOnePlan or ExplainOneUtility, or uses ExplainOneQuery_hook, will need adjustment. Also, the cases PREPARE ... SELECT INTO and CREATE RULE ... SELECT INTO, which formerly were accepted though undocumented, are no longer accepted. The PREPARE case can be replaced with use of CREATE TABLE AS EXECUTE. The CREATE RULE case doesn't seem to have much real-world use (since the rule would work only once before failing with "table already exists"), so we'll not bother with that one. Both SELECT INTO and CREATE TABLE AS still return a command tag of "SELECT nnnn". There was some discussion of returning "CREATE TABLE nnnn", but for the moment backwards compatibility wins the day. Andres Freund and Tom Lane
2012-03-20 02:37:19 +01:00
COMPARE_SCALAR_FIELD(is_select_into);
return true;
}
Add a materialized view relations. A materialized view has a rule just like a view and a heap and other physical properties like a table. The rule is only used to populate the table, references in queries refer to the materialized data. This is a minimal implementation, but should still be useful in many cases. Currently data is only populated "on demand" by the CREATE MATERIALIZED VIEW and REFRESH MATERIALIZED VIEW statements. It is expected that future releases will add incremental updates with various timings, and that a more refined concept of defining what is "fresh" data will be developed. At some point it may even be possible to have queries use a materialized in place of references to underlying tables, but that requires the other above-mentioned features to be working first. Much of the documentation work by Robert Haas. Review by Noah Misch, Thom Brown, Robert Haas, Marko Tiikkaja Security review by KaiGai Kohei, with a decision on how best to implement sepgsql still pending.
2013-03-04 01:23:31 +01:00
static bool
_equalRefreshMatViewStmt(const RefreshMatViewStmt *a, const RefreshMatViewStmt *b)
{
Add support for REFRESH MATERIALIZED VIEW CONCURRENTLY. This allows reads to continue without any blocking while a REFRESH runs. The new data appears atomically as part of transaction commit. Review questioned the Assert that a matview was not a system relation. This will be addressed separately. Reviewed by Hitoshi Harada, Robert Haas, Andres Freund. Merged after review with security patch f3ab5d4.
2013-07-16 19:55:44 +02:00
COMPARE_SCALAR_FIELD(concurrent);
Add a materialized view relations. A materialized view has a rule just like a view and a heap and other physical properties like a table. The rule is only used to populate the table, references in queries refer to the materialized data. This is a minimal implementation, but should still be useful in many cases. Currently data is only populated "on demand" by the CREATE MATERIALIZED VIEW and REFRESH MATERIALIZED VIEW statements. It is expected that future releases will add incremental updates with various timings, and that a more refined concept of defining what is "fresh" data will be developed. At some point it may even be possible to have queries use a materialized in place of references to underlying tables, but that requires the other above-mentioned features to be working first. Much of the documentation work by Robert Haas. Review by Noah Misch, Thom Brown, Robert Haas, Marko Tiikkaja Security review by KaiGai Kohei, with a decision on how best to implement sepgsql still pending.
2013-03-04 01:23:31 +01:00
COMPARE_SCALAR_FIELD(skipData);
COMPARE_NODE_FIELD(relation);
return true;
}
Add the notion of REPLICA IDENTITY for a table. Pending patches for logical replication will use this to determine which columns of a tuple ought to be considered as its candidate key. Andres Freund, with minor, mostly cosmetic adjustments by me
2013-11-08 18:30:43 +01:00
static bool
_equalReplicaIdentityStmt(const ReplicaIdentityStmt *a, const ReplicaIdentityStmt *b)
{
COMPARE_SCALAR_FIELD(identity_type);
COMPARE_STRING_FIELD(name);
return true;
}
Add ALTER SYSTEM command to edit the server configuration file. Patch contributed by Amit Kapila. Reviewed by Hari Babu, Masao Fujii, Boszormenyi Zoltan, Andres Freund, Greg Smith and others.
2013-12-18 15:42:44 +01:00
static bool
_equalAlterSystemStmt(const AlterSystemStmt * a, const AlterSystemStmt * b)
{
COMPARE_NODE_FIELD(setstmt);
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateSeqStmt(const CreateSeqStmt *a, const CreateSeqStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(sequence);
COMPARE_NODE_FIELD(options);
Fix failure of "ALTER TABLE t ADD COLUMN c serial" when done by non-owner. The implicitly created sequence was created as owned by the current user, who could be different from the table owner, eg if current user is a superuser or some member of the table's owning role. This caused sanity checks in the SEQUENCE OWNED BY code to spit up. Although possibly we don't need those sanity checks, the safest fix seems to be to make sure the implicit sequence is assigned the same owner role as the table has. (We still do all permissions checks as the current user, however.) Per report from Josh Berkus. Back-patch to 9.0. The bug goes back to the invention of SEQUENCE OWNED BY in 8.2, but the fix requires an API change for DefineRelation(), which seems to have potential for breaking third-party code if done in a minor release. Given the lack of prior complaints, it's probably not worth fixing in the stable branches.
2010-08-18 20:35:21 +02:00
COMPARE_SCALAR_FIELD(ownerId);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Todo items: Add ALTER SEQUENCE to modify min/max/increment/cache/cycle values Also updated create sequence docs to mention NO MINVALUE, & NO MAXVALUE. New Files: doc/src/sgml/ref/alter_sequence.sgml src/test/regress/expected/sequence.out src/test/regress/sql/sequence.sql ALTER SEQUENCE is NOT transactional. It behaves similarly to setval(). It matches the proposed SQL200N spec, as well as Oracle in most ways -- Oracle lacks RESTART WITH for some strange reason. -- Rod Taylor <rbt@rbt.ca>
2003-03-20 08:02:11 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterSeqStmt(const AlterSeqStmt *a, const AlterSeqStmt *b)
Todo items: Add ALTER SEQUENCE to modify min/max/increment/cache/cycle values Also updated create sequence docs to mention NO MINVALUE, & NO MAXVALUE. New Files: doc/src/sgml/ref/alter_sequence.sgml src/test/regress/expected/sequence.out src/test/regress/sql/sequence.sql ALTER SEQUENCE is NOT transactional. It behaves similarly to setval(). It matches the proposed SQL200N spec, as well as Oracle in most ways -- Oracle lacks RESTART WITH for some strange reason. -- Rod Taylor <rbt@rbt.ca>
2003-03-20 08:02:11 +01:00
{
COMPARE_NODE_FIELD(sequence);
COMPARE_NODE_FIELD(options);
ALTER <thing> [IF EXISTS] ... allows silent DDL if required, e.g. ALTER FOREIGN TABLE IF EXISTS foo RENAME TO bar Pavel Stehule
2012-01-24 00:25:04 +01:00
COMPARE_SCALAR_FIELD(missing_ok);
Todo items: Add ALTER SEQUENCE to modify min/max/increment/cache/cycle values Also updated create sequence docs to mention NO MINVALUE, & NO MAXVALUE. New Files: doc/src/sgml/ref/alter_sequence.sgml src/test/regress/expected/sequence.out src/test/regress/sql/sequence.sql ALTER SEQUENCE is NOT transactional. It behaves similarly to setval(). It matches the proposed SQL200N spec, as well as Oracle in most ways -- Oracle lacks RESTART WITH for some strange reason. -- Rod Taylor <rbt@rbt.ca>
2003-03-20 08:02:11 +01:00
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalVariableSetStmt(const VariableSetStmt *a, const VariableSetStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Support SET FROM CURRENT in CREATE/ALTER FUNCTION, ALTER DATABASE, ALTER ROLE. (Actually, it works as a plain statement too, but I didn't document that because it seems a bit useless.) Unify VariableResetStmt with VariableSetStmt, and clean up some ancient cruft in the representation of same.
2007-09-03 20:46:30 +02:00
COMPARE_SCALAR_FIELD(kind);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(name);
COMPARE_NODE_FIELD(args);
COMPARE_SCALAR_FIELD(is_local);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalVariableShowStmt(const VariableShowStmt *a, const VariableShowStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(name);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Rename the newly-added commands for discarding session state. RESET SESSION, RESET PLANS, and RESET TEMP are now DISCARD ALL, DISCARD PLANS, and DISCARD TEMP, respectively. This is to avoid confusion with the pre-existing RESET variants: the DISCARD commands are not actually similar to RESET. Patch from Marko Kreen, with some minor editorialization.
2007-04-26 18:13:15 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDiscardStmt(const DiscardStmt *a, const DiscardStmt *b)
Rename the newly-added commands for discarding session state. RESET SESSION, RESET PLANS, and RESET TEMP are now DISCARD ALL, DISCARD PLANS, and DISCARD TEMP, respectively. This is to avoid confusion with the pre-existing RESET variants: the DISCARD commands are not actually similar to RESET. Patch from Marko Kreen, with some minor editorialization.
2007-04-26 18:13:15 +02:00
{
COMPARE_SCALAR_FIELD(target);
return true;
}
Tablespaces. Alternate database locations are dead, long live tablespaces. There are various things left to do: contrib dbsize and oid2name modules need work, and so does the documentation. Also someone should think about COMMENT ON TABLESPACE and maybe RENAME TABLESPACE. Also initlocation is dead, it just doesn't know it yet. Gavin Sherry and Tom Lane.
2004-06-18 08:14:31 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateTableSpaceStmt(const CreateTableSpaceStmt *a, const CreateTableSpaceStmt *b)
Tablespaces. Alternate database locations are dead, long live tablespaces. There are various things left to do: contrib dbsize and oid2name modules need work, and so does the documentation. Also someone should think about COMMENT ON TABLESPACE and maybe RENAME TABLESPACE. Also initlocation is dead, it just doesn't know it yet. Gavin Sherry and Tom Lane.
2004-06-18 08:14:31 +02:00
{
COMPARE_STRING_FIELD(tablespacename);
COMPARE_STRING_FIELD(owner);
COMPARE_STRING_FIELD(location);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDropTableSpaceStmt(const DropTableSpaceStmt *a, const DropTableSpaceStmt *b)
Tablespaces. Alternate database locations are dead, long live tablespaces. There are various things left to do: contrib dbsize and oid2name modules need work, and so does the documentation. Also someone should think about COMMENT ON TABLESPACE and maybe RENAME TABLESPACE. Also initlocation is dead, it just doesn't know it yet. Gavin Sherry and Tom Lane.
2004-06-18 08:14:31 +02:00
{
COMPARE_STRING_FIELD(tablespacename);
DROP ... IF EXISTS for the following cases: language, tablespace, trigger, rule, opclass, function, aggregate. operator, and cast.
2006-06-16 22:23:45 +02:00
COMPARE_SCALAR_FIELD(missing_ok);
Tablespaces. Alternate database locations are dead, long live tablespaces. There are various things left to do: contrib dbsize and oid2name modules need work, and so does the documentation. Also someone should think about COMMENT ON TABLESPACE and maybe RENAME TABLESPACE. Also initlocation is dead, it just doesn't know it yet. Gavin Sherry and Tom Lane.
2004-06-18 08:14:31 +02:00
return true;
}
Support ALTER TABLESPACE name SET/RESET ( tablespace_options ). This patch only supports seq_page_cost and random_page_cost as parameters, but it provides the infrastructure to scalably support many more. In particular, we may want to add support for effective_io_concurrency, but I'm leaving that as future work for now. Thanks to Tom Lane for design help and Alvaro Herrera for the review.
2010-01-05 22:54:00 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *a,
const AlterTableSpaceOptionsStmt *b)
Support ALTER TABLESPACE name SET/RESET ( tablespace_options ). This patch only supports seq_page_cost and random_page_cost as parameters, but it provides the infrastructure to scalably support many more. In particular, we may want to add support for effective_io_concurrency, but I'm leaving that as future work for now. Thanks to Tom Lane for design help and Alvaro Herrera for the review.
2010-01-05 22:54:00 +01:00
{
COMPARE_STRING_FIELD(tablespacename);
COMPARE_NODE_FIELD(options);
COMPARE_SCALAR_FIELD(isReset);
return true;
}
Add ALTER TABLESPACE ... MOVE command This adds a 'MOVE' sub-command to ALTER TABLESPACE which allows moving sets of objects from one tablespace to another. This can be extremely handy and avoids a lot of error-prone scripting. ALTER TABLESPACE ... MOVE will only move objects the user owns, will notify the user if no objects were found, and can be used to move ALL objects or specific types of objects (TABLES, INDEXES, or MATERIALIZED VIEWS).
2014-01-19 00:56:40 +01:00
static bool
_equalAlterTableSpaceMoveStmt(const AlterTableSpaceMoveStmt *a,
const AlterTableSpaceMoveStmt *b)
{
COMPARE_STRING_FIELD(orig_tablespacename);
COMPARE_STRING_FIELD(new_tablespacename);
COMPARE_SCALAR_FIELD(nowait);
return true;
}
Core support for "extensions", which are packages of SQL objects. This patch adds the server infrastructure to support extensions. There is still one significant loose end, namely how to make it play nice with pg_upgrade, so I am not yet committing the changes that would make all the contrib modules depend on this feature. In passing, fix a disturbingly large amount of breakage in AlterObjectNamespace() and callers. Dimitri Fontaine, reviewed by Anssi Kääriäinen, Itagaki Takahiro, Tom Lane, and numerous others
2011-02-08 22:08:41 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateExtensionStmt(const CreateExtensionStmt *a, const CreateExtensionStmt *b)
Core support for "extensions", which are packages of SQL objects. This patch adds the server infrastructure to support extensions. There is still one significant loose end, namely how to make it play nice with pg_upgrade, so I am not yet committing the changes that would make all the contrib modules depend on this feature. In passing, fix a disturbingly large amount of breakage in AlterObjectNamespace() and callers. Dimitri Fontaine, reviewed by Anssi Kääriäinen, Itagaki Takahiro, Tom Lane, and numerous others
2011-02-08 22:08:41 +01:00
{
COMPARE_STRING_FIELD(extname);
Allow non-superusers to create (some) extensions. Remove the unconditional superuser permissions check in CREATE EXTENSION, and instead define a "superuser" extension property, which when false (not the default) skips the superuser permissions check. In this case the calling user only needs enough permissions to execute the commands in the extension's installation script. The superuser property is also enforced in the same way for ALTER EXTENSION UPDATE cases. In other ALTER EXTENSION cases and DROP EXTENSION, test ownership of the extension rather than superuserness. ALTER EXTENSION ADD/DROP needs to insist on ownership of the target object as well; to do that without duplicating code, refactor comment.c's big switch for permissions checks into a separate function in objectaddress.c. I also removed the superuserness checks in pg_available_extensions and related functions; there's no strong reason why everybody shouldn't be able to see that info. Also invent an IF NOT EXISTS variant of CREATE EXTENSION, and use that in pg_dump, so that dumps won't fail for installed-by-default extensions. We don't have any of those yet, but we will soon. This is all per discussion of wrapping the standard procedural languages into extensions. I'll make those changes in a separate commit; this is just putting the core infrastructure in place.
2011-03-04 22:08:24 +01:00
COMPARE_SCALAR_FIELD(if_not_exists);
Core support for "extensions", which are packages of SQL objects. This patch adds the server infrastructure to support extensions. There is still one significant loose end, namely how to make it play nice with pg_upgrade, so I am not yet committing the changes that would make all the contrib modules depend on this feature. In passing, fix a disturbingly large amount of breakage in AlterObjectNamespace() and callers. Dimitri Fontaine, reviewed by Anssi Kääriäinen, Itagaki Takahiro, Tom Lane, and numerous others
2011-02-08 22:08:41 +01:00
COMPARE_NODE_FIELD(options);
return true;
}
Add support for multiple versions of an extension and ALTER EXTENSION UPDATE. This follows recent discussions, so it's quite a bit different from Dimitri's original. There will probably be more changes once we get a bit of experience with it, but let's get it in and start playing with it. This is still just core code. I'll start converting contrib modules shortly. Dimitri Fontaine and Tom Lane
2011-02-12 03:25:20 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterExtensionStmt(const AlterExtensionStmt *a, const AlterExtensionStmt *b)
Add support for multiple versions of an extension and ALTER EXTENSION UPDATE. This follows recent discussions, so it's quite a bit different from Dimitri's original. There will probably be more changes once we get a bit of experience with it, but let's get it in and start playing with it. This is still just core code. I'll start converting contrib modules shortly. Dimitri Fontaine and Tom Lane
2011-02-12 03:25:20 +01:00
{
COMPARE_STRING_FIELD(extname);
COMPARE_NODE_FIELD(options);
return true;
}
Implement "ALTER EXTENSION ADD object". This is an essential component of making the extension feature usable; first because it's needed in the process of converting an existing installation containing "loose" objects of an old contrib module into the extension-based world, and second because we'll have to use it in pg_dump --binary-upgrade, as per recent discussion. Loosely based on part of Dimitri Fontaine's ALTER EXTENSION UPGRADE patch.
2011-02-09 17:55:32 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterExtensionContentsStmt(const AlterExtensionContentsStmt *a, const AlterExtensionContentsStmt *b)
Implement "ALTER EXTENSION ADD object". This is an essential component of making the extension feature usable; first because it's needed in the process of converting an existing installation containing "loose" objects of an old contrib module into the extension-based world, and second because we'll have to use it in pg_dump --binary-upgrade, as per recent discussion. Loosely based on part of Dimitri Fontaine's ALTER EXTENSION UPGRADE patch.
2011-02-09 17:55:32 +01:00
{
COMPARE_STRING_FIELD(extname);
Extend "ALTER EXTENSION ADD object" to permit "DROP object" as well. Per discussion, this is something we should have sooner rather than later, and it doesn't take much additional code to support it.
2011-02-10 23:36:44 +01:00
COMPARE_SCALAR_FIELD(action);
Implement "ALTER EXTENSION ADD object". This is an essential component of making the extension feature usable; first because it's needed in the process of converting an existing installation containing "loose" objects of an old contrib module into the extension-based world, and second because we'll have to use it in pg_dump --binary-upgrade, as per recent discussion. Loosely based on part of Dimitri Fontaine's ALTER EXTENSION UPGRADE patch.
2011-02-09 17:55:32 +01:00
COMPARE_SCALAR_FIELD(objtype);
COMPARE_NODE_FIELD(objname);
COMPARE_NODE_FIELD(objargs);
return true;
}
SQL/MED catalog manipulation facilities This doesn't do any remote or external things yet, but it gives modules like plproxy and dblink a standardized and future-proof system for managing their connection information. Martin Pihlak and Peter Eisentraut
2008-12-19 17:25:19 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateFdwStmt(const CreateFdwStmt *a, const CreateFdwStmt *b)
SQL/MED catalog manipulation facilities This doesn't do any remote or external things yet, but it gives modules like plproxy and dblink a standardized and future-proof system for managing their connection information. Martin Pihlak and Peter Eisentraut
2008-12-19 17:25:19 +01:00
{
COMPARE_STRING_FIELD(fdwname);
Create the catalog infrastructure for foreign-data-wrapper handlers. Add a fdwhandler column to pg_foreign_data_wrapper, plus HANDLER options in the CREATE FOREIGN DATA WRAPPER and ALTER FOREIGN DATA WRAPPER commands, plus pg_dump support for same. Also invent a new pseudotype fdw_handler with properties similar to language_handler. This is split out of the "FDW API" patch for ease of review; it's all stuff we will certainly need, regardless of any other details of the FDW API. FDW handler functions will not actually get called yet. In passing, fix some omissions and infelicities in foreigncmds.c. Shigeru Hanada, Jan Urbanski, Heikki Linnakangas
2011-02-19 06:06:18 +01:00
COMPARE_NODE_FIELD(func_options);
SQL/MED catalog manipulation facilities This doesn't do any remote or external things yet, but it gives modules like plproxy and dblink a standardized and future-proof system for managing their connection information. Martin Pihlak and Peter Eisentraut
2008-12-19 17:25:19 +01:00
COMPARE_NODE_FIELD(options);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterFdwStmt(const AlterFdwStmt *a, const AlterFdwStmt *b)
SQL/MED catalog manipulation facilities This doesn't do any remote or external things yet, but it gives modules like plproxy and dblink a standardized and future-proof system for managing their connection information. Martin Pihlak and Peter Eisentraut
2008-12-19 17:25:19 +01:00
{
COMPARE_STRING_FIELD(fdwname);
Create the catalog infrastructure for foreign-data-wrapper handlers. Add a fdwhandler column to pg_foreign_data_wrapper, plus HANDLER options in the CREATE FOREIGN DATA WRAPPER and ALTER FOREIGN DATA WRAPPER commands, plus pg_dump support for same. Also invent a new pseudotype fdw_handler with properties similar to language_handler. This is split out of the "FDW API" patch for ease of review; it's all stuff we will certainly need, regardless of any other details of the FDW API. FDW handler functions will not actually get called yet. In passing, fix some omissions and infelicities in foreigncmds.c. Shigeru Hanada, Jan Urbanski, Heikki Linnakangas
2011-02-19 06:06:18 +01:00
COMPARE_NODE_FIELD(func_options);
SQL/MED catalog manipulation facilities This doesn't do any remote or external things yet, but it gives modules like plproxy and dblink a standardized and future-proof system for managing their connection information. Martin Pihlak and Peter Eisentraut
2008-12-19 17:25:19 +01:00
COMPARE_NODE_FIELD(options);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateForeignServerStmt(const CreateForeignServerStmt *a, const CreateForeignServerStmt *b)
SQL/MED catalog manipulation facilities This doesn't do any remote or external things yet, but it gives modules like plproxy and dblink a standardized and future-proof system for managing their connection information. Martin Pihlak and Peter Eisentraut
2008-12-19 17:25:19 +01:00
{
COMPARE_STRING_FIELD(servername);
COMPARE_STRING_FIELD(servertype);
COMPARE_STRING_FIELD(version);
COMPARE_STRING_FIELD(fdwname);
COMPARE_NODE_FIELD(options);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterForeignServerStmt(const AlterForeignServerStmt *a, const AlterForeignServerStmt *b)
SQL/MED catalog manipulation facilities This doesn't do any remote or external things yet, but it gives modules like plproxy and dblink a standardized and future-proof system for managing their connection information. Martin Pihlak and Peter Eisentraut
2008-12-19 17:25:19 +01:00
{
COMPARE_STRING_FIELD(servername);
COMPARE_STRING_FIELD(version);
COMPARE_NODE_FIELD(options);
COMPARE_SCALAR_FIELD(has_version);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateUserMappingStmt(const CreateUserMappingStmt *a, const CreateUserMappingStmt *b)
SQL/MED catalog manipulation facilities This doesn't do any remote or external things yet, but it gives modules like plproxy and dblink a standardized and future-proof system for managing their connection information. Martin Pihlak and Peter Eisentraut
2008-12-19 17:25:19 +01:00
{
COMPARE_STRING_FIELD(username);
COMPARE_STRING_FIELD(servername);
COMPARE_NODE_FIELD(options);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterUserMappingStmt(const AlterUserMappingStmt *a, const AlterUserMappingStmt *b)
SQL/MED catalog manipulation facilities This doesn't do any remote or external things yet, but it gives modules like plproxy and dblink a standardized and future-proof system for managing their connection information. Martin Pihlak and Peter Eisentraut
2008-12-19 17:25:19 +01:00
{
COMPARE_STRING_FIELD(username);
COMPARE_STRING_FIELD(servername);
COMPARE_NODE_FIELD(options);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDropUserMappingStmt(const DropUserMappingStmt *a, const DropUserMappingStmt *b)
SQL/MED catalog manipulation facilities This doesn't do any remote or external things yet, but it gives modules like plproxy and dblink a standardized and future-proof system for managing their connection information. Martin Pihlak and Peter Eisentraut
2008-12-19 17:25:19 +01:00
{
COMPARE_STRING_FIELD(username);
COMPARE_STRING_FIELD(servername);
COMPARE_SCALAR_FIELD(missing_ok);
return true;
}
Basic foreign table support. Foreign tables are a core component of SQL/MED. This commit does not provide a working SQL/MED infrastructure, because foreign tables cannot yet be queried. Support for foreign table scans will need to be added in a future patch. However, this patch creates the necessary system catalog structure, syntax support, and support for ancillary operations such as COMMENT and SECURITY LABEL. Shigeru Hanada, heavily revised by Robert Haas
2011-01-02 05:48:11 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateForeignTableStmt(const CreateForeignTableStmt *a, const CreateForeignTableStmt *b)
Basic foreign table support. Foreign tables are a core component of SQL/MED. This commit does not provide a working SQL/MED infrastructure, because foreign tables cannot yet be queried. Support for foreign table scans will need to be added in a future patch. However, this patch creates the necessary system catalog structure, syntax support, and support for ancillary operations such as COMMENT and SECURITY LABEL. Shigeru Hanada, heavily revised by Robert Haas
2011-01-02 05:48:11 +01:00
{
if (!_equalCreateStmt(&a->base, &b->base))
return false;
COMPARE_STRING_FIELD(servername);
COMPARE_NODE_FIELD(options);
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateTrigStmt(const CreateTrigStmt *a, const CreateTrigStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(trigname);
COMPARE_NODE_FIELD(relation);
COMPARE_NODE_FIELD(funcname);
COMPARE_NODE_FIELD(args);
COMPARE_SCALAR_FIELD(row);
Support triggers on views. This patch adds the SQL-standard concept of an INSTEAD OF trigger, which is fired instead of performing a physical insert/update/delete. The trigger function is passed the entire old and/or new rows of the view, and must figure out what to do to the underlying tables to implement the update. So this feature can be used to implement updatable views using trigger programming style rather than rule hacking. In passing, this patch corrects the names of some columns in the information_schema.triggers view. It seems the SQL committee renamed them somewhere between SQL:99 and SQL:2003. Dean Rasheed, reviewed by Bernd Helmle; some additional hacking by me.
2010-10-10 19:43:33 +02:00
COMPARE_SCALAR_FIELD(timing);
Fix the just-reported problem that you can't specify all four trigger event types in CREATE TRIGGER. While at it, clean up the amazingly tedious and inextensible way that the trigger event type list was handled. Per report from Greg Sabino Mullane.
2009-06-18 03:27:02 +02:00
COMPARE_SCALAR_FIELD(events);
Support SQL-compliant triggers on columns, ie fire only if certain columns are named in the UPDATE's SET list. Note: the schema of pg_trigger has not actually changed; we've just started to use a column that was there all along. catversion bumped anyway so that this commit is included in the history of potentially interesting changes to system catalog contents. Itagaki Takahiro
2009-10-15 00:14:25 +02:00
COMPARE_NODE_FIELD(columns);
Add a WHEN clause to CREATE TRIGGER, allowing a boolean expression to be checked to determine whether the trigger should be fired. For BEFORE triggers this is mostly a matter of spec compliance; but for AFTER triggers it can provide a noticeable performance improvement, since queuing of a deferred trigger event and re-fetching of the row(s) at end of statement can be short-circuited if the trigger does not need to be fired. Takahiro Itagaki, reviewed by KaiGai Kohei.
2009-11-20 21:38:12 +01:00
COMPARE_NODE_FIELD(whenClause);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(isconstraint);
COMPARE_SCALAR_FIELD(deferrable);
COMPARE_SCALAR_FIELD(initdeferred);
COMPARE_NODE_FIELD(constrrel);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Syntax support and documentation for event triggers. They don't actually do anything yet; that will get fixed in a follow-on commit. But this gets the basic infrastructure in place, including CREATE/ALTER/DROP EVENT TRIGGER; support for COMMENT, SECURITY LABEL, and ALTER EXTENSION .. ADD/DROP EVENT TRIGGER; pg_dump and psql support; and documentation for the anticipated initial feature set. Dimitri Fontaine, with review and a bunch of additional hacking by me. Thom Brown extensively reviewed earlier versions of this patch set, but there's not a whole lot of that code left in this commit, as it turns out.
2012-07-18 16:16:16 +02:00
static bool
_equalCreateEventTrigStmt(const CreateEventTrigStmt *a, const CreateEventTrigStmt *b)
{
COMPARE_STRING_FIELD(trigname);
COMPARE_SCALAR_FIELD(eventname);
COMPARE_NODE_FIELD(funcname);
COMPARE_NODE_FIELD(whenclause);
return true;
}
static bool
_equalAlterEventTrigStmt(const AlterEventTrigStmt *a, const AlterEventTrigStmt *b)
{
COMPARE_STRING_FIELD(trigname);
COMPARE_SCALAR_FIELD(tgenabled);
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreatePLangStmt(const CreatePLangStmt *a, const CreatePLangStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Add an OR REPLACE option to CREATE LANGUAGE. This operates in the same way as other CREATE OR REPLACE commands, ie, it replaces everything but the ownership and ACL lists of an existing entry, and requires the caller to have owner privileges for that entry. While modifying an existing language has some use in development scenarios, in typical usage all the "replaced" values come from pg_pltemplate so there will be no actual change in the language definition. The reason for adding this is mainly to allow programs to ensure that a language exists without triggering an error if it already does exist. This commit just adds and documents the new option. A followon patch will use it to clean up some unpleasant cases in pg_dump and pg_regress.
2010-02-23 23:51:43 +01:00
COMPARE_SCALAR_FIELD(replace);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(plname);
COMPARE_NODE_FIELD(plhandler);
Implement the DO statement to support execution of PL code without having to create a function for it. Procedural languages now have an additional entry point, namely a function to execute an inline code block. This seemed a better design than trying to hide the transient-ness of the code from the PL. As of this patch, only plpgsql has an inline handler, but probably people will soon write handlers for the other standard PLs. In passing, remove the long-dead LANCOMPILER option of CREATE LANGUAGE. Petr Jelinek
2009-09-23 01:43:43 +02:00
COMPARE_NODE_FIELD(plinline);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(plvalidator);
COMPARE_SCALAR_FIELD(pltrusted);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateRoleStmt(const CreateRoleStmt *a, const CreateRoleStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Add a role property 'rolinherit' which, when false, denotes that the role doesn't automatically inherit the privileges of roles it is a member of; for such a role, membership in another role can be exploited only by doing explicit SET ROLE. The default inherit setting is TRUE, so by default the behavior doesn't change, but creating a user with NOINHERIT gives closer adherence to our current reading of SQL99. Documentation still lacking, and I think the information schema needs another look.
2005-07-26 18:38:29 +02:00
COMPARE_SCALAR_FIELD(stmt_type);
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
COMPARE_STRING_FIELD(role);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(options);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterRoleStmt(const AlterRoleStmt *a, const AlterRoleStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
COMPARE_STRING_FIELD(role);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(options);
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
COMPARE_SCALAR_FIELD(action);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
User and database-specific session defaults for run-time configuration variables. New commands ALTER DATABASE ... SET and ALTER USER ... SET.
2002-03-01 23:45:19 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterRoleSetStmt(const AlterRoleSetStmt *a, const AlterRoleSetStmt *b)
User and database-specific session defaults for run-time configuration variables. New commands ALTER DATABASE ... SET and ALTER USER ... SET.
2002-03-01 23:45:19 +01:00
{
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
COMPARE_STRING_FIELD(role);
Make it possibly to specify GUC params per user and per database. Create a new catalog pg_db_role_setting where they are now stored, and better encapsulate the code that deals with settings into its realm. The old datconfig and rolconfig columns are removed. psql has gained a \drds command to display the settings. Backwards compatibility warning: while the backwards-compatible system views still have the config columns, they no longer completely represent the configuration for a user or database. Catalog version bumped.
2009-10-08 00:14:26 +02:00
COMPARE_STRING_FIELD(database);
Support SET FROM CURRENT in CREATE/ALTER FUNCTION, ALTER DATABASE, ALTER ROLE. (Actually, it works as a plain statement too, but I didn't document that because it seems a bit useless.) Unify VariableResetStmt with VariableSetStmt, and clean up some ancient cruft in the representation of same.
2007-09-03 20:46:30 +02:00
COMPARE_NODE_FIELD(setstmt);
User and database-specific session defaults for run-time configuration variables. New commands ALTER DATABASE ... SET and ALTER USER ... SET.
2002-03-01 23:45:19 +01:00
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDropRoleStmt(const DropRoleStmt *a, const DropRoleStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
COMPARE_NODE_FIELD(roles);
DROP IF EXISTS for ROLE/USER/GROUP
2006-02-04 20:06:47 +01:00
COMPARE_SCALAR_FIELD(missing_ok);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalLockStmt(const LockStmt *a, const LockStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(relations);
COMPARE_SCALAR_FIELD(mode);
Add NOWAIT option to LOCK command
2004-03-11 02:47:41 +01:00
COMPARE_SCALAR_FIELD(nowait);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalConstraintsSetStmt(const ConstraintsSetStmt *a, const ConstraintsSetStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(constraints);
COMPARE_SCALAR_FIELD(deferred);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalReindexStmt(const ReindexStmt *a, const ReindexStmt *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Get rid of last few vestiges of parsetree dependency on grammar token codes, per discussion from last March. parse.h should now be included *only* by gram.y, scan.l, keywords.c, parser.c. This prevents surprising misbehavior after seemingly-trivial grammar adjustments.
2003-02-10 05:44:47 +01:00
COMPARE_SCALAR_FIELD(kind);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(relation);
COMPARE_STRING_FIELD(name);
Make REINDEX DATABASE do what one would expect, namely reindex all indexes in the database. The old behavior (reindex system catalogs only) is now available as REINDEX SYSTEM. I did not add the complementary REINDEX USER case since there did not seem to be consensus for this, but it would be trivial to add later. Per recent discussions.
2005-06-22 23:14:31 +02:00
COMPARE_SCALAR_FIELD(do_system);
COMPARE_SCALAR_FIELD(do_user);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't *do* anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname.
2002-03-21 17:02:16 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateSchemaStmt(const CreateSchemaStmt *a, const CreateSchemaStmt *b)
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't *do* anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname.
2002-03-21 17:02:16 +01:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(schemaname);
COMPARE_STRING_FIELD(authid);
COMPARE_NODE_FIELD(schemaElts);
Support CREATE SCHEMA IF NOT EXISTS. Per discussion, schema-element subcommands are not allowed together with this option, since it's not very obvious what should happen to the element objects. Fabrízio de Royes Mello
2012-10-04 01:47:11 +02:00
COMPARE_SCALAR_FIELD(if_not_exists);
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't *do* anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname.
2002-03-21 17:02:16 +01:00
return true;
}
Add missing copyfuncs/equalfuncs entries, including T_Null which has been missing forever; surprising it wasn't noticed before. The other additions are, um, sloppiness in certain recent feature additions.
2002-08-19 02:11:53 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateConversionStmt(const CreateConversionStmt *a, const CreateConversionStmt *b)
Add missing copyfuncs/equalfuncs entries, including T_Null which has been missing forever; surprising it wasn't noticed before. The other additions are, um, sloppiness in certain recent feature additions.
2002-08-19 02:11:53 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(conversion_name);
COMPARE_STRING_FIELD(for_encoding_name);
COMPARE_STRING_FIELD(to_encoding_name);
COMPARE_NODE_FIELD(func_name);
COMPARE_SCALAR_FIELD(def);
Add missing copyfuncs/equalfuncs entries, including T_Null which has been missing forever; surprising it wasn't noticed before. The other additions are, um, sloppiness in certain recent feature additions.
2002-08-19 02:11:53 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCreateCastStmt(const CreateCastStmt *a, const CreateCastStmt *b)
Add missing copyfuncs/equalfuncs entries, including T_Null which has been missing forever; surprising it wasn't noticed before. The other additions are, um, sloppiness in certain recent feature additions.
2002-08-19 02:11:53 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(sourcetype);
COMPARE_NODE_FIELD(targettype);
COMPARE_NODE_FIELD(func);
COMPARE_SCALAR_FIELD(context);
Add support for user-defined I/O conversion casts.
2008-10-31 09:39:22 +01:00
COMPARE_SCALAR_FIELD(inout);
Add missing copyfuncs/equalfuncs entries, including T_Null which has been missing forever; surprising it wasn't noticed before. The other additions are, um, sloppiness in certain recent feature additions.
2002-08-19 02:11:53 +02:00
return true;
}
PREPARE/EXECUTE statements. Patch by Neil Conway, some kibitzing from Tom Lane.
2002-08-27 06:55:12 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalPrepareStmt(const PrepareStmt *a, const PrepareStmt *b)
PREPARE/EXECUTE statements. Patch by Neil Conway, some kibitzing from Tom Lane.
2002-08-27 06:55:12 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(name);
COMPARE_NODE_FIELD(argtypes);
COMPARE_NODE_FIELD(query);
PREPARE/EXECUTE statements. Patch by Neil Conway, some kibitzing from Tom Lane.
2002-08-27 06:55:12 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalExecuteStmt(const ExecuteStmt *a, const ExecuteStmt *b)
PREPARE/EXECUTE statements. Patch by Neil Conway, some kibitzing from Tom Lane.
2002-08-27 06:55:12 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(name);
COMPARE_NODE_FIELD(params);
PREPARE/EXECUTE statements. Patch by Neil Conway, some kibitzing from Tom Lane.
2002-08-27 06:55:12 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDeallocateStmt(const DeallocateStmt *a, const DeallocateStmt *b)
PREPARE/EXECUTE statements. Patch by Neil Conway, some kibitzing from Tom Lane.
2002-08-27 06:55:12 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(name);
PREPARE/EXECUTE statements. Patch by Neil Conway, some kibitzing from Tom Lane.
2002-08-27 06:55:12 +02:00
return true;
}
Implement DROP OWNED and REASSIGN OWNED. These new commands facilitate the process of dropping roles by dropping objects owned by them and privileges granted to them, or giving the owned objects to someone else, through the use of the data stored in the new pg_shdepend catalog. Some refactoring of the GRANT/REVOKE code was needed, as well as ALTER OWNER code. Further cleanup of code duplication in the GRANT code seems necessary. Implemented by me after an idea from Tom Lane, who also provided various kind of implementation advice. Regression tests pass. Some tests for the new functionality are also added, as well as rudimentary documentation.
2005-11-21 13:49:33 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDropOwnedStmt(const DropOwnedStmt *a, const DropOwnedStmt *b)
Implement DROP OWNED and REASSIGN OWNED. These new commands facilitate the process of dropping roles by dropping objects owned by them and privileges granted to them, or giving the owned objects to someone else, through the use of the data stored in the new pg_shdepend catalog. Some refactoring of the GRANT/REVOKE code was needed, as well as ALTER OWNER code. Further cleanup of code duplication in the GRANT code seems necessary. Implemented by me after an idea from Tom Lane, who also provided various kind of implementation advice. Regression tests pass. Some tests for the new functionality are also added, as well as rudimentary documentation.
2005-11-21 13:49:33 +01:00
{
COMPARE_NODE_FIELD(roles);
COMPARE_SCALAR_FIELD(behavior);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
Implement DROP OWNED and REASSIGN OWNED. These new commands facilitate the process of dropping roles by dropping objects owned by them and privileges granted to them, or giving the owned objects to someone else, through the use of the data stored in the new pg_shdepend catalog. Some refactoring of the GRANT/REVOKE code was needed, as well as ALTER OWNER code. Further cleanup of code duplication in the GRANT code seems necessary. Implemented by me after an idea from Tom Lane, who also provided various kind of implementation advice. Regression tests pass. Some tests for the new functionality are also added, as well as rudimentary documentation.
2005-11-21 13:49:33 +01:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalReassignOwnedStmt(const ReassignOwnedStmt *a, const ReassignOwnedStmt *b)
Implement DROP OWNED and REASSIGN OWNED. These new commands facilitate the process of dropping roles by dropping objects owned by them and privileges granted to them, or giving the owned objects to someone else, through the use of the data stored in the new pg_shdepend catalog. Some refactoring of the GRANT/REVOKE code was needed, as well as ALTER OWNER code. Further cleanup of code duplication in the GRANT code seems necessary. Implemented by me after an idea from Tom Lane, who also provided various kind of implementation advice. Regression tests pass. Some tests for the new functionality are also added, as well as rudimentary documentation.
2005-11-21 13:49:33 +01:00
{
COMPARE_NODE_FIELD(roles);
Fix copyfuncs/equalfuncs support for ReassignOwnedStmt. Noah Misch
2012-04-18 16:45:18 +02:00
COMPARE_STRING_FIELD(newrole);
Implement DROP OWNED and REASSIGN OWNED. These new commands facilitate the process of dropping roles by dropping objects owned by them and privileges granted to them, or giving the owned objects to someone else, through the use of the data stored in the new pg_shdepend catalog. Some refactoring of the GRANT/REVOKE code was needed, as well as ALTER OWNER code. Further cleanup of code duplication in the GRANT code seems necessary. Implemented by me after an idea from Tom Lane, who also provided various kind of implementation advice. Regression tests pass. Some tests for the new functionality are also added, as well as rudimentary documentation.
2005-11-21 13:49:33 +01:00
return true;
}
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
Add missing copyfuncs/equalfuncs support for AlterTSDictionaryStmt and AlterTSConfigurationStmt. All utility statement node types are expected to be supported here, though they do not have to have outfuncs/readfuncs support. Found by running regression tests with COPY_PARSE_PLAN_TREES enabled.
2008-02-07 21:19:47 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterTSDictionaryStmt(const AlterTSDictionaryStmt *a, const AlterTSDictionaryStmt *b)
Add missing copyfuncs/equalfuncs support for AlterTSDictionaryStmt and AlterTSConfigurationStmt. All utility statement node types are expected to be supported here, though they do not have to have outfuncs/readfuncs support. Found by running regression tests with COPY_PARSE_PLAN_TREES enabled.
2008-02-07 21:19:47 +01:00
{
COMPARE_NODE_FIELD(dictname);
COMPARE_NODE_FIELD(options);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAlterTSConfigurationStmt(const AlterTSConfigurationStmt *a,
const AlterTSConfigurationStmt *b)
Add missing copyfuncs/equalfuncs support for AlterTSDictionaryStmt and AlterTSConfigurationStmt. All utility statement node types are expected to be supported here, though they do not have to have outfuncs/readfuncs support. Found by running regression tests with COPY_PARSE_PLAN_TREES enabled.
2008-02-07 21:19:47 +01:00
{
COMPARE_NODE_FIELD(cfgname);
COMPARE_NODE_FIELD(tokentype);
COMPARE_NODE_FIELD(dicts);
COMPARE_SCALAR_FIELD(override);
COMPARE_SCALAR_FIELD(replace);
COMPARE_SCALAR_FIELD(missing_ok);
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAExpr(const A_Expr *a, const A_Expr *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Get rid of last few vestiges of parsetree dependency on grammar token codes, per discussion from last March. parse.h should now be included *only* by gram.y, scan.l, keywords.c, parser.c. This prevents surprising misbehavior after seemingly-trivial grammar adjustments.
2003-02-10 05:44:47 +01:00
COMPARE_SCALAR_FIELD(kind);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(name);
COMPARE_NODE_FIELD(lexpr);
COMPARE_NODE_FIELD(rexpr);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalColumnRef(const ColumnRef *a, const ColumnRef *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(fields);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalParamRef(const ParamRef *a, const ParamRef *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(number);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAConst(const A_Const *a, const A_Const *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
pgindent run.
2003-08-04 02:43:34 +02:00
if (!equal(&a->val, &b->val)) /* hack for in-line Value field */
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return false;
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalFuncCall(const FuncCall *a, const FuncCall *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(funcname);
COMPARE_NODE_FIELD(args);
Support ORDER BY within aggregate function calls, at long last providing a non-kluge method for controlling the order in which values are fed to an aggregate function. At the same time eliminate the old implementation restriction that DISTINCT was only supported for single-argument aggregates. Possibly release-notable behavioral change: formerly, agg(DISTINCT x) dropped null values of x unconditionally. Now, it does so only if the agg transition function is strict; otherwise nulls are treated as DISTINCT normally would, ie, you get one copy. Andrew Gierth, reviewed by Hitoshi Harada
2009-12-15 18:57:48 +01:00
COMPARE_NODE_FIELD(agg_order);
Implement the FILTER clause for aggregate function calls. This is SQL-standard with a few extensions, namely support for subqueries and outer references in clause expressions. catversion bump due to change in Aggref and WindowFunc. David Fetter, reviewed by Dean Rasheed.
2013-07-17 02:15:36 +02:00
COMPARE_NODE_FIELD(agg_filter);
Support ordered-set (WITHIN GROUP) aggregates. This patch introduces generic support for ordered-set and hypothetical-set aggregate functions, as well as implementations of the instances defined in SQL:2008 (percentile_cont(), percentile_disc(), rank(), dense_rank(), percent_rank(), cume_dist()). We also added mode() though it is not in the spec, as well as versions of percentile_cont() and percentile_disc() that can compute multiple percentile values in one pass over the data. Unlike the original submission, this patch puts full control of the sorting process in the hands of the aggregate's support functions. To allow the support functions to find out how they're supposed to sort, a new API function AggGetAggref() is added to nodeAgg.c. This allows retrieval of the aggregate call's Aggref node, which may have other uses beyond the immediate need. There is also support for ordered-set aggregates to install cleanup callback functions, so that they can be sure that infrastructure such as tuplesort objects gets cleaned up. In passing, make some fixes in the recently-added support for variadic aggregates, and make some editorial adjustments in the recent FILTER additions for aggregates. Also, simplify use of IsBinaryCoercible() by allowing it to succeed whenever the target type is ANY or ANYELEMENT. It was inconsistent that it dealt with other polymorphic target types but not these. Atri Sharma and Andrew Gierth; reviewed by Pavel Stehule and Vik Fearing, and rather heavily editorialized upon by Tom Lane
2013-12-23 22:11:35 +01:00
COMPARE_SCALAR_FIELD(agg_within_group);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(agg_star);
COMPARE_SCALAR_FIELD(agg_distinct);
Support "variadic" functions, which can accept a variable number of arguments so long as all the trailing arguments are of the same (non-array) type. The function receives them as a single array argument (which is why they have to all be the same type). It might be useful to extend this facility to aggregates, but this patch doesn't do that. This patch imposes a noticeable slowdown on function lookup --- a follow-on patch will fix that by adding a redundant column to pg_proc. Pavel Stehule
2008-07-16 03:30:23 +02:00
COMPARE_SCALAR_FIELD(func_variadic);
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
COMPARE_NODE_FIELD(over);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Fix the raw-parsetree representation of star (as in SELECT * FROM or SELECT foo.*) so that it cannot be confused with a quoted identifier "*". Instead create a separate node type A_Star to represent this notation. Per pgsql-hackers discussion of 2007-Sep-27.
2008-08-30 03:39:14 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAStar(const A_Star *a, const A_Star *b)
Fix the raw-parsetree representation of star (as in SELECT * FROM or SELECT foo.*) so that it cannot be confused with a quoted identifier "*". Instead create a separate node type A_Star to represent this notation. Per pgsql-hackers discussion of 2007-Sep-27.
2008-08-30 03:39:14 +02:00
{
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalAIndices(const A_Indices *a, const A_Indices *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(lidx);
COMPARE_NODE_FIELD(uidx);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't *do* anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname.
2002-03-21 17:02:16 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalA_Indirection(const A_Indirection *a, const A_Indirection *b)
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't *do* anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname.
2002-03-21 17:02:16 +01:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(arg);
COMPARE_NODE_FIELD(indirection);
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't *do* anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname.
2002-03-21 17:02:16 +01:00
return true;
}
Arrange for an explicit cast applied to an ARRAY[] constructor to be applied directly to all the member expressions, instead of the previous implementation where the ARRAY[] constructor would infer a common element type and then we'd coerce the finished array after the fact. This has a number of benefits, one being that we can allow an empty ARRAY[] construct so long as its element type is specified by such a cast. Brendan Jurd, minor fixes by me.
2008-03-20 22:42:48 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalA_ArrayExpr(const A_ArrayExpr *a, const A_ArrayExpr *b)
Arrange for an explicit cast applied to an ARRAY[] constructor to be applied directly to all the member expressions, instead of the previous implementation where the ARRAY[] constructor would infer a common element type and then we'd coerce the finished array after the fact. This has a number of benefits, one being that we can allow an empty ARRAY[] construct so long as its element type is specified by such a cast. Brendan Jurd, minor fixes by me.
2008-03-20 22:42:48 +01:00
{
COMPARE_NODE_FIELD(elements);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Arrange for an explicit cast applied to an ARRAY[] constructor to be applied directly to all the member expressions, instead of the previous implementation where the ARRAY[] constructor would infer a common element type and then we'd coerce the finished array after the fact. This has a number of benefits, one being that we can allow an empty ARRAY[] construct so long as its element type is specified by such a cast. Brendan Jurd, minor fixes by me.
2008-03-20 22:42:48 +01:00
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalResTarget(const ResTarget *a, const ResTarget *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(name);
COMPARE_NODE_FIELD(indirection);
COMPARE_NODE_FIELD(val);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalTypeName(const TypeName *a, const TypeName *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(names);
Make backend header files C++ safe This alters various incidental uses of C++ key words to use other similar identifiers, so that a C++ compiler won't choke outright. You still (probably) need extern "C" { }; around the inclusion of backend headers. based on a patch by Kurt Harriman <harriman@acm.org> Also add a script cpluspluscheck to check for C++ compatibility in the future. As of right now, this passes without error for me.
2009-07-16 08:33:46 +02:00
COMPARE_SCALAR_FIELD(typeOid);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(setof);
COMPARE_SCALAR_FIELD(pct_type);
Support type modifiers for user-defined types, and pull most knowledge about typmod representation for standard types out into type-specific typmod I/O functions. Teodor Sigaev, with some editorialization by Tom Lane.
2006-12-30 22:21:56 +01:00
COMPARE_NODE_FIELD(typmods);
COMPARE_SCALAR_FIELD(typemod);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(arrayBounds);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't *do* anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname.
2002-03-21 17:02:16 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalTypeCast(const TypeCast *a, const TypeCast *b)
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't *do* anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname.
2002-03-21 17:02:16 +01:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(arg);
Make backend header files C++ safe This alters various incidental uses of C++ key words to use other similar identifiers, so that a C++ compiler won't choke outright. You still (probably) need extern "C" { }; around the inclusion of backend headers. based on a patch by Kurt Harriman <harriman@acm.org> Also add a script cpluspluscheck to check for C++ compatibility in the future. As of right now, this passes without error for me.
2009-07-16 08:33:46 +02:00
COMPARE_NODE_FIELD(typeName);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't *do* anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname.
2002-03-21 17:02:16 +01:00
return true;
}
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCollateClause(const CollateClause *a, const CollateClause *b)
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
{
COMPARE_NODE_FIELD(arg);
Split CollateClause into separate raw and analyzed node types. CollateClause is now used only in raw grammar output, and CollateExpr after parse analysis. This is for clarity and to avoid carrying collation names in post-analysis parse trees: that's both wasteful and possibly misleading, since the collation's name could be changed while the parsetree still exists. Also, clean up assorted infelicities and omissions in processing of the node type.
2011-03-11 22:27:51 +01:00
COMPARE_NODE_FIELD(collname);
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
COMPARE_LOCATION_FIELD(location);
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalSortBy(const SortBy *a, const SortBy *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Add a bunch of new error location reports to parse-analysis error messages. There are still some weak spots around JOIN USING and relation alias lists, but most errors reported within backend/parser/ now have locations.
2008-09-01 22:42:46 +02:00
COMPARE_NODE_FIELD(node);
Support ORDER BY ... NULLS FIRST/LAST, and add ASC/DESC/NULLS FIRST/NULLS LAST per-column options for btree indexes. The planner's support for this is still pretty rudimentary; it does not yet know how to plan mergejoins with nondefault ordering options. The documentation is pretty rudimentary, too. I'll work on improving that stuff later. Note incompatible change from prior behavior: ORDER BY ... USING will now be rejected if the operator is not a less-than or greater-than member of some btree opclass. This prevents less-than-sane behavior if an operator that doesn't actually define a proper sort ordering is selected.
2007-01-09 03:14:16 +01:00
COMPARE_SCALAR_FIELD(sortby_dir);
COMPARE_SCALAR_FIELD(sortby_nulls);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(useOp);
Add a bunch of new error location reports to parse-analysis error messages. There are still some weak spots around JOIN USING and relation alias lists, but most errors reported within backend/parser/ now have locations.
2008-09-01 22:42:46 +02:00
COMPARE_LOCATION_FIELD(location);
Fix merge failures for anonymous-type patch. From Joe Conway.
2002-08-05 01:49:59 +02:00
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalWindowDef(const WindowDef *a, const WindowDef *b)
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
{
COMPARE_STRING_FIELD(name);
COMPARE_STRING_FIELD(refname);
COMPARE_NODE_FIELD(partitionClause);
COMPARE_NODE_FIELD(orderClause);
Add some basic support for window frame clauses to the window-functions patch. This includes the ability to force the frame to cover the whole partition, and the ability to make the frame end exactly on the current row rather than its last ORDER BY peer. Supporting any more of the full SQL frame-clause syntax will require nontrivial hacking on the window aggregate code, so it'll have to wait for 8.5 or beyond.
2008-12-31 01:08:39 +01:00
COMPARE_SCALAR_FIELD(frameOptions);
Extend the set of frame options supported for window functions. This patch allows the frame to start from CURRENT ROW (in either RANGE or ROWS mode), and it also adds support for ROWS n PRECEDING and ROWS n FOLLOWING start and end points. (RANGE value PRECEDING/FOLLOWING isn't there yet --- the grammar works, but that's all.) Hitoshi Harada, reviewed by Pavel Stehule
2010-02-12 18:33:21 +01:00
COMPARE_NODE_FIELD(startOffset);
COMPARE_NODE_FIELD(endOffset);
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
COMPARE_LOCATION_FIELD(location);
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalRangeSubselect(const RangeSubselect *a, const RangeSubselect *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Implement SQL-standard LATERAL subqueries. This patch implements the standard syntax of LATERAL attached to a sub-SELECT in FROM, and also allows LATERAL attached to a function in FROM, since set-returning function calls are expected to be one of the principal use-cases. The main change here is a rewrite of the mechanism for keeping track of which relations are visible for column references while the FROM clause is being scanned. The parser "namespace" lists are no longer lists of bare RTEs, but are lists of ParseNamespaceItem structs, which carry an RTE pointer as well as some visibility-controlling flags. Aside from supporting LATERAL correctly, this lets us get rid of the ancient hacks that required rechecking subqueries and JOIN/ON and function-in-FROM expressions for invalid references after they were initially parsed. Invalid column references are now always correctly detected on sight. In passing, remove assorted parser error checks that are now dead code by virtue of our having gotten rid of add_missing_from, as well as some comments that are obsolete for the same reason. (It was mainly add_missing_from that caused so much fudging here in the first place.) The planner support for this feature is very minimal, and will be improved in future patches. It works well enough for testing purposes, though. catversion bump forced due to new field in RangeTblEntry.
2012-08-08 01:02:54 +02:00
COMPARE_SCALAR_FIELD(lateral);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(subquery);
COMPARE_NODE_FIELD(alias);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
First pass at set-returning-functions in FROM, by Joe Conway with some kibitzing from Tom Lane. Not everything works yet, and there's no documentation or regression test, but let's commit this so Joe doesn't need to cope with tracking changes in so many files ...
2002-05-12 22:10:05 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalRangeFunction(const RangeFunction *a, const RangeFunction *b)
First pass at set-returning-functions in FROM, by Joe Conway with some kibitzing from Tom Lane. Not everything works yet, and there's no documentation or regression test, but let's commit this so Joe doesn't need to cope with tracking changes in so many files ...
2002-05-12 22:10:05 +02:00
{
Implement SQL-standard LATERAL subqueries. This patch implements the standard syntax of LATERAL attached to a sub-SELECT in FROM, and also allows LATERAL attached to a function in FROM, since set-returning function calls are expected to be one of the principal use-cases. The main change here is a rewrite of the mechanism for keeping track of which relations are visible for column references while the FROM clause is being scanned. The parser "namespace" lists are no longer lists of bare RTEs, but are lists of ParseNamespaceItem structs, which carry an RTE pointer as well as some visibility-controlling flags. Aside from supporting LATERAL correctly, this lets us get rid of the ancient hacks that required rechecking subqueries and JOIN/ON and function-in-FROM expressions for invalid references after they were initially parsed. Invalid column references are now always correctly detected on sight. In passing, remove assorted parser error checks that are now dead code by virtue of our having gotten rid of add_missing_from, as well as some comments that are obsolete for the same reason. (It was mainly add_missing_from that caused so much fudging here in the first place.) The planner support for this feature is very minimal, and will be improved in future patches. It works well enough for testing purposes, though. catversion bump forced due to new field in RangeTblEntry.
2012-08-08 01:02:54 +02:00
COMPARE_SCALAR_FIELD(lateral);
Support multi-argument UNNEST(), and TABLE() syntax for multiple functions. This patch adds the ability to write TABLE( function1(), function2(), ...) as a single FROM-clause entry. The result is the concatenation of the first row from each function, followed by the second row from each function, etc; with NULLs inserted if any function produces fewer rows than others. This is believed to be a much more useful behavior than what Postgres currently does with multiple SRFs in a SELECT list. This syntax also provides a reasonable way to combine use of column definition lists with WITH ORDINALITY: put the column definition list inside TABLE(), where it's clear that it doesn't control the ordinality column as well. Also implement SQL-compliant multiple-argument UNNEST(), by turning UNNEST(a,b,c) into TABLE(unnest(a), unnest(b), unnest(c)). The SQL standard specifies TABLE() with only a single function, not multiple functions, and it seems to require an implicit UNNEST() which is not what this patch does. There may be something wrong with that reading of the spec, though, because if it's right then the spec's TABLE() is just a pointless alternative spelling of UNNEST(). After further review of that, we might choose to adopt a different syntax for what this patch does, but in any case this functionality seems clearly worthwhile. Andrew Gierth, reviewed by Zoltán Böszörményi and Heikki Linnakangas, and significantly revised by me
2013-11-22 01:37:02 +01:00
COMPARE_SCALAR_FIELD(ordinality);
Rename TABLE() to ROWS FROM(). SQL-standard TABLE() is a subset of UNNEST(); they deal with arrays and other collection types. This feature, however, deals with set-returning functions. Use a different syntax for this feature to keep open the possibility of implementing the standard TABLE().
2013-12-10 15:34:37 +01:00
COMPARE_SCALAR_FIELD(is_rowsfrom);
Support multi-argument UNNEST(), and TABLE() syntax for multiple functions. This patch adds the ability to write TABLE( function1(), function2(), ...) as a single FROM-clause entry. The result is the concatenation of the first row from each function, followed by the second row from each function, etc; with NULLs inserted if any function produces fewer rows than others. This is believed to be a much more useful behavior than what Postgres currently does with multiple SRFs in a SELECT list. This syntax also provides a reasonable way to combine use of column definition lists with WITH ORDINALITY: put the column definition list inside TABLE(), where it's clear that it doesn't control the ordinality column as well. Also implement SQL-compliant multiple-argument UNNEST(), by turning UNNEST(a,b,c) into TABLE(unnest(a), unnest(b), unnest(c)). The SQL standard specifies TABLE() with only a single function, not multiple functions, and it seems to require an implicit UNNEST() which is not what this patch does. There may be something wrong with that reading of the spec, though, because if it's right then the spec's TABLE() is just a pointless alternative spelling of UNNEST(). After further review of that, we might choose to adopt a different syntax for what this patch does, but in any case this functionality seems clearly worthwhile. Andrew Gierth, reviewed by Zoltán Böszörményi and Heikki Linnakangas, and significantly revised by me
2013-11-22 01:37:02 +01:00
COMPARE_NODE_FIELD(functions);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(alias);
COMPARE_NODE_FIELD(coldeflist);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalIndexElem(const IndexElem *a, const IndexElem *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(name);
Replace functional-index facility with expressional indexes. Any column of an index can now be a computed expression instead of a simple variable. Restrictions on expressions are the same as for predicates (only immutable functions, no sub-selects). This fixes problems recently introduced with inlining SQL functions, because the inlining transformation is applied to both expression trees so the planner can still match them up. Along the way, improve efficiency of handling index predicates (both predicates and index expressions are now cached by the relcache) and fix 7.3 oversight that didn't record dependencies of predicate expressions.
2003-05-28 18:04:02 +02:00
COMPARE_NODE_FIELD(expr);
Adjust naming of indexes and their columns per recent discussion. Index expression columns are now named after the FigureColname result for their expressions, rather than always being "pg_expression_N". Digits are appended to this name if needed to make the column name unique within the index. (That happens for regular columns too, thus fixing the old problem that CREATE INDEX fooi ON foo (f1, f1) fails. Before exclusion indexes there was no real reason to do such a thing, but now maybe there is.) Default names for indexes and associated constraints now include the column names of all their columns, not only the first one as in previous practice. (Of course, this will be truncated as needed to fit in NAMEDATALEN. Also, pkey indexes retain the historical behavior of not naming specific columns at all.) An example of the results: regression=# create table foo (f1 int, f2 text, regression(# exclude (f1 with =, lower(f2) with =)); NOTICE: CREATE TABLE / EXCLUDE will create implicit index "foo_f1_lower_exclusion" for table "foo" CREATE TABLE regression=# \d foo_f1_lower_exclusion Index "public.foo_f1_lower_exclusion" Column | Type | Definition --------+---------+------------ f1 | integer | f1 lower | text | lower(f2) btree, for table "public.foo"
2009-12-23 03:35:25 +01:00
COMPARE_STRING_FIELD(indexcolname);
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
COMPARE_NODE_FIELD(collation);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(opclass);
Support ORDER BY ... NULLS FIRST/LAST, and add ASC/DESC/NULLS FIRST/NULLS LAST per-column options for btree indexes. The planner's support for this is still pretty rudimentary; it does not yet know how to plan mergejoins with nondefault ordering options. The documentation is pretty rudimentary, too. I'll work on improving that stuff later. Note incompatible change from prior behavior: ORDER BY ... USING will now be rejected if the operator is not a less-than or greater-than member of some btree opclass. This prevents less-than-sane behavior if an operator that doesn't actually define a proper sort ordering is selected.
2007-01-09 03:14:16 +01:00
COMPARE_SCALAR_FIELD(ordering);
COMPARE_SCALAR_FIELD(nulls_ordering);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalColumnDef(const ColumnDef *a, const ColumnDef *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(colname);
Make backend header files C++ safe This alters various incidental uses of C++ key words to use other similar identifiers, so that a C++ compiler won't choke outright. You still (probably) need extern "C" { }; around the inclusion of backend headers. based on a patch by Kurt Harriman <harriman@acm.org> Also add a script cpluspluscheck to check for C++ compatibility in the future. As of right now, this passes without error for me.
2009-07-16 08:33:46 +02:00
COMPARE_NODE_FIELD(typeName);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(inhcount);
COMPARE_SCALAR_FIELD(is_local);
COMPARE_SCALAR_FIELD(is_not_null);
Remove collation information from TypeName, where it does not belong. The initial collations patch treated a COLLATE spec as part of a TypeName, following what can only be described as brain fade on the part of the SQL committee. It's a lot more reasonable to treat COLLATE as a syntactically separate object, so that it can be added in only the productions where it actually belongs, rather than needing to reject it in a boatload of places where it doesn't belong (something the original patch mostly failed to do). In addition this change lets us meet the spec's requirement to allow COLLATE anywhere in the clauses of a ColumnDef, and it avoids unfriendly behavior for constructs such as "foo::type COLLATE collation". To do this, pull collation information out of TypeName and put it in ColumnDef instead, thus reverting most of the collation-related changes in parse_type.c's API. I made one additional structural change, which was to use a ColumnDef as an intermediate node in AT_AlterColumnType AlterTableCmd nodes. This provides enough room to get rid of the "transform" wart in AlterTableCmd too, since the ColumnDef can carry the USING expression easily enough. Also fix some other minor bugs that have crept in in the same areas, like failure to copy recently-added fields of ColumnDef in copyfuncs.c. While at it, document the formerly secret ability to specify a collation in ALTER TABLE ALTER COLUMN TYPE, ALTER TYPE ADD ATTRIBUTE, and ALTER TYPE ALTER ATTRIBUTE TYPE; and correct some misstatements about what the default collation selection will be when COLLATE is omitted. BTW, the three-parameter form of format_type() should go away too, since it just contributes to the confusion in this area; but I'll do that in a separate patch.
2011-03-10 04:38:52 +01:00
COMPARE_SCALAR_FIELD(is_from_type);
Code review for LIKE INCLUDING patch --- clean up some cosmetic and not so cosmetic stuff.
2009-10-13 02:53:08 +02:00
COMPARE_SCALAR_FIELD(storage);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(raw_default);
Change CREATE TABLE so that column default expressions coming from different inheritance parent tables are compared using equal(), instead of doing strcmp() on the nodeToString representation. The old implementation was always a tad cheesy, and it finally fails completely as of 8.4, now that the node tree might contain syntax location information. equal() knows it's supposed to ignore those fields, but strcmp() hardly can. Per recent report from Scott Ribe.
2009-10-06 02:55:26 +02:00
COMPARE_NODE_FIELD(cooked_default);
Remove collation information from TypeName, where it does not belong. The initial collations patch treated a COLLATE spec as part of a TypeName, following what can only be described as brain fade on the part of the SQL committee. It's a lot more reasonable to treat COLLATE as a syntactically separate object, so that it can be added in only the productions where it actually belongs, rather than needing to reject it in a boatload of places where it doesn't belong (something the original patch mostly failed to do). In addition this change lets us meet the spec's requirement to allow COLLATE anywhere in the clauses of a ColumnDef, and it avoids unfriendly behavior for constructs such as "foo::type COLLATE collation". To do this, pull collation information out of TypeName and put it in ColumnDef instead, thus reverting most of the collation-related changes in parse_type.c's API. I made one additional structural change, which was to use a ColumnDef as an intermediate node in AT_AlterColumnType AlterTableCmd nodes. This provides enough room to get rid of the "transform" wart in AlterTableCmd too, since the ColumnDef can carry the USING expression easily enough. Also fix some other minor bugs that have crept in in the same areas, like failure to copy recently-added fields of ColumnDef in copyfuncs.c. While at it, document the formerly secret ability to specify a collation in ALTER TABLE ALTER COLUMN TYPE, ALTER TYPE ADD ATTRIBUTE, and ALTER TYPE ALTER ATTRIBUTE TYPE; and correct some misstatements about what the default collation selection will be when COLLATE is omitted. BTW, the three-parameter form of format_type() should go away too, since it just contributes to the confusion in this area; but I'll do that in a separate patch.
2011-03-10 04:38:52 +01:00
COMPARE_NODE_FIELD(collClause);
COMPARE_SCALAR_FIELD(collOid);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(constraints);
Fix various infelicities in node functions. Mostly, this consists of adding support for fields which exist in the structure but aren't handled by copy/equal/outfuncs; but the create foreign table case can actually produce garbage output. Noah Misch
2012-04-18 16:43:16 +02:00
COMPARE_NODE_FIELD(fdwoptions);
Support multi-argument UNNEST(), and TABLE() syntax for multiple functions. This patch adds the ability to write TABLE( function1(), function2(), ...) as a single FROM-clause entry. The result is the concatenation of the first row from each function, followed by the second row from each function, etc; with NULLs inserted if any function produces fewer rows than others. This is believed to be a much more useful behavior than what Postgres currently does with multiple SRFs in a SELECT list. This syntax also provides a reasonable way to combine use of column definition lists with WITH ORDINALITY: put the column definition list inside TABLE(), where it's clear that it doesn't control the ordinality column as well. Also implement SQL-compliant multiple-argument UNNEST(), by turning UNNEST(a,b,c) into TABLE(unnest(a), unnest(b), unnest(c)). The SQL standard specifies TABLE() with only a single function, not multiple functions, and it seems to require an implicit UNNEST() which is not what this patch does. There may be something wrong with that reading of the spec, though, because if it's right then the spec's TABLE() is just a pointless alternative spelling of UNNEST(). After further review of that, we might choose to adopt a different syntax for what this patch does, but in any case this functionality seems clearly worthwhile. Andrew Gierth, reviewed by Zoltán Böszörményi and Heikki Linnakangas, and significantly revised by me
2013-11-22 01:37:02 +01:00
COMPARE_LOCATION_FIELD(location);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalConstraint(const Constraint *a, const Constraint *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(contype);
Merge the Constraint and FkConstraint node types into a single type. This was foreseen to be a good idea long ago, but nobody had got round to doing it. The recent patch for deferred unique constraints made transformConstraintAttrs() ugly enough that I decided it was time. This change will also greatly simplify parsing of deferred CHECK constraints, if anyone ever gets around to implementing that. While at it, add a location field to Constraint, and use that to provide an error cursor for some of the constraint-related error messages.
2009-07-30 04:45:38 +02:00
COMPARE_STRING_FIELD(conname);
COMPARE_SCALAR_FIELD(deferrable);
COMPARE_SCALAR_FIELD(initdeferred);
COMPARE_LOCATION_FIELD(location);
Recast "ONLY" column CHECK constraints as NO INHERIT The original syntax wasn't universally loved, and it didn't allow its usage in CREATE TABLE, only ALTER TABLE. It now works everywhere, and it also allows using ALTER TABLE ONLY to add an uninherited CHECK constraint, per discussion. The pg_constraint column has accordingly been renamed connoinherit. This commit partly reverts some of the changes in 61d81bd28dbec65a6b144e0cd3d0bfe25913c3ac, particularly some pg_dump and psql bits, because now pg_get_constraintdef includes the necessary NO INHERIT within the constraint definition. Author: Nikhil Sontakke Some tweaks by me
2012-04-21 04:46:20 +02:00
COMPARE_SCALAR_FIELD(is_no_inherit);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(raw_expr);
COMPARE_STRING_FIELD(cooked_expr);
COMPARE_NODE_FIELD(keys);
Add exclusion constraints, which generalize the concept of uniqueness to support any indexable commutative operator, not just equality. Two rows violate the exclusion constraint if "row1.col OP row2.col" is TRUE for each of the columns in the constraint. Jeff Davis, reviewed by Robert Haas
2009-12-07 06:22:23 +01:00
COMPARE_NODE_FIELD(exclusions);
Add FILLFACTOR to CREATE INDEX. ITAGAKI Takahiro
2006-07-02 04:23:23 +02:00
COMPARE_NODE_FIELD(options);
Implement ALTER TABLE ADD UNIQUE/PRIMARY KEY USING INDEX. This feature allows a unique or pkey constraint to be created using an already-existing unique index. While the constraint isn't very functionally different from the bare index, it's nice to be able to do that for documentation purposes. The main advantage over just issuing a plain ALTER TABLE ADD UNIQUE/PRIMARY KEY is that the index can be created with CREATE INDEX CONCURRENTLY, so that there is not a long interval where the table is locked against updates. On the way, refactor some of the code in DefineIndex() and index_create() so that we don't have to pass through those functions in order to create the index constraint's catalog entries. Also, in parse_utilcmd.c, pass around the ParseState pointer in struct CreateStmtContext to save on notation, and add error location pointers to some error reports that didn't have one before. Gurjeet Singh, reviewed by Steve Singer and Tom Lane
2011-01-25 21:42:03 +01:00
COMPARE_STRING_FIELD(indexname);
Support USING INDEX TABLESPACE clause for PRIMARY KEY and UNIQUE constraints. Christopher Kings-Lynne.
2004-08-02 06:28:29 +02:00
COMPARE_STRING_FIELD(indexspace);
Add exclusion constraints, which generalize the concept of uniqueness to support any indexable commutative operator, not just equality. Two rows violate the exclusion constraint if "row1.col OP row2.col" is TRUE for each of the columns in the constraint. Jeff Davis, reviewed by Robert Haas
2009-12-07 06:22:23 +01:00
COMPARE_STRING_FIELD(access_method);
COMPARE_NODE_FIELD(where_clause);
Merge the Constraint and FkConstraint node types into a single type. This was foreseen to be a good idea long ago, but nobody had got round to doing it. The recent patch for deferred unique constraints made transformConstraintAttrs() ugly enough that I decided it was time. This change will also greatly simplify parsing of deferred CHECK constraints, if anyone ever gets around to implementing that. While at it, add a location field to Constraint, and use that to provide an error cursor for some of the constraint-related error messages.
2009-07-30 04:45:38 +02:00
COMPARE_NODE_FIELD(pktable);
COMPARE_NODE_FIELD(fk_attrs);
COMPARE_NODE_FIELD(pk_attrs);
COMPARE_SCALAR_FIELD(fk_matchtype);
COMPARE_SCALAR_FIELD(fk_upd_action);
COMPARE_SCALAR_FIELD(fk_del_action);
ALTER TABLE: skip FK validation when it's safe to do so We already skip rewriting the table in these cases, but we still force a whole table scan to validate the data. This can be skipped, and thus we can make the whole ALTER TABLE operation just do some catalog touches instead of scanning the table, when these two conditions hold: (a) Old and new pg_constraint.conpfeqop match exactly. This is actually stronger than needed; we could loosen things by way of operator families, but it'd require a lot more effort. (b) The functions, if any, implementing a cast from the foreign type to the primary opcintype are the same. For this purpose, we can consider a binary coercion equivalent to an exact type match. When the opcintype is polymorphic, require that the old and new foreign types match exactly. (Since ri_triggers.c does use the executor, the stronger check for polymorphic types is no mere future-proofing. However, no core type exercises its necessity.) Author: Noah Misch Committer's note: catalog version bumped due to change of the Constraint node. I can't actually find any way to have such a node in a stored rule, but given that we have "out" support for them, better be safe.
2012-02-27 22:28:00 +01:00
COMPARE_NODE_FIELD(old_conpfeqop);
Merge the Constraint and FkConstraint node types into a single type. This was foreseen to be a good idea long ago, but nobody had got round to doing it. The recent patch for deferred unique constraints made transformConstraintAttrs() ugly enough that I decided it was time. This change will also greatly simplify parsing of deferred CHECK constraints, if anyone ever gets around to implementing that. While at it, add a location field to Constraint, and use that to provide an error cursor for some of the constraint-related error messages.
2009-07-30 04:45:38 +02:00
COMPARE_SCALAR_FIELD(skip_validation);
Make FKs valid at creation when added as column constraints. Bug report from Alvaro Herrera
2011-03-23 00:10:35 +01:00
COMPARE_SCALAR_FIELD(initially_valid);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalDefElem(const DefElem *a, const DefElem *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Remove the recently added node types ReloptElem and OptionDefElem in favor of adding optional namespace and action fields to DefElem. Having three node types that do essentially the same thing bloats the code and leads to errors of confusion, such as in yesterday's bug report from Khee Chin.
2009-04-04 23:12:31 +02:00
COMPARE_STRING_FIELD(defnamespace);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(defname);
COMPARE_NODE_FIELD(arg);
Remove the recently added node types ReloptElem and OptionDefElem in favor of adding optional namespace and action fields to DefElem. Having three node types that do essentially the same thing bloats the code and leads to errors of confusion, such as in yesterday's bug report from Khee Chin.
2009-04-04 23:12:31 +02:00
COMPARE_SCALAR_FIELD(defaction);
Allow reloption names to have qualifiers, initially supporting a TOAST qualifier, and add support for this in pg_dump. This allows TOAST tables to have user-defined fillfactor, and will also enable us to move the autovacuum parameters to reloptions without taking away the possibility of setting values for TOAST tables.
2009-02-02 20:31:40 +01:00
return true;
}
Add NOWAIT option to SELECT FOR UPDATE/SHARE. Original patch by Hans-Juergen Schoenig, revisions by Karel Zak and Tom Lane.
2005-08-01 22:31:16 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalLockingClause(const LockingClause *a, const LockingClause *b)
Add NOWAIT option to SELECT FOR UPDATE/SHARE. Original patch by Hans-Juergen Schoenig, revisions by Karel Zak and Tom Lane.
2005-08-01 22:31:16 +02:00
{
COMPARE_NODE_FIELD(lockedRels);
Improve concurrency of foreign key locking This patch introduces two additional lock modes for tuples: "SELECT FOR KEY SHARE" and "SELECT FOR NO KEY UPDATE". These don't block each other, in contrast with already existing "SELECT FOR SHARE" and "SELECT FOR UPDATE". UPDATE commands that do not modify the values stored in the columns that are part of the key of the tuple now grab a SELECT FOR NO KEY UPDATE lock on the tuple, allowing them to proceed concurrently with tuple locks of the FOR KEY SHARE variety. Foreign key triggers now use FOR KEY SHARE instead of FOR SHARE; this means the concurrency improvement applies to them, which is the whole point of this patch. The added tuple lock semantics require some rejiggering of the multixact module, so that the locking level that each transaction is holding can be stored alongside its Xid. Also, multixacts now need to persist across server restarts and crashes, because they can now represent not only tuple locks, but also tuple updates. This means we need more careful tracking of lifetime of pg_multixact SLRU files; since they now persist longer, we require more infrastructure to figure out when they can be removed. pg_upgrade also needs to be careful to copy pg_multixact files over from the old server to the new, or at least part of multixact.c state, depending on the versions of the old and new servers. Tuple time qualification rules (HeapTupleSatisfies routines) need to be careful not to consider tuples with the "is multi" infomask bit set as being only locked; they might need to look up MultiXact values (i.e. possibly do pg_multixact I/O) to find out the Xid that updated a tuple, whereas they previously were assured to only use information readily available from the tuple header. This is considered acceptable, because the extra I/O would involve cases that would previously cause some commands to block waiting for concurrent transactions to finish. Another important change is the fact that locking tuples that have previously been updated causes the future versions to be marked as locked, too; this is essential for correctness of foreign key checks. This causes additional WAL-logging, also (there was previously a single WAL record for a locked tuple; now there are as many as updated copies of the tuple there exist.) With all this in place, contention related to tuples being checked by foreign key rules should be much reduced. As a bonus, the old behavior that a subtransaction grabbing a stronger tuple lock than the parent (sub)transaction held on a given tuple and later aborting caused the weaker lock to be lost, has been fixed. Many new spec files were added for isolation tester framework, to ensure overall behavior is sane. There's probably room for several more tests. There were several reviewers of this patch; in particular, Noah Misch and Andres Freund spent considerable time in it. Original idea for the patch came from Simon Riggs, after a problem report by Joel Jacobson. Most code is from me, with contributions from Marti Raudsepp, Alexander Shulgin, Noah Misch and Andres Freund. This patch was discussed in several pgsql-hackers threads; the most important start at the following message-ids: AANLkTimo9XVcEzfiBR-ut3KVNDkjm2Vxh+t8kAmWjPuv@mail.gmail.com 1290721684-sup-3951@alvh.no-ip.org 1294953201-sup-2099@alvh.no-ip.org 1320343602-sup-2290@alvh.no-ip.org 1339690386-sup-8927@alvh.no-ip.org 4FE5FF020200002500048A3D@gw.wicourts.gov 4FEAB90A0200002500048B7D@gw.wicourts.gov
2013-01-23 16:04:59 +01:00
COMPARE_SCALAR_FIELD(strength);
Improve the representation of FOR UPDATE/FOR SHARE so that we can support both FOR UPDATE and FOR SHARE in one command, as well as both NOWAIT and normal WAIT behavior. The more general code is actually simpler and cleaner.
2006-04-30 20:30:40 +02:00
COMPARE_SCALAR_FIELD(noWait);
Add NOWAIT option to SELECT FOR UPDATE/SHARE. Original patch by Hans-Juergen Schoenig, revisions by Karel Zak and Tom Lane.
2005-08-01 22:31:16 +02:00
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(rtekind);
COMPARE_SCALAR_FIELD(relid);
Add a relkind field to RangeTblEntry to avoid some syscache lookups. The recent additions for FDW support required checking foreign-table-ness in several places in the parse/plan chain. While it's not clear whether that would really result in a noticeable slowdown, it seems best to avoid any performance risk by keeping a copy of the relation's relkind in RangeTblEntry. That might have some other uses later, anyway. Per discussion.
2011-02-23 01:23:23 +01:00
COMPARE_SCALAR_FIELD(relkind);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(subquery);
Add a security_barrier option for views. When a view is marked as a security barrier, it will not be pulled up into the containing query, and no quals will be pushed down into it, so that no function or operator chosen by the user can be applied to rows not exposed by the view. Views not configured with this option cannot provide robust row-level security, but will perform far better. Patch by KaiGai Kohei; original problem report by Heikki Linnakangas (in October 2009!). Review (in earlier versions) by Noah Misch and others. Design advice by Tom Lane and myself. Further review and cleanup by me.
2011-12-22 22:15:57 +01:00
COMPARE_SCALAR_FIELD(security_barrier);
Implement SQL-standard WITH clauses, including WITH RECURSIVE. There are some unimplemented aspects: recursive queries must use UNION ALL (should allow UNION too), and we don't have SEARCH or CYCLE clauses. These might or might not get done for 8.4, but even without them it's a pretty useful feature. There are also a couple of small loose ends and definitional quibbles, which I'll send a memo about to pgsql-hackers shortly. But let's land the patch now so we can get on with other development. Yoshiyuki Asaba, with lots of help from Tatsuo Ishii and Tom Lane
2008-10-04 23:56:55 +02:00
COMPARE_SCALAR_FIELD(jointype);
COMPARE_NODE_FIELD(joinaliasvars);
Support multi-argument UNNEST(), and TABLE() syntax for multiple functions. This patch adds the ability to write TABLE( function1(), function2(), ...) as a single FROM-clause entry. The result is the concatenation of the first row from each function, followed by the second row from each function, etc; with NULLs inserted if any function produces fewer rows than others. This is believed to be a much more useful behavior than what Postgres currently does with multiple SRFs in a SELECT list. This syntax also provides a reasonable way to combine use of column definition lists with WITH ORDINALITY: put the column definition list inside TABLE(), where it's clear that it doesn't control the ordinality column as well. Also implement SQL-compliant multiple-argument UNNEST(), by turning UNNEST(a,b,c) into TABLE(unnest(a), unnest(b), unnest(c)). The SQL standard specifies TABLE() with only a single function, not multiple functions, and it seems to require an implicit UNNEST() which is not what this patch does. There may be something wrong with that reading of the spec, though, because if it's right then the spec's TABLE() is just a pointless alternative spelling of UNNEST(). After further review of that, we might choose to adopt a different syntax for what this patch does, but in any case this functionality seems clearly worthwhile. Andrew Gierth, reviewed by Zoltán Böszörményi and Heikki Linnakangas, and significantly revised by me
2013-11-22 01:37:02 +01:00
COMPARE_NODE_FIELD(functions);
Add SQL Standard WITH ORDINALITY support for UNNEST (and any other SRF) Author: Andrew Gierth, David Fetter Reviewers: Dean Rasheed, Jeevan Chalke, Stephen Frost
2013-07-29 17:38:01 +02:00
COMPARE_SCALAR_FIELD(funcordinality);
Add support for multi-row VALUES clauses as part of INSERT statements (e.g. "INSERT ... VALUES (...), (...), ...") and elsewhere as allowed by the spec. (e.g. similar to a FROM clause subselect). initdb required. Joe Conway and Tom Lane.
2006-08-02 03:59:48 +02:00
COMPARE_NODE_FIELD(values_lists);
Fix handling of collations in multi-row VALUES constructs. Per spec we ought to apply select_common_collation() across the expressions in each column of the VALUES table. The original coding was just taking the first row and assuming it was representative. This patch adds a field to struct RangeTblEntry to carry the resolved collations, so initdb is forced for changes in stored rule representation.
2011-04-18 21:31:52 +02:00
COMPARE_NODE_FIELD(values_collations);
Implement SQL-standard WITH clauses, including WITH RECURSIVE. There are some unimplemented aspects: recursive queries must use UNION ALL (should allow UNION too), and we don't have SEARCH or CYCLE clauses. These might or might not get done for 8.4, but even without them it's a pretty useful feature. There are also a couple of small loose ends and definitional quibbles, which I'll send a memo about to pgsql-hackers shortly. But let's land the patch now so we can get on with other development. Yoshiyuki Asaba, with lots of help from Tatsuo Ishii and Tom Lane
2008-10-04 23:56:55 +02:00
COMPARE_STRING_FIELD(ctename);
COMPARE_SCALAR_FIELD(ctelevelsup);
COMPARE_SCALAR_FIELD(self_reference);
COMPARE_NODE_FIELD(ctecoltypes);
COMPARE_NODE_FIELD(ctecoltypmods);
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
COMPARE_NODE_FIELD(ctecolcollations);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_NODE_FIELD(alias);
COMPARE_NODE_FIELD(eref);
Implement SQL-standard LATERAL subqueries. This patch implements the standard syntax of LATERAL attached to a sub-SELECT in FROM, and also allows LATERAL attached to a function in FROM, since set-returning function calls are expected to be one of the principal use-cases. The main change here is a rewrite of the mechanism for keeping track of which relations are visible for column references while the FROM clause is being scanned. The parser "namespace" lists are no longer lists of bare RTEs, but are lists of ParseNamespaceItem structs, which carry an RTE pointer as well as some visibility-controlling flags. Aside from supporting LATERAL correctly, this lets us get rid of the ancient hacks that required rechecking subqueries and JOIN/ON and function-in-FROM expressions for invalid references after they were initially parsed. Invalid column references are now always correctly detected on sight. In passing, remove assorted parser error checks that are now dead code by virtue of our having gotten rid of add_missing_from, as well as some comments that are obsolete for the same reason. (It was mainly add_missing_from that caused so much fudging here in the first place.) The planner support for this feature is very minimal, and will be improved in future patches. It works well enough for testing purposes, though. catversion bump forced due to new field in RangeTblEntry.
2012-08-08 01:02:54 +02:00
COMPARE_SCALAR_FIELD(lateral);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(inh);
COMPARE_SCALAR_FIELD(inFromCl);
Fix permission-checking bug reported by Tim Burgess 10-Feb-03 (this time for sure...). Rather than relying on the query context of a rangetable entry to identify what permissions it wants checked, store a full AclMode mask in each RTE, and check exactly those bits. This allows an RTE specifying, say, INSERT privilege on a view to be copied into a derived UPDATE query without changing meaning. Per recent discussion thread. initdb forced due to change of stored rule representation.
2004-01-15 00:01:55 +01:00
COMPARE_SCALAR_FIELD(requiredPerms);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(checkAsUser);
Support column-level privileges, as required by SQL standard. Stephen Frost, with help from KaiGai Kohei and others
2009-01-22 21:16:10 +01:00
COMPARE_BITMAPSET_FIELD(selectedCols);
COMPARE_BITMAPSET_FIELD(modifiedCols);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Support multi-argument UNNEST(), and TABLE() syntax for multiple functions. This patch adds the ability to write TABLE( function1(), function2(), ...) as a single FROM-clause entry. The result is the concatenation of the first row from each function, followed by the second row from each function, etc; with NULLs inserted if any function produces fewer rows than others. This is believed to be a much more useful behavior than what Postgres currently does with multiple SRFs in a SELECT list. This syntax also provides a reasonable way to combine use of column definition lists with WITH ORDINALITY: put the column definition list inside TABLE(), where it's clear that it doesn't control the ordinality column as well. Also implement SQL-compliant multiple-argument UNNEST(), by turning UNNEST(a,b,c) into TABLE(unnest(a), unnest(b), unnest(c)). The SQL standard specifies TABLE() with only a single function, not multiple functions, and it seems to require an implicit UNNEST() which is not what this patch does. There may be something wrong with that reading of the spec, though, because if it's right then the spec's TABLE() is just a pointless alternative spelling of UNNEST(). After further review of that, we might choose to adopt a different syntax for what this patch does, but in any case this functionality seems clearly worthwhile. Andrew Gierth, reviewed by Zoltán Böszörményi and Heikki Linnakangas, and significantly revised by me
2013-11-22 01:37:02 +01:00
static bool
_equalRangeTblFunction(const RangeTblFunction *a, const RangeTblFunction *b)
{
COMPARE_NODE_FIELD(funcexpr);
COMPARE_SCALAR_FIELD(funccolcount);
COMPARE_NODE_FIELD(funccolnames);
COMPARE_NODE_FIELD(funccoltypes);
COMPARE_NODE_FIELD(funccoltypmods);
COMPARE_NODE_FIELD(funccolcollations);
COMPARE_BITMAPSET_FIELD(funcparams);
return true;
}
WITH CHECK OPTION support for auto-updatable VIEWs For simple views which are automatically updatable, this patch allows the user to specify what level of checking should be done on records being inserted or updated. For 'LOCAL CHECK', new tuples are validated against the conditionals of the view they are being inserted into, while for 'CASCADED CHECK' the new tuples are validated against the conditionals for all views involved (from the top down). This option is part of the SQL specification. Dean Rasheed, reviewed by Pavel Stehule
2013-07-18 23:10:16 +02:00
static bool
_equalWithCheckOption(const WithCheckOption *a, const WithCheckOption *b)
{
COMPARE_STRING_FIELD(viewname);
COMPARE_NODE_FIELD(qual);
COMPARE_SCALAR_FIELD(cascaded);
return true;
}
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalSortGroupClause(const SortGroupClause *a, const SortGroupClause *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(tleSortGroupRef);
Rearrange the querytree representation of ORDER BY/GROUP BY/DISTINCT items as per my recent proposal: 1. Fold SortClause and GroupClause into a single node type SortGroupClause. We were already relying on them to be struct-equivalent, so using two node tags wasn't accomplishing much except to get in the way of comparing items with equal(). 2. Add an "eqop" field to SortGroupClause to carry the associated equality operator. This is cheap for the parser to get at the same time it's looking up the sort operator, and storing it eliminates the need for repeated not-so-cheap lookups during planning. In future this will also let us represent GROUP/DISTINCT operations on datatypes that have hash opclasses but no btree opclasses (ie, they have equality but no natural sort order). The previous representation simply didn't work for that, since its only indicator of comparison semantics was a sort operator. 3. Add a hasDistinctOn boolean to struct Query to explicitly record whether the distinctClause came from DISTINCT or DISTINCT ON. This allows removing some complicated and not 100% bulletproof code that attempted to figure that out from the distinctClause alone. This patch doesn't in itself create any new capability, but it's necessary infrastructure for future attempts to use hash-based grouping for DISTINCT and UNION/INTERSECT/EXCEPT.
2008-08-02 23:32:01 +02:00
COMPARE_SCALAR_FIELD(eqop);
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(sortop);
Support ORDER BY ... NULLS FIRST/LAST, and add ASC/DESC/NULLS FIRST/NULLS LAST per-column options for btree indexes. The planner's support for this is still pretty rudimentary; it does not yet know how to plan mergejoins with nondefault ordering options. The documentation is pretty rudimentary, too. I'll work on improving that stuff later. Note incompatible change from prior behavior: ORDER BY ... USING will now be rejected if the operator is not a less-than or greater-than member of some btree opclass. This prevents less-than-sane behavior if an operator that doesn't actually define a proper sort ordering is selected.
2007-01-09 03:14:16 +01:00
COMPARE_SCALAR_FIELD(nulls_first);
Provide hashing support for arrays. The core of this patch is hash_array() and associated typcache infrastructure, which works just about exactly like the existing support for array comparison. In addition I did some work to ensure that the planner won't think that an array type is hashable unless its element type is hashable, and similarly for sorting. This includes adding a datatype parameter to op_hashjoinable and op_mergejoinable, and adding an explicit "hashable" flag to SortGroupClause. The lack of a cross-check on the element type was a pre-existing bug in mergejoin support --- but it didn't matter so much before, because if you couldn't sort the element type there wasn't any good alternative to failing anyhow. Now that we have the alternative of hashing the array type, there are cases where we can avoid a failure by being picky at the planner stage, so it's time to be picky. The issue of exactly how to combine the per-element hash values to produce an array hash is still open for discussion, but the rest of this is pretty solid, so I'll commit it as-is.
2010-10-31 02:55:20 +01:00
COMPARE_SCALAR_FIELD(hashable);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
return true;
}
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalWindowClause(const WindowClause *a, const WindowClause *b)
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
{
COMPARE_STRING_FIELD(name);
COMPARE_STRING_FIELD(refname);
COMPARE_NODE_FIELD(partitionClause);
COMPARE_NODE_FIELD(orderClause);
Add some basic support for window frame clauses to the window-functions patch. This includes the ability to force the frame to cover the whole partition, and the ability to make the frame end exactly on the current row rather than its last ORDER BY peer. Supporting any more of the full SQL frame-clause syntax will require nontrivial hacking on the window aggregate code, so it'll have to wait for 8.5 or beyond.
2008-12-31 01:08:39 +01:00
COMPARE_SCALAR_FIELD(frameOptions);
Extend the set of frame options supported for window functions. This patch allows the frame to start from CURRENT ROW (in either RANGE or ROWS mode), and it also adds support for ROWS n PRECEDING and ROWS n FOLLOWING start and end points. (RANGE value PRECEDING/FOLLOWING isn't there yet --- the grammar works, but that's all.) Hitoshi Harada, reviewed by Pavel Stehule
2010-02-12 18:33:21 +01:00
COMPARE_NODE_FIELD(startOffset);
COMPARE_NODE_FIELD(endOffset);
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
COMPARE_SCALAR_FIELD(winref);
COMPARE_SCALAR_FIELD(copiedOrder);
return true;
}
Improve the representation of FOR UPDATE/FOR SHARE so that we can support both FOR UPDATE and FOR SHARE in one command, as well as both NOWAIT and normal WAIT behavior. The more general code is actually simpler and cleaner.
2006-04-30 20:30:40 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalRowMarkClause(const RowMarkClause *a, const RowMarkClause *b)
Improve the representation of FOR UPDATE/FOR SHARE so that we can support both FOR UPDATE and FOR SHARE in one command, as well as both NOWAIT and normal WAIT behavior. The more general code is actually simpler and cleaner.
2006-04-30 20:30:40 +02:00
{
COMPARE_SCALAR_FIELD(rti);
Improve concurrency of foreign key locking This patch introduces two additional lock modes for tuples: "SELECT FOR KEY SHARE" and "SELECT FOR NO KEY UPDATE". These don't block each other, in contrast with already existing "SELECT FOR SHARE" and "SELECT FOR UPDATE". UPDATE commands that do not modify the values stored in the columns that are part of the key of the tuple now grab a SELECT FOR NO KEY UPDATE lock on the tuple, allowing them to proceed concurrently with tuple locks of the FOR KEY SHARE variety. Foreign key triggers now use FOR KEY SHARE instead of FOR SHARE; this means the concurrency improvement applies to them, which is the whole point of this patch. The added tuple lock semantics require some rejiggering of the multixact module, so that the locking level that each transaction is holding can be stored alongside its Xid. Also, multixacts now need to persist across server restarts and crashes, because they can now represent not only tuple locks, but also tuple updates. This means we need more careful tracking of lifetime of pg_multixact SLRU files; since they now persist longer, we require more infrastructure to figure out when they can be removed. pg_upgrade also needs to be careful to copy pg_multixact files over from the old server to the new, or at least part of multixact.c state, depending on the versions of the old and new servers. Tuple time qualification rules (HeapTupleSatisfies routines) need to be careful not to consider tuples with the "is multi" infomask bit set as being only locked; they might need to look up MultiXact values (i.e. possibly do pg_multixact I/O) to find out the Xid that updated a tuple, whereas they previously were assured to only use information readily available from the tuple header. This is considered acceptable, because the extra I/O would involve cases that would previously cause some commands to block waiting for concurrent transactions to finish. Another important change is the fact that locking tuples that have previously been updated causes the future versions to be marked as locked, too; this is essential for correctness of foreign key checks. This causes additional WAL-logging, also (there was previously a single WAL record for a locked tuple; now there are as many as updated copies of the tuple there exist.) With all this in place, contention related to tuples being checked by foreign key rules should be much reduced. As a bonus, the old behavior that a subtransaction grabbing a stronger tuple lock than the parent (sub)transaction held on a given tuple and later aborting caused the weaker lock to be lost, has been fixed. Many new spec files were added for isolation tester framework, to ensure overall behavior is sane. There's probably room for several more tests. There were several reviewers of this patch; in particular, Noah Misch and Andres Freund spent considerable time in it. Original idea for the patch came from Simon Riggs, after a problem report by Joel Jacobson. Most code is from me, with contributions from Marti Raudsepp, Alexander Shulgin, Noah Misch and Andres Freund. This patch was discussed in several pgsql-hackers threads; the most important start at the following message-ids: AANLkTimo9XVcEzfiBR-ut3KVNDkjm2Vxh+t8kAmWjPuv@mail.gmail.com 1290721684-sup-3951@alvh.no-ip.org 1294953201-sup-2099@alvh.no-ip.org 1320343602-sup-2290@alvh.no-ip.org 1339690386-sup-8927@alvh.no-ip.org 4FE5FF020200002500048A3D@gw.wicourts.gov 4FEAB90A0200002500048B7D@gw.wicourts.gov
2013-01-23 16:04:59 +01:00
COMPARE_SCALAR_FIELD(strength);
Improve the representation of FOR UPDATE/FOR SHARE so that we can support both FOR UPDATE and FOR SHARE in one command, as well as both NOWAIT and normal WAIT behavior. The more general code is actually simpler and cleaner.
2006-04-30 20:30:40 +02:00
COMPARE_SCALAR_FIELD(noWait);
When FOR UPDATE/SHARE is used with LIMIT, put the LockRows plan node underneath the Limit node, not atop it. This fixes the old problem that such a query might unexpectedly return fewer rows than the LIMIT says, due to LockRows discarding updated rows. There is a related problem that LockRows might destroy the sort ordering produced by earlier steps; but fixing that by pushing LockRows below Sort would create serious performance problems that are unjustified in many real-world applications, as well as potential deadlock problems from locking many more rows than expected. Instead, keep the present semantics of applying FOR UPDATE after ORDER BY within a single query level; but allow the user to specify the other way by writing FOR UPDATE in a sub-select. To make that work, track whether FOR UPDATE appeared explicitly in sub-selects or got pushed down from the parent, and don't flatten a sub-select that contained an explicit FOR UPDATE.
2009-10-28 15:55:47 +01:00
COMPARE_SCALAR_FIELD(pushedDown);
Improve the representation of FOR UPDATE/FOR SHARE so that we can support both FOR UPDATE and FOR SHARE in one command, as well as both NOWAIT and normal WAIT behavior. The more general code is actually simpler and cleaner.
2006-04-30 20:30:40 +02:00
return true;
}
Implement SQL-standard WITH clauses, including WITH RECURSIVE. There are some unimplemented aspects: recursive queries must use UNION ALL (should allow UNION too), and we don't have SEARCH or CYCLE clauses. These might or might not get done for 8.4, but even without them it's a pretty useful feature. There are also a couple of small loose ends and definitional quibbles, which I'll send a memo about to pgsql-hackers shortly. But let's land the patch now so we can get on with other development. Yoshiyuki Asaba, with lots of help from Tatsuo Ishii and Tom Lane
2008-10-04 23:56:55 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalWithClause(const WithClause *a, const WithClause *b)
Implement SQL-standard WITH clauses, including WITH RECURSIVE. There are some unimplemented aspects: recursive queries must use UNION ALL (should allow UNION too), and we don't have SEARCH or CYCLE clauses. These might or might not get done for 8.4, but even without them it's a pretty useful feature. There are also a couple of small loose ends and definitional quibbles, which I'll send a memo about to pgsql-hackers shortly. But let's land the patch now so we can get on with other development. Yoshiyuki Asaba, with lots of help from Tatsuo Ishii and Tom Lane
2008-10-04 23:56:55 +02:00
{
COMPARE_NODE_FIELD(ctes);
COMPARE_SCALAR_FIELD(recursive);
COMPARE_LOCATION_FIELD(location);
return true;
}
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b)
Implement SQL-standard WITH clauses, including WITH RECURSIVE. There are some unimplemented aspects: recursive queries must use UNION ALL (should allow UNION too), and we don't have SEARCH or CYCLE clauses. These might or might not get done for 8.4, but even without them it's a pretty useful feature. There are also a couple of small loose ends and definitional quibbles, which I'll send a memo about to pgsql-hackers shortly. But let's land the patch now so we can get on with other development. Yoshiyuki Asaba, with lots of help from Tatsuo Ishii and Tom Lane
2008-10-04 23:56:55 +02:00
{
COMPARE_STRING_FIELD(ctename);
COMPARE_NODE_FIELD(aliascolnames);
COMPARE_NODE_FIELD(ctequery);
COMPARE_LOCATION_FIELD(location);
COMPARE_SCALAR_FIELD(cterecursive);
COMPARE_SCALAR_FIELD(cterefcount);
COMPARE_NODE_FIELD(ctecolnames);
COMPARE_NODE_FIELD(ctecoltypes);
COMPARE_NODE_FIELD(ctecoltypmods);
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
COMPARE_NODE_FIELD(ctecolcollations);
Implement SQL-standard WITH clauses, including WITH RECURSIVE. There are some unimplemented aspects: recursive queries must use UNION ALL (should allow UNION too), and we don't have SEARCH or CYCLE clauses. These might or might not get done for 8.4, but even without them it's a pretty useful feature. There are also a couple of small loose ends and definitional quibbles, which I'll send a memo about to pgsql-hackers shortly. But let's land the patch now so we can get on with other development. Yoshiyuki Asaba, with lots of help from Tatsuo Ishii and Tom Lane
2008-10-04 23:56:55 +02:00
return true;
}
Implement XMLSERIALIZE for real. Analogously, make the xml to text cast observe the xmloption. Reorganize the representation of the XML option in the parse tree and the API to make it easier to manage and understand. Add regression tests for parsing back XML expressions.
2007-02-03 15:06:56 +01:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalXmlSerialize(const XmlSerialize *a, const XmlSerialize *b)
Implement XMLSERIALIZE for real. Analogously, make the xml to text cast observe the xmloption. Reorganize the representation of the XML option in the parse tree and the API to make it easier to manage and understand. Add regression tests for parsing back XML expressions.
2007-02-03 15:06:56 +01:00
{
COMPARE_SCALAR_FIELD(xmloption);
COMPARE_NODE_FIELD(expr);
Make backend header files C++ safe This alters various incidental uses of C++ key words to use other similar identifiers, so that a C++ compiler won't choke outright. You still (probably) need extern "C" { }; around the inclusion of backend headers. based on a patch by Kurt Harriman <harriman@acm.org> Also add a script cpluspluscheck to check for C++ compatibility in the future. As of right now, this passes without error for me.
2009-07-16 08:33:46 +02:00
COMPARE_NODE_FIELD(typeName);
Extend the parser location infrastructure to include a location field in most node types used in expression trees (both before and after parse analysis). This allows us to place an error cursor in many situations where we formerly could not, because the information wasn't available beyond the very first level of parse analysis. There's a fair amount of work still to be done to persuade individual ereport() calls to actually include an error location, but this gets the initdb-forcing part of the work out of the way; and the situation is already markedly better than before for complaints about unimplementable implicit casts, such as CASE and UNION constructs with incompatible alternative data types. Per my proposal of a few days ago.
2008-08-29 01:09:48 +02:00
COMPARE_LOCATION_FIELD(location);
Implement XMLSERIALIZE for real. Analogously, make the xml to text cast observe the xmloption. Reorganize the representation of the XML option in the parse tree and the API to make it easier to manage and understand. Add regression tests for parsing back XML expressions.
2007-02-03 15:06:56 +01:00
return true;
}
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
/*
* Stuff from pg_list.h
*/
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
Reimplement the linked list data structure used throughout the backend. In the past, we used a 'Lispy' linked list implementation: a "list" was merely a pointer to the head node of the list. The problem with that design is that it makes lappend() and length() linear time. This patch fixes that problem (and others) by maintaining a count of the list length and a pointer to the tail node along with each head node pointer. A "list" is now a pointer to a structure containing some meta-data about the list; the head and tail pointers in that structure refer to ListCell structures that maintain the actual linked list of nodes. The function names of the list API have also been changed to, I hope, be more logically consistent. By default, the old function names are still available; they will be disabled-by-default once the rest of the tree has been updated to use the new API names.
2004-05-26 06:41:50 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalList(const List *a, const List *b)
Reimplement the linked list data structure used throughout the backend. In the past, we used a 'Lispy' linked list implementation: a "list" was merely a pointer to the head node of the list. The problem with that design is that it makes lappend() and length() linear time. This patch fixes that problem (and others) by maintaining a count of the list length and a pointer to the tail node along with each head node pointer. A "list" is now a pointer to a structure containing some meta-data about the list; the head and tail pointers in that structure refer to ListCell structures that maintain the actual linked list of nodes. The function names of the list API have also been changed to, I hope, be more logically consistent. By default, the old function names are still available; they will be disabled-by-default once the rest of the tree has been updated to use the new API names.
2004-05-26 06:41:50 +02:00
{
Run pgindent on 9.2 source tree in preparation for first 9.3 commit-fest.
2012-06-10 21:20:04 +02:00
const ListCell *item_a;
const ListCell *item_b;
Reimplement the linked list data structure used throughout the backend. In the past, we used a 'Lispy' linked list implementation: a "list" was merely a pointer to the head node of the list. The problem with that design is that it makes lappend() and length() linear time. This patch fixes that problem (and others) by maintaining a count of the list length and a pointer to the tail node along with each head node pointer. A "list" is now a pointer to a structure containing some meta-data about the list; the head and tail pointers in that structure refer to ListCell structures that maintain the actual linked list of nodes. The function names of the list API have also been changed to, I hope, be more logically consistent. By default, the old function names are still available; they will be disabled-by-default once the rest of the tree has been updated to use the new API names.
2004-05-26 06:41:50 +02:00
/*
Standard pgindent run for 8.1.
2005-10-15 04:49:52 +02:00
* Try to reject by simple scalar checks before grovelling through all the
* list elements...
Reimplement the linked list data structure used throughout the backend. In the past, we used a 'Lispy' linked list implementation: a "list" was merely a pointer to the head node of the list. The problem with that design is that it makes lappend() and length() linear time. This patch fixes that problem (and others) by maintaining a count of the list length and a pointer to the tail node along with each head node pointer. A "list" is now a pointer to a structure containing some meta-data about the list; the head and tail pointers in that structure refer to ListCell structures that maintain the actual linked list of nodes. The function names of the list API have also been changed to, I hope, be more logically consistent. By default, the old function names are still available; they will be disabled-by-default once the rest of the tree has been updated to use the new API names.
2004-05-26 06:41:50 +02:00
*/
COMPARE_SCALAR_FIELD(type);
COMPARE_SCALAR_FIELD(length);
/*
Standard pgindent run for 8.1.
2005-10-15 04:49:52 +02:00
* We place the switch outside the loop for the sake of efficiency; this
* may not be worth doing...
Reimplement the linked list data structure used throughout the backend. In the past, we used a 'Lispy' linked list implementation: a "list" was merely a pointer to the head node of the list. The problem with that design is that it makes lappend() and length() linear time. This patch fixes that problem (and others) by maintaining a count of the list length and a pointer to the tail node along with each head node pointer. A "list" is now a pointer to a structure containing some meta-data about the list; the head and tail pointers in that structure refer to ListCell structures that maintain the actual linked list of nodes. The function names of the list API have also been changed to, I hope, be more logically consistent. By default, the old function names are still available; they will be disabled-by-default once the rest of the tree has been updated to use the new API names.
2004-05-26 06:41:50 +02:00
*/
switch (a->type)
{
case T_List:
forboth(item_a, a, item_b, b)
{
if (!equal(lfirst(item_a), lfirst(item_b)))
return false;
}
break;
case T_IntList:
forboth(item_a, a, item_b, b)
{
if (lfirst_int(item_a) != lfirst_int(item_b))
return false;
}
break;
case T_OidList:
forboth(item_a, a, item_b, b)
{
if (lfirst_oid(item_a) != lfirst_oid(item_b))
return false;
}
break;
default:
elog(ERROR, "unrecognized list node type: %d",
(int) a->type);
return false; /* keep compiler quiet */
}
/*
* If we got here, we should have run out of elements of both lists
*/
Assert(item_a == NULL);
Assert(item_b == NULL);
return true;
}
/*
* Stuff from value.h
*/
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
static bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
_equalValue(const Value *a, const Value *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(type);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
switch (a->type)
{
case T_Integer:
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_SCALAR_FIELD(val.ival);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_Float:
case T_String:
Change the parser to convert SQL "position" and "substring" syntax to position() and substring() functions, so that it works transparently for bit types as well. Alias the text functions appropriately. Add position() for bit types. Add new constant node T_BitString that represents literals of the form B'1001 and pass those to zpbit type.
2000-10-31 11:22:13 +01:00
case T_BitString:
Restructure the code in copyfuncs and equalfuncs to put much heavier reliance on macros, in hopes of eliminating silly typos (like copying to the wrong field) and just generally making it easier to see the forest instead of the trees. As an example, here is the new code for A_Indices: static A_Indices * _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); COPY_NODE_FIELD(lidx); COPY_NODE_FIELD(uidx); return newnode; } static bool _equalAIndices(A_Indices *a, A_Indices *b) { COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); return true; } I plan to redo outfuncs/readfuncs in a similar style, but am committing what I've got.
2002-11-25 04:33:27 +01:00
COMPARE_STRING_FIELD(val.str);
break;
Add missing copyfuncs/equalfuncs entries, including T_Null which has been missing forever; surprising it wasn't noticed before. The other additions are, um, sloppiness in certain recent feature additions.
2002-08-19 02:11:53 +02:00
case T_Null:
/* nothing to do */
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
default:
Error message editing in backend/bootstrap, /lib, /nodes, /port.
2003-07-23 01:30:39 +02:00
elog(ERROR, "unrecognized node type: %d", (int) a->type);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
break;
}
return true;
}
/*
* equal
* returns whether two nodes are equal
*/
bool
Add const qualifiers to node inspection functions Thomas Munro
2011-12-07 20:46:56 +01:00
equal(const void *a, const void *b)
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
{
Error message editing in backend/bootstrap, /lib, /nodes, /port.
2003-07-23 01:30:39 +02:00
bool retval;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
if (a == b)
return true;
/*
* note that a!=b, so only one of them can be NULL
*/
if (a == NULL || b == NULL)
return false;
/*
* are they the same type of nodes?
*/
if (nodeTag(a) != nodeTag(b))
return false;
switch (nodeTag(a))
{
pgindent run.
2003-08-04 02:43:34 +02:00
/*
* PRIMITIVE NODES
*/
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
case T_Alias:
retval = _equalAlias(a, b);
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
break;
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
case T_RangeVar:
retval = _equalRangeVar(a, b);
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
break;
Remove the Query structure from the executor's API. This allows us to stop storing mostly-redundant Query trees in prepared statements, portals, etc. To replace Query, a new node type called PlannedStmt is inserted by the planner at the top of a completed plan tree; this carries just the fields of Query that are still needed at runtime. The statement lists kept in portals etc. now consist of intermixed PlannedStmt and bare utility-statement nodes --- no Query. This incidentally allows us to remove some fields from Query and Plan nodes that shouldn't have been there in the first place. Still to do: simplify the execution-time range table; at the moment the range table passed to the executor still contains Query trees for subqueries. initdb forced due to change of stored rules.
2007-02-20 18:32:18 +01:00
case T_IntoClause:
retval = _equalIntoClause(a, b);
break;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
case T_Var:
retval = _equalVar(a, b);
break;
case T_Const:
retval = _equalConst(a, b);
break;
case T_Param:
retval = _equalParam(a, b);
break;
equal() needs a case for Aggref nodes, as shown by: regression=> select sum(q1) from int8_tbl group by q2 order by sum(q1); NOTICE: equal: don't know whether nodes of type 107 are equal
1999-06-06 19:46:40 +02:00
case T_Aggref:
retval = _equalAggref(a, b);
Implement constant-expression simplification per Bernard Frankpitt, plus some improvements from yours truly. The simplifier depends on the proiscachable field of pg_proc to tell it whether a function is safe to pre-evaluate --- things like nextval() are not, for example. Update pg_proc.h to contain reasonable cacheability information; as of 6.5.* hardly any functions were marked cacheable. I may have erred too far in the other direction; see recent mail to pghackers for more info. This update does not force an initdb, exactly, but you won't see much benefit from the simplifier until you do one.
1999-09-26 04:28:44 +02:00
break;
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
case T_WindowFunc:
retval = _equalWindowFunc(a, b);
break;
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
case T_ArrayRef:
retval = _equalArrayRef(a, b);
break;
case T_FuncExpr:
retval = _equalFuncExpr(a, b);
break;
Support use of function argument names to identify which actual arguments match which function parameters. The syntax uses AS, for example funcname(value AS arg1, anothervalue AS arg2) Pavel Stehule
2009-10-08 04:39:25 +02:00
case T_NamedArgExpr:
retval = _equalNamedArgExpr(a, b);
break;
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
case T_OpExpr:
retval = _equalOpExpr(a, b);
break;
case T_DistinctExpr:
retval = _equalDistinctExpr(a, b);
break;
Revise collation derivation method and expression-tree representation. All expression nodes now have an explicit output-collation field, unless they are known to only return a noncollatable data type (such as boolean or record). Also, nodes that can invoke collation-aware functions store a separate field that is the collation value to pass to the function. This avoids confusion that arises when a function has collatable inputs and noncollatable output type, or vice versa. Also, replace the parser's on-the-fly collation assignment method with a post-pass over the completed expression tree. This allows us to use a more complex (and hopefully more nearly spec-compliant) assignment rule without paying for it in extra storage in every expression node. Fix assorted bugs in the planner's handling of collations by making collation one of the defining properties of an EquivalenceClass and by converting CollateExprs into discardable RelabelType nodes during expression preprocessing.
2011-03-20 01:29:08 +01:00
case T_NullIfExpr:
retval = _equalNullIfExpr(a, b);
break;
Support expressions of the form 'scalar op ANY (array)' and 'scalar op ALL (array)', where the operator is applied between the lefthand scalar and each element of the array. The operator must yield boolean; the result of the construct is the OR or AND of the per-element results, respectively. Original coding by Joe Conway, after an idea of Peter's. Rewritten by Tom to keep the implementation strictly separate from subqueries.
2003-06-29 02:33:44 +02:00
case T_ScalarArrayOpExpr:
retval = _equalScalarArrayOpExpr(a, b);
break;
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
case T_BoolExpr:
retval = _equalBoolExpr(a, b);
break;
Implement constant-expression simplification per Bernard Frankpitt, plus some improvements from yours truly. The simplifier depends on the proiscachable field of pg_proc to tell it whether a function is safe to pre-evaluate --- things like nextval() are not, for example. Update pg_proc.h to contain reasonable cacheability information; as of 6.5.* hardly any functions were marked cacheable. I may have erred too far in the other direction; see recent mail to pghackers for more info. This update does not force an initdb, exactly, but you won't see much benefit from the simplifier until you do one.
1999-09-26 04:28:44 +02:00
case T_SubLink:
retval = _equalSubLink(a, b);
equal() needs a case for Aggref nodes, as shown by: regression=> select sum(q1) from int8_tbl group by q2 order by sum(q1); NOTICE: equal: don't know whether nodes of type 107 are equal
1999-06-06 19:46:40 +02:00
break;
Clean up plantree representation of SubPlan-s --- SubLink does not appear in the planned representation of a subplan at all any more, only SubPlan. This means subselect.c doesn't scribble on its input anymore, which seems like a good thing; and there are no longer three different possible interpretations of a SubLink. Simplify node naming and improve comments in primnodes.h. No change to stored rules, though.
2002-12-14 01:17:59 +01:00
case T_SubPlan:
retval = _equalSubPlan(a, b);
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
break;
Arrange to convert EXISTS subqueries that are equivalent to hashable IN subqueries into the same thing you'd have gotten from IN (except always with unknownEqFalse = true, so as to get the proper semantics for an EXISTS). I believe this fixes the last case within CVS HEAD in which an EXISTS could give worse performance than an equivalent IN subquery. The tricky part of this is that if the upper query probes the EXISTS for only a few rows, the hashing implementation can actually be worse than the default, and therefore we need to make a cost-based decision about which way to use. But at the time when the planner generates plans for subqueries, it doesn't really know how many times the subquery will be executed. The least invasive solution seems to be to generate both plans and postpone the choice until execution. Therefore, in a query that has been optimized this way, EXPLAIN will show two subplans for the EXISTS, of which only one will actually get executed. There is a lot more that could be done based on this infrastructure: in particular it's interesting to consider switching to the hash plan if we start out using the non-hashed plan but find a lot more upper rows going by than we expected. I have therefore left some minor inefficiencies in place, such as initializing both subplans even though we will currently only use one.
2008-08-22 02:16:04 +02:00
case T_AlternativeSubPlan:
retval = _equalAlternativeSubPlan(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_FieldSelect:
retval = _equalFieldSelect(a, b);
break;
Support assignment to subfields of composite columns in UPDATE and INSERT. As a side effect, cause subscripts in INSERT targetlists to do something more or less sensible; previously we evaluated such subscripts and then effectively ignored them. Another side effect is that UPDATE-ing an element or slice of an array value that is NULL now produces a non-null result, namely an array containing just the assigned-to positions.
2004-06-09 21:08:20 +02:00
case T_FieldStore:
retval = _equalFieldStore(a, b);
break;
Add test code to copy all parse/plan trees. Repair essential omissions in copyfuncs and equalfuncs exposed by regression tests. We still have some work to do: these modules really ought to handle most or all of the utility statement node types. But it's better than it was.
2000-06-29 09:35:57 +02:00
case T_RelabelType:
retval = _equalRelabelType(a, b);
break;
Downgrade implicit casts to text to be assignment-only, except for the ones from the other string-category types; this eliminates a lot of surprising interpretations that the parser could formerly make when there was no directly applicable operator. Create a general mechanism that supports casts to and from the standard string types (text,varchar,bpchar) for *every* datatype, by invoking the datatype's I/O functions. These new casts are assignment-only in the to-string direction, explicit-only in the other, and therefore should create no surprising behavior. Remove a bunch of thereby-obsoleted datatype-specific casting functions. The "general mechanism" is a new expression node type CoerceViaIO that can actually convert between *any* two datatypes if their external text representations are compatible. This is more general than needed for the immediate feature, but might be useful in plpgsql or other places in future. This commit does nothing about the issue that applying the concatenation operator || to non-text types will now fail, often with strange error messages due to misinterpreting the operator as array concatenation. Since it often (not always) worked before, we should either make it succeed or at least give a more user-friendly error; but details are still under debate. Peter Eisentraut and Tom Lane
2007-06-05 23:31:09 +02:00
case T_CoerceViaIO:
retval = _equalCoerceViaIO(a, b);
break;
Fix array coercion expressions to ensure that the correct volatility is seen by code inspecting the expression. The best way to do this seems to be to drop the original representation as a function invocation, and instead make a special expression node type that represents applying the element-type coercion function to each array element. In this way the element function is exposed and will be checked for volatility. Per report from Guillaume Smet.
2007-03-28 01:21:12 +02:00
case T_ArrayCoerceExpr:
retval = _equalArrayCoerceExpr(a, b);
break;
Instead of supposing (wrongly, in the general case) that the rowtype of an inheritance child table is binary-compatible with the rowtype of its parent, invent an expression node type that does the conversion correctly. Fixes the new bug exhibited by Kris Shannon as well as a lot of old bugs that would only show up when using multiple inheritance or after altering the parent table.
2004-12-12 00:26:51 +01:00
case T_ConvertRowtypeExpr:
retval = _equalConvertRowtypeExpr(a, b);
break;
Split CollateClause into separate raw and analyzed node types. CollateClause is now used only in raw grammar output, and CollateExpr after parse analysis. This is for clarity and to avoid carrying collation names in post-analysis parse trees: that's both wasteful and possibly misleading, since the collation's name could be changed while the parsetree still exists. Also, clean up assorted infelicities and omissions in processing of the node type.
2011-03-11 22:27:51 +01:00
case T_CollateExpr:
retval = _equalCollateExpr(a, b);
break;
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
case T_CaseExpr:
retval = _equalCaseExpr(a, b);
break;
case T_CaseWhen:
retval = _equalCaseWhen(a, b);
break;
Reimplement CASE val WHEN compval1 THEN ... WHEN compval2 THEN ... END so that the 'val' is computed only once, per recent discussion. The speedup is not much when 'val' is just a simple variable, but could be significant for larger expressions. More importantly this avoids issues with multiple evaluations of a volatile 'val', and it allows the CASE expression to be reverse-listed in its original form by ruleutils.c.
2004-03-17 21:48:43 +01:00
case T_CaseTestExpr:
retval = _equalCaseTestExpr(a, b);
break;
First phase of work on array improvements. ARRAY[x,y,z] constructor expressions, ARRAY(sub-SELECT) expressions, some array functions. Polymorphic functions using ANYARRAY/ANYELEMENT argument and return types. Some regression tests in place, documentation is lacking. Joe Conway, with some kibitzing from Tom Lane.
2003-04-09 01:20:04 +02:00
case T_ArrayExpr:
retval = _equalArrayExpr(a, b);
break;
Promote row expressions to full-fledged citizens of the expression syntax, rather than allowing them only in a few special cases as before. In particular you can now pass a ROW() construct to a function that accepts a rowtype parameter. Internal generation of RowExprs fixes a number of corner cases that used to not work very well, such as referencing the whole-row result of a JOIN or subquery. This represents a further step in the work I started a month or so back to make rowtype values into first-class citizens.
2004-05-11 00:44:49 +02:00
case T_RowExpr:
retval = _equalRowExpr(a, b);
break;
Implement SQL-compliant treatment of row comparisons for < <= > >= cases (previously we only did = and <> correctly). Also, allow row comparisons with any operators that are in btree opclasses, not only those with these specific names. This gets rid of a whole lot of indefensible assumptions about the behavior of particular operators based on their names ... though it's still true that IN and NOT IN expand to "= ANY". The patch adds a RowCompareExpr expression node type, and makes some changes in the representation of ANY/ALL/ROWCOMPARE SubLinks so that they can share code with RowCompareExpr. I have not yet done anything about making RowCompareExpr an indexable operator, but will look at that soon. initdb forced due to changes in stored rules.
2005-12-28 02:30:02 +01:00
case T_RowCompareExpr:
retval = _equalRowCompareExpr(a, b);
break;
COALESCE() and NULLIF() are now first-class expressions, not macros that turn into CASE expressions. They evaluate their arguments at most once. Patch by Kris Jurka, review and (very light) editorializing by me.
2003-02-16 03:30:39 +01:00
case T_CoalesceExpr:
retval = _equalCoalesceExpr(a, b);
break;
Add Oracle-compatible GREATEST and LEAST functions. Pavel Stehule
2005-06-27 00:05:42 +02:00
case T_MinMaxExpr:
retval = _equalMinMaxExpr(a, b);
break;
Code review for XML patch. Instill a bit of sanity in the location of the XmlExpr code in various lists, use a representation that has some hope of reverse-listing correctly (though it's still a de-escaping function shy of correctness), generally try to make it look more like Postgres coding conventions.
2006-12-24 01:29:20 +01:00
case T_XmlExpr:
retval = _equalXmlExpr(a, b);
break;
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
case T_NullTest:
retval = _equalNullTest(a, b);
break;
case T_BooleanTest:
retval = _equalBooleanTest(a, b);
break;
Determine the set of constraints applied to a domain at executor startup, not in the parser; this allows ALTER DOMAIN to work correctly with domain constraint operations stored in rules. Rod Taylor; code review by Tom Lane.
2003-02-03 22:15:45 +01:00
case T_CoerceToDomain:
retval = _equalCoerceToDomain(a, b);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
break;
Determine the set of constraints applied to a domain at executor startup, not in the parser; this allows ALTER DOMAIN to work correctly with domain constraint operations stored in rules. Rod Taylor; code review by Tom Lane.
2003-02-03 22:15:45 +01:00
case T_CoerceToDomainValue:
retval = _equalCoerceToDomainValue(a, b);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
break;
Code review for UPDATE tab SET col = DEFAULT patch ... whack it around so it has some chance of working in rules ...
2003-07-03 18:34:26 +02:00
case T_SetToDefault:
retval = _equalSetToDefault(a, b);
break;
Support UPDATE/DELETE WHERE CURRENT OF cursor_name, per SQL standard. Along the way, allow FOR UPDATE in non-WITH-HOLD cursors; there may once have been a reason to disallow that, but it seems to work now, and it's really rather necessary if you want to select a row via a cursor and then update it in a concurrent-safe fashion. Original patch by Arul Shaji, rather heavily editorialized by Tom Lane.
2007-06-11 03:16:30 +02:00
case T_CurrentOfExpr:
retval = _equalCurrentOfExpr(a, b);
break;
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
case T_TargetEntry:
retval = _equalTargetEntry(a, b);
break;
First cut at full support for OUTER JOINs. There are still a few loose ends to clean up (see my message of same date to pghackers), but mostly it works. INITDB REQUIRED!
2000-09-12 23:07:18 +02:00
case T_RangeTblRef:
retval = _equalRangeTblRef(a, b);
break;
Subselects in FROM clause, per ISO syntax: FROM (SELECT ...) [AS] alias. (Don't forget that an alias is required.) Views reimplemented as expanding to subselect-in-FROM. Grouping, aggregates, DISTINCT in views actually work now (he says optimistically). No UNION support in subselects/views yet, but I have some ideas about that. Rule-related permissions checking moved out of rewriter and into executor. INITDB REQUIRED!
2000-09-29 20:21:41 +02:00
case T_FromExpr:
retval = _equalFromExpr(a, b);
break;
First cut at full support for OUTER JOINs. There are still a few loose ends to clean up (see my message of same date to pghackers), but mostly it works. INITDB REQUIRED!
2000-09-12 23:07:18 +02:00
case T_JoinExpr:
retval = _equalJoinExpr(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
/*
* RELATION NODES
*/
Refactor planner's pathkeys data structure to create a separate, explicit representation of equivalence classes of variables. This is an extensive rewrite, but it brings a number of benefits: * planner no longer fails in the presence of "incomplete" operator families that don't offer operators for every possible combination of datatypes. * avoid generating and then discarding redundant equality clauses. * remove bogus assumption that derived equalities always use operators named "=". * mergejoins can work with a variety of sort orders (e.g., descending) now, instead of tying each mergejoinable operator to exactly one sort order. * better recognition of redundant sort columns. * can make use of equalities appearing underneath an outer join.
2007-01-20 21:45:41 +01:00
case T_PathKey:
retval = _equalPathKey(a, b);
Tid access method feature from Hiroshi Inoue, Inoue@tpf.co.jp
1999-11-23 21:07:06 +01:00
break;
Add test code to copy all parse/plan trees. Repair essential omissions in copyfuncs and equalfuncs exposed by regression tests. We still have some work to do: these modules really ought to handle most or all of the utility statement node types. But it's better than it was.
2000-06-29 09:35:57 +02:00
case T_RestrictInfo:
retval = _equalRestrictInfo(a, b);
Support for subselects. (Have to re-visit readfuncs.c)
1998-02-13 04:27:47 +01:00
break;
Add a concept of "placeholder" variables to the planner. These are variables that represent some expression that we desire to compute below the top level of the plan, and then let that value "bubble up" as though it were a plain Var (ie, a column value). The immediate application is to allow sub-selects to be flattened even when they are below an outer join and have non-nullable output expressions. Formerly we couldn't flatten because such an expression wouldn't properly go to NULL when evaluated above the outer join. Now, we wrap it in a PlaceHolderVar and arrange for the actual evaluation to occur below the outer join. When the resulting Var bubbles up through the join, it will be set to NULL if necessary, yielding the correct results. This fixes a planner limitation that's existed since 7.1. In future we might want to use this mechanism to re-introduce some form of Hellerstein's "expensive functions" optimization, ie place the evaluation of an expensive function at the most suitable point in the plan tree.
2008-10-21 22:42:53 +02:00
case T_PlaceHolderVar:
retval = _equalPlaceHolderVar(a, b);
break;
Implement SEMI and ANTI joins in the planner and executor. (Semijoins replace the old JOIN_IN code, but antijoins are new functionality.) Teach the planner to convert appropriate EXISTS and NOT EXISTS subqueries into semi and anti joins respectively. Also, LEFT JOINs with suitable upper-level IS NULL filters are recognized as being anti joins. Unify the InClauseInfo and OuterJoinInfo infrastructure into "SpecialJoinInfo". With that change, it becomes possible to associate a SpecialJoinInfo with every join attempt, which permits some cleanup of join selectivity estimation. That needs to be taken much further than this patch does, but the next step is to change the API for oprjoin selectivity functions, which seems like material for a separate patch. So for the moment the output size estimates for semi and especially anti joins are quite bogus.
2008-08-14 20:48:00 +02:00
case T_SpecialJoinInfo:
retval = _equalSpecialJoinInfo(a, b);
IN clauses appearing at top level of WHERE can now be handled as joins. There are two implementation techniques: the executor understands a new JOIN_IN jointype, which emits at most one matching row per left-hand row, or the result of the IN's sub-select can be fed through a DISTINCT filter and then joined as an ordinary relation. Along the way, some minor code cleanup in the optimizer; notably, break out most of the jointree-rearrangement preprocessing in planner.c and put it in a new file prep/prepjointree.c.
2003-01-20 19:55:07 +01:00
break;
Fix up planner infrastructure to support LATERAL properly. This patch takes care of a number of problems having to do with failure to choose valid join orders and incorrect handling of lateral references pulled up from subqueries. Notable changes: * Add a LateralJoinInfo data structure similar to SpecialJoinInfo, to represent join ordering constraints created by lateral references. (I first considered extending the SpecialJoinInfo structure, but the semantics are different enough that a separate data structure seems better.) Extend join_is_legal() and related functions to prevent trying to form unworkable joins, and to ensure that we will consider joins that satisfy lateral references even if the joins would be clauseless. * Fill in the infrastructure needed for the last few types of relation scan paths to support parameterization. We'd have wanted this eventually anyway, but it is necessary now because a relation that gets pulled up out of a UNION ALL subquery may acquire a reltargetlist containing lateral references, meaning that its paths *have* to be parameterized whether or not we have any code that can push join quals down into the scan. * Compute data about lateral references early in query_planner(), and save in RelOptInfo nodes, to avoid repetitive calculations later. * Assorted corner-case bug fixes. There's probably still some bugs left, but this is a lot closer to being real than it was before.
2012-08-27 04:48:55 +02:00
case T_LateralJoinInfo:
retval = _equalLateralJoinInfo(a, b);
break;
Restructure planner's handling of inheritance. Rather than processing inheritance trees on-the-fly, which pretty well constrained us to considering only one way of planning inheritance, expand inheritance sets during the planner prep phase, and build a side data structure that can be consulted later to find which RTEs are members of which inheritance sets. As proof of concept, use the data structure to plan joins against inheritance sets more efficiently: we can now use indexes on the set members in inner-indexscan joins. (The generated plans could be improved further, but it'll take some executor changes.) This data structure will also support handling UNION ALL subqueries in the same way as inheritance sets, but that aspect of it isn't finished yet.
2006-01-31 22:39:25 +01:00
case T_AppendRelInfo:
retval = _equalAppendRelInfo(a, b);
break;
Add a concept of "placeholder" variables to the planner. These are variables that represent some expression that we desire to compute below the top level of the plan, and then let that value "bubble up" as though it were a plain Var (ie, a column value). The immediate application is to allow sub-selects to be flattened even when they are below an outer join and have non-nullable output expressions. Formerly we couldn't flatten because such an expression wouldn't properly go to NULL when evaluated above the outer join. Now, we wrap it in a PlaceHolderVar and arrange for the actual evaluation to occur below the outer join. When the resulting Var bubbles up through the join, it will be set to NULL if necessary, yielding the correct results. This fixes a planner limitation that's existed since 7.1. In future we might want to use this mechanism to re-introduce some form of Hellerstein's "expensive functions" optimization, ie place the evaluation of an expensive function at the most suitable point in the plan tree.
2008-10-21 22:42:53 +02:00
case T_PlaceHolderInfo:
retval = _equalPlaceHolderInfo(a, b);
break;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
case T_List:
Reimplement the linked list data structure used throughout the backend. In the past, we used a 'Lispy' linked list implementation: a "list" was merely a pointer to the head node of the list. The problem with that design is that it makes lappend() and length() linear time. This patch fixes that problem (and others) by maintaining a count of the list length and a pointer to the tail node along with each head node pointer. A "list" is now a pointer to a structure containing some meta-data about the list; the head and tail pointers in that structure refer to ListCell structures that maintain the actual linked list of nodes. The function names of the list API have also been changed to, I hope, be more logically consistent. By default, the old function names are still available; they will be disabled-by-default once the rest of the tree has been updated to use the new API names.
2004-05-26 06:41:50 +02:00
case T_IntList:
case T_OidList:
retval = _equalList(a, b);
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
break;
Add missing copyfuncs/equalfuncs entries, including T_Null which has been missing forever; surprising it wasn't noticed before. The other additions are, um, sloppiness in certain recent feature additions.
2002-08-19 02:11:53 +02:00
Add test code to copy all parse/plan trees. Repair essential omissions in copyfuncs and equalfuncs exposed by regression tests. We still have some work to do: these modules really ought to handle most or all of the utility statement node types. But it's better than it was.
2000-06-29 09:35:57 +02:00
case T_Integer:
case T_Float:
case T_String:
Change the parser to convert SQL "position" and "substring" syntax to position() and substring() functions, so that it works transparently for bit types as well. Alias the text functions appropriately. Add position() for bit types. Add new constant node T_BitString that represents literals of the form B'1001 and pass those to zpbit type.
2000-10-31 11:22:13 +01:00
case T_BitString:
Add missing copyfuncs/equalfuncs entries, including T_Null which has been missing forever; surprising it wasn't noticed before. The other additions are, um, sloppiness in certain recent feature additions.
2002-08-19 02:11:53 +02:00
case T_Null:
Add test code to copy all parse/plan trees. Repair essential omissions in copyfuncs and equalfuncs exposed by regression tests. We still have some work to do: these modules really ought to handle most or all of the utility statement node types. But it's better than it was.
2000-06-29 09:35:57 +02:00
retval = _equalValue(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 16:49:42 +01:00
/*
* PARSE NODES
*/
Add equality checking for T_Query so that we don't get complaints in UNION regress test. Probably still need some more node types to be handled here, but I'm done for the day...
1999-02-07 01:52:12 +01:00
case T_Query:
retval = _equalQuery(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_InsertStmt:
retval = _equalInsertStmt(a, b);
break;
case T_DeleteStmt:
retval = _equalDeleteStmt(a, b);
break;
case T_UpdateStmt:
retval = _equalUpdateStmt(a, b);
break;
case T_SelectStmt:
retval = _equalSelectStmt(a, b);
break;
Reimplementation of UNION/INTERSECT/EXCEPT. INTERSECT/EXCEPT now meet the SQL92 semantics, including support for ALL option. All three can be used in subqueries and views. DISTINCT and ORDER BY work now in views, too. This rewrite fixes many problems with cross-datatype UNIONs and INSERT/SELECT where the SELECT yields different datatypes than the INSERT needs. I did that by making UNION subqueries and SELECT in INSERT be treated like subselects-in-FROM, thereby allowing an extra level of targetlist where the datatype conversions can be inserted safely. INITDB NEEDED!
2000-10-05 21:11:39 +02:00
case T_SetOperationStmt:
retval = _equalSetOperationStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_AlterTableStmt:
retval = _equalAlterTableStmt(a, b);
break;
ALTER TABLE rewrite. New cool stuff: * ALTER ... ADD COLUMN with defaults and NOT NULL constraints works per SQL spec. A default is implemented by rewriting the table with the new value stored in each row. * ALTER COLUMN TYPE. You can change a column's datatype to anything you want, so long as you can specify how to convert the old value. Rewrites the table. (Possible future improvement: optimize no-op conversions such as varchar(N) to varchar(N+1).) * Multiple ALTER actions in a single ALTER TABLE command. You can perform any number of column additions, type changes, and constraint additions with only one pass over the table contents. Basic documentation provided in ALTER TABLE ref page, but some more docs work is needed. Original patch from Rod Taylor, additional work from Tom Lane.
2004-05-05 06:48:48 +02:00
case T_AlterTableCmd:
retval = _equalAlterTableCmd(a, b);
break;
Re-addd Rod's ALTER DOMAIN patch.
2002-12-06 06:00:34 +01:00
case T_AlterDomainStmt:
retval = _equalAlterDomainStmt(a, b);
break;
Allow GRANT/REVOKE to/from more than one user per invocation. Command tag for GRANT/REVOKE is now just that, not "CHANGE". On the way, migrate some of the aclitem internal representation away from the parser and build a real parse tree instead. Also add some 'const' qualifiers.
2001-06-10 01:21:55 +02:00
case T_GrantStmt:
retval = _equalGrantStmt(a, b);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
break;
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
case T_GrantRoleStmt:
retval = _equalGrantRoleStmt(a, b);
break;
Create an ALTER DEFAULT PRIVILEGES command, which allows users to adjust the privileges that will be applied to subsequently-created objects. Such adjustments are always per owning role, and can be restricted to objects created in particular schemas too. A notable benefit is that users can override the traditional default privilege settings, eg, the PUBLIC EXECUTE privilege traditionally granted by default for functions. Petr Jelinek
2009-10-05 21:24:49 +02:00
case T_AlterDefaultPrivilegesStmt:
retval = _equalAlterDefaultPrivilegesStmt(a, b);
break;
Restructure parsetree representation of DECLARE CURSOR: now it's a utility statement (DeclareCursorStmt) with a SELECT query dangling from it, rather than a SELECT query with a few unusual fields in it. Add code to determine whether a planned query can safely be run backwards. If DECLARE CURSOR specifies SCROLL, ensure that the plan can be run backwards by adding a Materialize plan node if it can't. Without SCROLL, you get an error if you try to fetch backwards from a cursor that can't handle it. (There is still some discussion about what the exact behavior should be, but this is necessary infrastructure in any case.) Along the way, make EXPLAIN DECLARE CURSOR work.
2003-03-10 04:53:52 +01:00
case T_DeclareCursorStmt:
retval = _equalDeclareCursorStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_ClosePortalStmt:
retval = _equalClosePortalStmt(a, b);
break;
case T_ClusterStmt:
retval = _equalClusterStmt(a, b);
break;
case T_CopyStmt:
retval = _equalCopyStmt(a, b);
break;
case T_CreateStmt:
retval = _equalCreateStmt(a, b);
break;
Rename the internal structures of the CREATE TABLE (LIKE ...) facility The original implementation of this interpreted it as a kind of "inheritance" facility and named all the internal structures accordingly. This turned out to be very confusing, because it has nothing to do with the INHERITS feature. So rename all the internal parser infrastructure, update the comments, adjust the error messages, and split up the regression tests.
2012-01-07 13:58:13 +01:00
case T_TableLikeClause:
retval = _equalTableLikeClause(a, b);
Includes: - LIKE <subtable> [ INCLUDING DEFAULTS | EXCLUDING DEFAULTS ] - Quick cleanup of analyze.c function prototypes. - New non-reserved keywords (INCLUDING, EXCLUDING, DEFAULTS), SQL 200X Opted not to extend for check constraints at this time. As per the definition that it's user defined columns, OIDs are NOT inherited. Doc and Source patches attached. -- Rod Taylor <rbt@rbt.ca>
2003-06-25 05:40:19 +02:00
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_DefineStmt:
retval = _equalDefineStmt(a, b);
break;
case T_DropStmt:
retval = _equalDropStmt(a, b);
break;
case T_TruncateStmt:
retval = _equalTruncateStmt(a, b);
break;
case T_CommentStmt:
retval = _equalCommentStmt(a, b);
break;
Add a SECURITY LABEL command. This is intended as infrastructure to support integration with label-based mandatory access control systems such as SE-Linux. Further changes (mostly hooks) will be needed, but this is a big chunk of it. KaiGai Kohei and Robert Haas
2010-09-28 02:55:27 +02:00
case T_SecLabelStmt:
retval = _equalSecLabelStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_FetchStmt:
retval = _equalFetchStmt(a, b);
break;
case T_IndexStmt:
retval = _equalIndexStmt(a, b);
break;
Extend syntax of CREATE FUNCTION to resemble SQL99.
2002-05-17 20:32:52 +02:00
case T_CreateFunctionStmt:
retval = _equalCreateFunctionStmt(a, b);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
break;
Apply the core parts of Dennis Bjorklund's patch to allow function parameters to be declared with names. pg_proc has a column to store names, and CREATE FUNCTION can insert data into it, but that's all as yet. I need to do more work on the pg_dump and plpgsql portions of the patch before committing those, but I thought I'd get the bulky changes in before the tree drifts under me. initdb forced due to pg_proc change.
2004-01-07 00:55:19 +01:00
case T_FunctionParameter:
retval = _equalFunctionParameter(a, b);
break;
Allow ALTER FUNCTION to change a function's strictness, volatility, and whether or not it is a security definer. Changing a function's strictness is required by SQL2003, and the other capabilities make sense. Also, allow an optional RESTRICT noise word to be specified, for SQL conformance. Some trivial regression tests added and the documentation has been updated.
2005-03-14 01:19:37 +01:00
case T_AlterFunctionStmt:
retval = _equalAlterFunctionStmt(a, b);
break;
Implement the DO statement to support execution of PL code without having to create a function for it. Procedural languages now have an additional entry point, namely a function to execute an inline code block. This seemed a better design than trying to hide the transient-ness of the code from the PL. As of this patch, only plpgsql has an inline handler, but probably people will soon write handlers for the other standard PLs. In passing, remove the long-dead LANCOMPILER option of CREATE LANGUAGE. Petr Jelinek
2009-09-23 01:43:43 +02:00
case T_DoStmt:
retval = _equalDoStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_RenameStmt:
retval = _equalRenameStmt(a, b);
break;
Add ALTER object SET SCHEMA capability for a limited but useful set of object kinds (tables, functions, types). Documentation is not here yet. Original code by Bernd Helmle, extensive rework by Bruce Momjian and Tom Lane.
2005-08-01 06:03:59 +02:00
case T_AlterObjectSchemaStmt:
retval = _equalAlterObjectSchemaStmt(a, b);
break;
Support renaming of tablespaces, and changing the owners of aggregates, conversions, functions, operators, operator classes, schemas, types, and tablespaces. Fold the existing implementations of alter domain owner and alter database owner in with these. Christopher Kings-Lynne
2004-06-25 23:55:59 +02:00
case T_AlterOwnerStmt:
retval = _equalAlterOwnerStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_RuleStmt:
retval = _equalRuleStmt(a, b);
break;
case T_NotifyStmt:
retval = _equalNotifyStmt(a, b);
break;
case T_ListenStmt:
retval = _equalListenStmt(a, b);
break;
case T_UnlistenStmt:
retval = _equalUnlistenStmt(a, b);
break;
case T_TransactionStmt:
retval = _equalTransactionStmt(a, b);
break;
Tom Lane wrote: > There's no longer a separate call to heap_storage_create in that routine > --- the right place to make the test is now in the storage_create > boolean parameter being passed to heap_create. A simple change, but > it passeth patch's understanding ... Thanks. Attached is a patch against cvs tip as of 8:30 PM PST or so. Turned out that even after fixing the failed hunks, there was a new spot in bufmgr.c which needed to be fixed (related to temp relations; RelationUpdateNumberOfBlocks). But thankfully the regression test code caught it :-) Joe Conway
2002-08-15 18:36:08 +02:00
case T_CompositeTypeStmt:
retval = _equalCompositeTypeStmt(a, b);
break;
Support enum data types. Along the way, use macros for the values of pg_type.typtype whereever practical. Tom Dunstan, with some kibitzing from Tom Lane.
2007-04-02 05:49:42 +02:00
case T_CreateEnumStmt:
retval = _equalCreateEnumStmt(a, b);
break;
Support range data types. Selectivity estimation functions are missing for some range type operators, which is a TODO. Jeff Davis
2011-11-03 12:16:28 +01:00
case T_CreateRangeStmt:
retval = _equalCreateRangeStmt(a, b);
break;
Allow new values to be added to an existing enum type. After much expenditure of effort, we've got this to the point where the performance penalty is pretty minimal in typical cases. Andrew Dunstan, reviewed by Brendan Jurd, Dean Rasheed, and Tom Lane
2010-10-25 05:04:37 +02:00
case T_AlterEnumStmt:
retval = _equalAlterEnumStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_ViewStmt:
retval = _equalViewStmt(a, b);
break;
case T_LoadStmt:
retval = _equalLoadStmt(a, b);
break;
Add DOMAIN support. Includes manual pages and regression tests, from Rod Taylor.
2002-03-19 03:18:25 +01:00
case T_CreateDomainStmt:
retval = _equalCreateDomainStmt(a, b);
break;
Implement CREATE/DROP OPERATOR CLASS. Work still remains: need more documentation (xindex.sgml should be rewritten), need to teach pg_dump about it, need to update contrib modules that currently build pg_opclass entries by hand. Original patch by Bill Studenmund, grammar adjustments and general update for 7.3 by Tom Lane.
2002-07-30 00:14:11 +02:00
case T_CreateOpClassStmt:
retval = _equalCreateOpClassStmt(a, b);
break;
case T_CreateOpClassItem:
retval = _equalCreateOpClassItem(a, b);
break;
Add CREATE/ALTER/DROP OPERATOR FAMILY commands, also COMMENT ON OPERATOR FAMILY; and add FAMILY option to CREATE OPERATOR CLASS to allow adding a class to a pre-existing family. Per previous discussion. Man, what a tedious lot of cutting and pasting ...
2007-01-23 06:07:18 +01:00
case T_CreateOpFamilyStmt:
retval = _equalCreateOpFamilyStmt(a, b);
break;
case T_AlterOpFamilyStmt:
retval = _equalAlterOpFamilyStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_CreatedbStmt:
retval = _equalCreatedbStmt(a, b);
break;
Add per-user and per-database connection limit options. This patch also includes preliminary update of pg_dumpall for roles. Petr Jelinek, with review by Bruce Momjian and Tom Lane.
2005-07-31 19:19:22 +02:00
case T_AlterDatabaseStmt:
retval = _equalAlterDatabaseStmt(a, b);
break;
User and database-specific session defaults for run-time configuration variables. New commands ALTER DATABASE ... SET and ALTER USER ... SET.
2002-03-01 23:45:19 +01:00
case T_AlterDatabaseSetStmt:
retval = _equalAlterDatabaseSetStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_DropdbStmt:
retval = _equalDropdbStmt(a, b);
break;
case T_VacuumStmt:
retval = _equalVacuumStmt(a, b);
break;
case T_ExplainStmt:
retval = _equalExplainStmt(a, b);
break;
Restructure SELECT INTO's parsetree representation into CreateTableAsStmt. Making this operation look like a utility statement seems generally a good idea, and particularly so in light of the desire to provide command triggers for utility statements. The original choice of representing it as SELECT with an IntoClause appendage had metastasized into rather a lot of places, unfortunately, so that this patch is a great deal more complicated than one might at first expect. In particular, keeping EXPLAIN working for SELECT INTO and CREATE TABLE AS subcommands required restructuring some EXPLAIN-related APIs. Add-on code that calls ExplainOnePlan or ExplainOneUtility, or uses ExplainOneQuery_hook, will need adjustment. Also, the cases PREPARE ... SELECT INTO and CREATE RULE ... SELECT INTO, which formerly were accepted though undocumented, are no longer accepted. The PREPARE case can be replaced with use of CREATE TABLE AS EXECUTE. The CREATE RULE case doesn't seem to have much real-world use (since the rule would work only once before failing with "table already exists"), so we'll not bother with that one. Both SELECT INTO and CREATE TABLE AS still return a command tag of "SELECT nnnn". There was some discussion of returning "CREATE TABLE nnnn", but for the moment backwards compatibility wins the day. Andres Freund and Tom Lane
2012-03-20 02:37:19 +01:00
case T_CreateTableAsStmt:
retval = _equalCreateTableAsStmt(a, b);
break;
Add a materialized view relations. A materialized view has a rule just like a view and a heap and other physical properties like a table. The rule is only used to populate the table, references in queries refer to the materialized data. This is a minimal implementation, but should still be useful in many cases. Currently data is only populated "on demand" by the CREATE MATERIALIZED VIEW and REFRESH MATERIALIZED VIEW statements. It is expected that future releases will add incremental updates with various timings, and that a more refined concept of defining what is "fresh" data will be developed. At some point it may even be possible to have queries use a materialized in place of references to underlying tables, but that requires the other above-mentioned features to be working first. Much of the documentation work by Robert Haas. Review by Noah Misch, Thom Brown, Robert Haas, Marko Tiikkaja Security review by KaiGai Kohei, with a decision on how best to implement sepgsql still pending.
2013-03-04 01:23:31 +01:00
case T_RefreshMatViewStmt:
retval = _equalRefreshMatViewStmt(a, b);
break;
Add the notion of REPLICA IDENTITY for a table. Pending patches for logical replication will use this to determine which columns of a tuple ought to be considered as its candidate key. Andres Freund, with minor, mostly cosmetic adjustments by me
2013-11-08 18:30:43 +01:00
case T_ReplicaIdentityStmt:
retval = _equalReplicaIdentityStmt(a, b);
break;
Add ALTER SYSTEM command to edit the server configuration file. Patch contributed by Amit Kapila. Reviewed by Hari Babu, Masao Fujii, Boszormenyi Zoltan, Andres Freund, Greg Smith and others.
2013-12-18 15:42:44 +01:00
case T_AlterSystemStmt:
retval = _equalAlterSystemStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_CreateSeqStmt:
retval = _equalCreateSeqStmt(a, b);
break;
Todo items: Add ALTER SEQUENCE to modify min/max/increment/cache/cycle values Also updated create sequence docs to mention NO MINVALUE, & NO MAXVALUE. New Files: doc/src/sgml/ref/alter_sequence.sgml src/test/regress/expected/sequence.out src/test/regress/sql/sequence.sql ALTER SEQUENCE is NOT transactional. It behaves similarly to setval(). It matches the proposed SQL200N spec, as well as Oracle in most ways -- Oracle lacks RESTART WITH for some strange reason. -- Rod Taylor <rbt@rbt.ca>
2003-03-20 08:02:11 +01:00
case T_AlterSeqStmt:
retval = _equalAlterSeqStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_VariableSetStmt:
retval = _equalVariableSetStmt(a, b);
break;
case T_VariableShowStmt:
retval = _equalVariableShowStmt(a, b);
break;
Rename the newly-added commands for discarding session state. RESET SESSION, RESET PLANS, and RESET TEMP are now DISCARD ALL, DISCARD PLANS, and DISCARD TEMP, respectively. This is to avoid confusion with the pre-existing RESET variants: the DISCARD commands are not actually similar to RESET. Patch from Marko Kreen, with some minor editorialization.
2007-04-26 18:13:15 +02:00
case T_DiscardStmt:
retval = _equalDiscardStmt(a, b);
break;
Tablespaces. Alternate database locations are dead, long live tablespaces. There are various things left to do: contrib dbsize and oid2name modules need work, and so does the documentation. Also someone should think about COMMENT ON TABLESPACE and maybe RENAME TABLESPACE. Also initlocation is dead, it just doesn't know it yet. Gavin Sherry and Tom Lane.
2004-06-18 08:14:31 +02:00
case T_CreateTableSpaceStmt:
retval = _equalCreateTableSpaceStmt(a, b);
break;
case T_DropTableSpaceStmt:
retval = _equalDropTableSpaceStmt(a, b);
break;
Support ALTER TABLESPACE name SET/RESET ( tablespace_options ). This patch only supports seq_page_cost and random_page_cost as parameters, but it provides the infrastructure to scalably support many more. In particular, we may want to add support for effective_io_concurrency, but I'm leaving that as future work for now. Thanks to Tom Lane for design help and Alvaro Herrera for the review.
2010-01-05 22:54:00 +01:00
case T_AlterTableSpaceOptionsStmt:
retval = _equalAlterTableSpaceOptionsStmt(a, b);
break;
Add ALTER TABLESPACE ... MOVE command This adds a 'MOVE' sub-command to ALTER TABLESPACE which allows moving sets of objects from one tablespace to another. This can be extremely handy and avoids a lot of error-prone scripting. ALTER TABLESPACE ... MOVE will only move objects the user owns, will notify the user if no objects were found, and can be used to move ALL objects or specific types of objects (TABLES, INDEXES, or MATERIALIZED VIEWS).
2014-01-19 00:56:40 +01:00
case T_AlterTableSpaceMoveStmt:
retval = _equalAlterTableSpaceMoveStmt(a, b);
break;
Core support for "extensions", which are packages of SQL objects. This patch adds the server infrastructure to support extensions. There is still one significant loose end, namely how to make it play nice with pg_upgrade, so I am not yet committing the changes that would make all the contrib modules depend on this feature. In passing, fix a disturbingly large amount of breakage in AlterObjectNamespace() and callers. Dimitri Fontaine, reviewed by Anssi Kääriäinen, Itagaki Takahiro, Tom Lane, and numerous others
2011-02-08 22:08:41 +01:00
case T_CreateExtensionStmt:
retval = _equalCreateExtensionStmt(a, b);
break;
Add support for multiple versions of an extension and ALTER EXTENSION UPDATE. This follows recent discussions, so it's quite a bit different from Dimitri's original. There will probably be more changes once we get a bit of experience with it, but let's get it in and start playing with it. This is still just core code. I'll start converting contrib modules shortly. Dimitri Fontaine and Tom Lane
2011-02-12 03:25:20 +01:00
case T_AlterExtensionStmt:
retval = _equalAlterExtensionStmt(a, b);
break;
Extend "ALTER EXTENSION ADD object" to permit "DROP object" as well. Per discussion, this is something we should have sooner rather than later, and it doesn't take much additional code to support it.
2011-02-10 23:36:44 +01:00
case T_AlterExtensionContentsStmt:
retval = _equalAlterExtensionContentsStmt(a, b);
Implement "ALTER EXTENSION ADD object". This is an essential component of making the extension feature usable; first because it's needed in the process of converting an existing installation containing "loose" objects of an old contrib module into the extension-based world, and second because we'll have to use it in pg_dump --binary-upgrade, as per recent discussion. Loosely based on part of Dimitri Fontaine's ALTER EXTENSION UPGRADE patch.
2011-02-09 17:55:32 +01:00
break;
SQL/MED catalog manipulation facilities This doesn't do any remote or external things yet, but it gives modules like plproxy and dblink a standardized and future-proof system for managing their connection information. Martin Pihlak and Peter Eisentraut
2008-12-19 17:25:19 +01:00
case T_CreateFdwStmt:
retval = _equalCreateFdwStmt(a, b);
break;
case T_AlterFdwStmt:
retval = _equalAlterFdwStmt(a, b);
break;
case T_CreateForeignServerStmt:
retval = _equalCreateForeignServerStmt(a, b);
break;
case T_AlterForeignServerStmt:
retval = _equalAlterForeignServerStmt(a, b);
break;
case T_CreateUserMappingStmt:
retval = _equalCreateUserMappingStmt(a, b);
break;
case T_AlterUserMappingStmt:
retval = _equalAlterUserMappingStmt(a, b);
break;
case T_DropUserMappingStmt:
retval = _equalDropUserMappingStmt(a, b);
break;
Basic foreign table support. Foreign tables are a core component of SQL/MED. This commit does not provide a working SQL/MED infrastructure, because foreign tables cannot yet be queried. Support for foreign table scans will need to be added in a future patch. However, this patch creates the necessary system catalog structure, syntax support, and support for ancillary operations such as COMMENT and SECURITY LABEL. Shigeru Hanada, heavily revised by Robert Haas
2011-01-02 05:48:11 +01:00
case T_CreateForeignTableStmt:
retval = _equalCreateForeignTableStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_CreateTrigStmt:
retval = _equalCreateTrigStmt(a, b);
break;
Syntax support and documentation for event triggers. They don't actually do anything yet; that will get fixed in a follow-on commit. But this gets the basic infrastructure in place, including CREATE/ALTER/DROP EVENT TRIGGER; support for COMMENT, SECURITY LABEL, and ALTER EXTENSION .. ADD/DROP EVENT TRIGGER; pg_dump and psql support; and documentation for the anticipated initial feature set. Dimitri Fontaine, with review and a bunch of additional hacking by me. Thom Brown extensively reviewed earlier versions of this patch set, but there's not a whole lot of that code left in this commit, as it turns out.
2012-07-18 16:16:16 +02:00
case T_CreateEventTrigStmt:
retval = _equalCreateEventTrigStmt(a, b);
break;
case T_AlterEventTrigStmt:
retval = _equalAlterEventTrigStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_CreatePLangStmt:
retval = _equalCreatePLangStmt(a, b);
break;
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
case T_CreateRoleStmt:
retval = _equalCreateRoleStmt(a, b);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
break;
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
case T_AlterRoleStmt:
retval = _equalAlterRoleStmt(a, b);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
break;
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
case T_AlterRoleSetStmt:
retval = _equalAlterRoleSetStmt(a, b);
User and database-specific session defaults for run-time configuration variables. New commands ALTER DATABASE ... SET and ALTER USER ... SET.
2002-03-01 23:45:19 +01:00
break;
Replace pg_shadow and pg_group by new role-capable catalogs pg_authid and pg_auth_members. There are still many loose ends to finish in this patch (no documentation, no regression tests, no pg_dump support for instance). But I'm going to commit it now anyway so that Alvaro can make some progress on shared dependencies. The catalog changes should be pretty much done.
2005-06-28 07:09:14 +02:00
case T_DropRoleStmt:
retval = _equalDropRoleStmt(a, b);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
break;
case T_LockStmt:
retval = _equalLockStmt(a, b);
break;
case T_ConstraintsSetStmt:
retval = _equalConstraintsSetStmt(a, b);
break;
case T_ReindexStmt:
retval = _equalReindexStmt(a, b);
break;
New CHECKPOINT command. Auto removing of offline log files and creating new file at checkpoint time.
2000-11-05 23:50:21 +01:00
case T_CheckPointStmt:
retval = true;
break;
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't *do* anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname.
2002-03-21 17:02:16 +01:00
case T_CreateSchemaStmt:
retval = _equalCreateSchemaStmt(a, b);
break;
Add missing copyfuncs/equalfuncs entries, including T_Null which has been missing forever; surprising it wasn't noticed before. The other additions are, um, sloppiness in certain recent feature additions.
2002-08-19 02:11:53 +02:00
case T_CreateConversionStmt:
retval = _equalCreateConversionStmt(a, b);
break;
case T_CreateCastStmt:
retval = _equalCreateCastStmt(a, b);
break;
PREPARE/EXECUTE statements. Patch by Neil Conway, some kibitzing from Tom Lane.
2002-08-27 06:55:12 +02:00
case T_PrepareStmt:
retval = _equalPrepareStmt(a, b);
break;
case T_ExecuteStmt:
retval = _equalExecuteStmt(a, b);
break;
case T_DeallocateStmt:
retval = _equalDeallocateStmt(a, b);
break;
Implement DROP OWNED and REASSIGN OWNED. These new commands facilitate the process of dropping roles by dropping objects owned by them and privileges granted to them, or giving the owned objects to someone else, through the use of the data stored in the new pg_shdepend catalog. Some refactoring of the GRANT/REVOKE code was needed, as well as ALTER OWNER code. Further cleanup of code duplication in the GRANT code seems necessary. Implemented by me after an idea from Tom Lane, who also provided various kind of implementation advice. Regression tests pass. Some tests for the new functionality are also added, as well as rudimentary documentation.
2005-11-21 13:49:33 +01:00
case T_DropOwnedStmt:
retval = _equalDropOwnedStmt(a, b);
break;
case T_ReassignOwnedStmt:
retval = _equalReassignOwnedStmt(a, b);
break;
Add missing copyfuncs/equalfuncs support for AlterTSDictionaryStmt and AlterTSConfigurationStmt. All utility statement node types are expected to be supported here, though they do not have to have outfuncs/readfuncs support. Found by running regression tests with COPY_PARSE_PLAN_TREES enabled.
2008-02-07 21:19:47 +01:00
case T_AlterTSDictionaryStmt:
retval = _equalAlterTSDictionaryStmt(a, b);
break;
case T_AlterTSConfigurationStmt:
retval = _equalAlterTSConfigurationStmt(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_A_Expr:
retval = _equalAExpr(a, b);
break;
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't *do* anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname.
2002-03-21 17:02:16 +01:00
case T_ColumnRef:
retval = _equalColumnRef(a, b);
break;
case T_ParamRef:
retval = _equalParamRef(a, b);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
break;
case T_A_Const:
retval = _equalAConst(a, b);
break;
case T_FuncCall:
retval = _equalFuncCall(a, b);
break;
Fix the raw-parsetree representation of star (as in SELECT * FROM or SELECT foo.*) so that it cannot be confused with a quoted identifier "*". Instead create a separate node type A_Star to represent this notation. Per pgsql-hackers discussion of 2007-Sep-27.
2008-08-30 03:39:14 +02:00
case T_A_Star:
retval = _equalAStar(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_A_Indices:
retval = _equalAIndices(a, b);
break;
Support assignment to subfields of composite columns in UPDATE and INSERT. As a side effect, cause subscripts in INSERT targetlists to do something more or less sensible; previously we evaluated such subscripts and then effectively ignored them. Another side effect is that UPDATE-ing an element or slice of an array value that is NULL now produces a non-null result, namely an array containing just the assigned-to positions.
2004-06-09 21:08:20 +02:00
case T_A_Indirection:
retval = _equalA_Indirection(a, b);
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't *do* anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname.
2002-03-21 17:02:16 +01:00
break;
Arrange for an explicit cast applied to an ARRAY[] constructor to be applied directly to all the member expressions, instead of the previous implementation where the ARRAY[] constructor would infer a common element type and then we'd coerce the finished array after the fact. This has a number of benefits, one being that we can allow an empty ARRAY[] construct so long as its element type is specified by such a cast. Brendan Jurd, minor fixes by me.
2008-03-20 22:42:48 +01:00
case T_A_ArrayExpr:
retval = _equalA_ArrayExpr(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_ResTarget:
retval = _equalResTarget(a, b);
break;
case T_TypeCast:
retval = _equalTypeCast(a, b);
break;
Per-column collation support This adds collation support for columns and domains, a COLLATE clause to override it per expression, and B-tree index support. Peter Eisentraut reviewed by Pavel Stehule, Itagaki Takahiro, Robert Haas, Noah Misch
2011-02-08 22:04:18 +01:00
case T_CollateClause:
retval = _equalCollateClause(a, b);
break;
Create a 'type cache' that keeps track of the data needed for any particular datatype by array_eq and array_cmp; use this to solve problems with memory leaks in array indexing support. The parser's equality_oper and ordering_oper routines also use the cache. Change the operator search algorithms to look for appropriate btree or hash index opclasses, instead of assuming operators named '<' or '=' have the right semantics. (ORDER BY ASC/DESC now also look at opclasses, instead of assuming '<' and '>' are the right things.) Add several more index opclasses so that there is no regression in functionality for base datatypes. initdb forced due to catalog additions.
2003-08-17 21:58:06 +02:00
case T_SortBy:
retval = _equalSortBy(a, b);
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
break;
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
case T_WindowDef:
retval = _equalWindowDef(a, b);
break;
First cut at full support for OUTER JOINs. There are still a few loose ends to clean up (see my message of same date to pghackers), but mostly it works. INITDB REQUIRED!
2000-09-12 23:07:18 +02:00
case T_RangeSubselect:
retval = _equalRangeSubselect(a, b);
break;
First pass at set-returning-functions in FROM, by Joe Conway with some kibitzing from Tom Lane. Not everything works yet, and there's no documentation or regression test, but let's commit this so Joe doesn't need to cope with tracking changes in so many files ...
2002-05-12 22:10:05 +02:00
case T_RangeFunction:
retval = _equalRangeFunction(a, b);
break;
copyObject() and equal() now know about all parse-time node types, including utility statements. Still can't copy or compare executor state, but at present that doesn't seem to be necessary. This makes it possible to execute most (all?) utility statements in plpgsql. Had to change parsetree representation of CreateTrigStmt so that it contained only legal Nodes, and not bare string constants.
2000-08-12 01:45:35 +02:00
case T_TypeName:
retval = _equalTypeName(a, b);
break;
case T_IndexElem:
retval = _equalIndexElem(a, b);
break;
case T_ColumnDef:
retval = _equalColumnDef(a, b);
break;
case T_Constraint:
retval = _equalConstraint(a, b);
break;
case T_DefElem:
retval = _equalDefElem(a, b);
break;
Add NOWAIT option to SELECT FOR UPDATE/SHARE. Original patch by Hans-Juergen Schoenig, revisions by Karel Zak and Tom Lane.
2005-08-01 22:31:16 +02:00
case T_LockingClause:
retval = _equalLockingClause(a, b);
break;
Add equality checking for T_Query so that we don't get complaints in UNION regress test. Probably still need some more node types to be handled here, but I'm done for the day...
1999-02-07 01:52:12 +01:00
case T_RangeTblEntry:
retval = _equalRangeTblEntry(a, b);
break;
Support multi-argument UNNEST(), and TABLE() syntax for multiple functions. This patch adds the ability to write TABLE( function1(), function2(), ...) as a single FROM-clause entry. The result is the concatenation of the first row from each function, followed by the second row from each function, etc; with NULLs inserted if any function produces fewer rows than others. This is believed to be a much more useful behavior than what Postgres currently does with multiple SRFs in a SELECT list. This syntax also provides a reasonable way to combine use of column definition lists with WITH ORDINALITY: put the column definition list inside TABLE(), where it's clear that it doesn't control the ordinality column as well. Also implement SQL-compliant multiple-argument UNNEST(), by turning UNNEST(a,b,c) into TABLE(unnest(a), unnest(b), unnest(c)). The SQL standard specifies TABLE() with only a single function, not multiple functions, and it seems to require an implicit UNNEST() which is not what this patch does. There may be something wrong with that reading of the spec, though, because if it's right then the spec's TABLE() is just a pointless alternative spelling of UNNEST(). After further review of that, we might choose to adopt a different syntax for what this patch does, but in any case this functionality seems clearly worthwhile. Andrew Gierth, reviewed by Zoltán Böszörményi and Heikki Linnakangas, and significantly revised by me
2013-11-22 01:37:02 +01:00
case T_RangeTblFunction:
retval = _equalRangeTblFunction(a, b);
break;
WITH CHECK OPTION support for auto-updatable VIEWs For simple views which are automatically updatable, this patch allows the user to specify what level of checking should be done on records being inserted or updated. For 'LOCAL CHECK', new tuples are validated against the conditionals of the view they are being inserted into, while for 'CASCADED CHECK' the new tuples are validated against the conditionals for all views involved (from the top down). This option is part of the SQL specification. Dean Rasheed, reviewed by Pavel Stehule
2013-07-18 23:10:16 +02:00
case T_WithCheckOption:
retval = _equalWithCheckOption(a, b);
break;
Rearrange the querytree representation of ORDER BY/GROUP BY/DISTINCT items as per my recent proposal: 1. Fold SortClause and GroupClause into a single node type SortGroupClause. We were already relying on them to be struct-equivalent, so using two node tags wasn't accomplishing much except to get in the way of comparing items with equal(). 2. Add an "eqop" field to SortGroupClause to carry the associated equality operator. This is cheap for the parser to get at the same time it's looking up the sort operator, and storing it eliminates the need for repeated not-so-cheap lookups during planning. In future this will also let us represent GROUP/DISTINCT operations on datatypes that have hash opclasses but no btree opclasses (ie, they have equality but no natural sort order). The previous representation simply didn't work for that, since its only indicator of comparison semantics was a sort operator. 3. Add a hasDistinctOn boolean to struct Query to explicitly record whether the distinctClause came from DISTINCT or DISTINCT ON. This allows removing some complicated and not 100% bulletproof code that attempted to figure that out from the distinctClause alone. This patch doesn't in itself create any new capability, but it's necessary infrastructure for future attempts to use hash-based grouping for DISTINCT and UNION/INTERSECT/EXCEPT.
2008-08-02 23:32:01 +02:00
case T_SortGroupClause:
retval = _equalSortGroupClause(a, b);
Hmm, equalfuncs didn't know about SortClause or GroupClause nodes...
2000-01-31 02:21:39 +01:00
break;
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom.
2008-12-28 19:54:01 +01:00
case T_WindowClause:
retval = _equalWindowClause(a, b);
break;
Improve the representation of FOR UPDATE/FOR SHARE so that we can support both FOR UPDATE and FOR SHARE in one command, as well as both NOWAIT and normal WAIT behavior. The more general code is actually simpler and cleaner.
2006-04-30 20:30:40 +02:00
case T_RowMarkClause:
retval = _equalRowMarkClause(a, b);
break;
Implement SQL-standard WITH clauses, including WITH RECURSIVE. There are some unimplemented aspects: recursive queries must use UNION ALL (should allow UNION too), and we don't have SEARCH or CYCLE clauses. These might or might not get done for 8.4, but even without them it's a pretty useful feature. There are also a couple of small loose ends and definitional quibbles, which I'll send a memo about to pgsql-hackers shortly. But let's land the patch now so we can get on with other development. Yoshiyuki Asaba, with lots of help from Tatsuo Ishii and Tom Lane
2008-10-04 23:56:55 +02:00
case T_WithClause:
retval = _equalWithClause(a, b);
break;
case T_CommonTableExpr:
retval = _equalCommonTableExpr(a, b);
break;
Allow GRANT/REVOKE to/from more than one user per invocation. Command tag for GRANT/REVOKE is now just that, not "CHANGE". On the way, migrate some of the aclitem internal representation away from the parser and build a real parse tree instead. Also add some 'const' qualifiers.
2001-06-10 01:21:55 +02:00
case T_PrivGrantee:
retval = _equalPrivGrantee(a, b);
break;
Privileges on functions and procedural languages
2002-02-19 00:11:58 +01:00
case T_FuncWithArgs:
retval = _equalFuncWithArgs(a, b);
break;
Support column-level privileges, as required by SQL standard. Stephen Frost, with help from KaiGai Kohei and others
2009-01-22 21:16:10 +01:00
case T_AccessPriv:
retval = _equalAccessPriv(a, b);
break;
Implement XMLSERIALIZE for real. Analogously, make the xml to text cast observe the xmloption. Reorganize the representation of the XML option in the parse tree and the API to make it easier to manage and understand. Add regression tests for parsing back XML expressions.
2007-02-03 15:06:56 +01:00
case T_XmlSerialize:
retval = _equalXmlSerialize(a, b);
break;
Add test code to copy all parse/plan trees. Repair essential omissions in copyfuncs and equalfuncs exposed by regression tests. We still have some work to do: these modules really ought to handle most or all of the utility statement node types. But it's better than it was.
2000-06-29 09:35:57 +02:00
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
default:
Error message editing in backend/bootstrap, /lib, /nodes, /port.
2003-07-23 01:30:39 +02:00
elog(ERROR, "unrecognized node type: %d",
(int) nodeTag(a));
retval = false; /* keep compiler quiet */
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 04:41:22 +02:00
break;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 07:04:48 +02:00
return retval;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 08:22:35 +02:00
}