When a view has a function-returning-composite in FROM, and there are some dropped columns in the underlying composite type, ruleutils.c printed junk in the column alias list for the reconstructed FROM entry. Before 9.3, this was prevented by doing get_rte_attribute_is_dropped tests while printing the column alias list; but that solution is not currently available to us for reasons I'll explain below. Instead, check for empty-string entries in the alias list, which can only exist if that column position had been dropped at the time the view was made. (The parser fills in empty strings to preserve the invariant that the aliases correspond to physical column positions.) While this is sufficient to handle the case of columns dropped before the view was made, we have still got issues with columns dropped after the view was made. In particular, the view could contain Vars that explicitly reference such columns! The dependency machinery really ought to refuse the column drop attempt in such cases, as it would do when trying to drop a table column that's explicitly referenced in views. However, we currently neglect to store dependencies on columns of composite types, and fixing that is likely to be too big to be back-patchable (not to mention that existing views in existing databases would not have the needed pg_depend entries anyway). So I'll leave that for a separate patch. Pre-9.3, ruleutils would print such Vars normally (with their original column names) even though it suppressed their entries in the RTE's column alias list. This is certainly bogus, since the printed view definition would fail to reload, but at least it didn't crash. However, as of 9.3 the printed column alias list is tightly tied to the names printed for Vars; so we can't treat columns as dropped for one purpose and not dropped for the other. This is why we can't just put back the get_rte_attribute_is_dropped test: it results in an assertion failure if the view in fact contains any Vars referencing the dropped column. Once we've got dependencies preventing such cases, we'll probably want to do it that way instead of relying on the empty-string test used here. This fix turned up a very ancient bug in outfuncs/readfuncs, namely that T_String nodes containing empty strings were not dumped/reloaded correctly: the node was printed as "<>" which is read as a string value of <>. Since (per SQL) we disallow empty-string identifiers, such nodes don't occur normally, which is why we'd not noticed. (Such nodes aren't used for literal constants, just identifiers.) Per report from Marc Schablewski. Back-patch to 9.3 which is where the rule printing behavior changed. The dangling-variable case is broken all the way back, but that's not what his complaint is about. |
||
---|---|---|
.. | ||
Makefile | ||
README | ||
bitmapset.c | ||
copyfuncs.c | ||
equalfuncs.c | ||
list.c | ||
makefuncs.c | ||
nodeFuncs.c | ||
nodes.c | ||
outfuncs.c | ||
params.c | ||
print.c | ||
read.c | ||
readfuncs.c | ||
tidbitmap.c | ||
value.c |
README
src/backend/nodes/README Node Structures =============== Andrew Yu (11/94) Introduction ------------ The current node structures are plain old C structures. "Inheritance" is achieved by convention. No additional functions will be generated. Functions that manipulate node structures reside in this directory. FILES IN THIS DIRECTORY (src/backend/nodes/) General-purpose node manipulation functions: copyfuncs.c - copy a node tree equalfuncs.c - compare two node trees outfuncs.c - convert a node tree to text representation readfuncs.c - convert text representation back to a node tree makefuncs.c - creator functions for some common node types nodeFuncs.c - some other general-purpose manipulation functions Specialized manipulation functions: bitmapset.c - Bitmapset support list.c - generic list support params.c - Param support tidbitmap.c - TIDBitmap support value.c - support for Value nodes FILES IN src/include/nodes/ Node definitions: nodes.h - define node tags (NodeTag) primnodes.h - primitive nodes parsenodes.h - parse tree nodes plannodes.h - plan tree nodes relation.h - planner internal nodes execnodes.h - executor nodes memnodes.h - memory nodes pg_list.h - generic list Steps to Add a Node ------------------- Suppose you wanna define a node Foo: 1. Add a tag (T_Foo) to the enum NodeTag in nodes.h. (If you insert the tag in a way that moves the numbers associated with existing tags, you'll need to recompile the whole tree after doing this. It doesn't force initdb though, because the numbers never go to disk.) 2. Add the structure definition to the appropriate include/nodes/???.h file. If you intend to inherit from, say a Plan node, put Plan as the first field of your struct definition. 3. If you intend to use copyObject, equal, nodeToString or stringToNode, add an appropriate function to copyfuncs.c, equalfuncs.c, outfuncs.c and readfuncs.c accordingly. (Except for frequently used nodes, don't bother writing a creator function in makefuncs.c) The header comments in those files give general rules for whether you need to add support. 4. Add cases to the functions in nodeFuncs.c as needed. There are many other places you'll probably also need to teach about your new node type. Best bet is to grep for references to one or two similar existing node types to find all the places to touch. Historical Note --------------- Prior to the current simple C structure definitions, the Node structures used a pseudo-inheritance system which automatically generated creator and accessor functions. Since every node inherited from LispValue, the whole thing was a mess. Here's a little anecdote: LispValue definition -- class used to support lisp structures in C. This is here because we did not want to totally rewrite planner and executor code which depended on lisp structures when we ported postgres V1 from lisp to C. -cim 4/23/90