submake-catalog-headers:

$(MAKE) -C catalog distprep generated-header-symlinks

submake-nodes-headers:

$(MAKE) -C nodes distprep generated-header-symlinks

submake-utils-headers:

$(MAKE) -C utils distprep generated-header-symlinks

.PHONY: submake-catalog-headers submake-utils-headers

.PHONY: submake-catalog-headers submake-nodes-headers submake-utils-headers

.PHONY: generated-headers

generated-headers:$(top_builddir)/src/include/parser/gram.h$(top_builddir)/src/include/storage/lwlocknames.h submake-catalog-headers submake-utils-headers

generated-headers:$(top_builddir)/src/include/parser/gram.h$(top_builddir)/src/include/storage/lwlocknames.h submake-catalog-headers submake-nodes-headers submake-utils-headers

$(top_builddir)/src/include/parser/gram.h: parser/gram.h

prereqdir=`cd'$(dir $<)'>/dev/null&& pwd`&&\

$(MAKE) -C parsergram.c gram.h scan.c

$(MAKE) -C bootstrapbootparse.c bootscanner.c

$(MAKE) -C catalogdistprep

$(MAKE) -C nodesdistprep

$(MAKE) -C replicationrepl_gram.c repl_scanner.c syncrep_gram.c syncrep_scanner.c

$(MAKE) -C storage/lmgrlwlocknames.h lwlocknames.c

$(MAKE) -C utilsdistprep

maintainer-clean: distclean

$(MAKE) -C catalog$@

$(MAKE) -C nodes$@

$(MAKE) -C utils$@

rm -f bootstrap/bootparse.c\

bootstrap/bootscanner.c\

/node-support-stamp

/nodetags.h

/*funcs.funcs.c

/*funcs.switch.c

value.o

include$(top_srcdir)/src/backend/common.mk

node_headers =\

nodes/nodes.h\

nodes/execnodes.h\

nodes/plannodes.h\

nodes/primnodes.h\

nodes/pathnodes.h\

nodes/extensible.h\

nodes/parsenodes.h\

nodes/replnodes.h\

nodes/value.h\

commands/trigger.h\

commands/event_trigger.h\

foreign/fdwapi.h\

access/amapi.h\

access/tableam.h\

access/tsmapi.h\

utils/rel.h\

nodes/supportnodes.h\

executor/tuptable.h\

nodes/lockoptions.h\

access/sdir.h

all: distprep generated-header-symlinks

distprep: node-support-stamp

.PHONY: generated-header-symlinks

generated-header-symlinks:$(top_builddir)/src/include/nodes/header-stamp

node-support-stamp: gen_node_support.pl$(addprefix$(top_srcdir)/src/include/,$(node_headers))

touch$@

$(top_builddir)/src/include/nodes/header-stamp: node-support-stamp

prereqdir=`cd'$(dir $<)'>/dev/null&& pwd`&&\

cd'$(dir $@)'&&forfilein nodetags.h;do \

rm -f$$file&&$(LN_S)"$$prereqdir/$$file".;\

touch$@

copyfuncs.o: copyfuncs.c copyfuncs.funcs.c copyfuncs.switch.c | node-support-stamp

equalfuncs.o: equalfuncs.c equalfuncs.funcs.c equalfuncs.switch.c | node-support-stamp

outfuncs.o: outfuncs.c outfuncs.funcs.c outfuncs.switch.c | node-support-stamp

readfuncs.o: readfuncs.c readfuncs.funcs.c readfuncs.switch.c | node-support-stamp

maintainer-clean: clean

rm -f node-support-stamp$(addsuffix funcs.funcs.c,copy equal out read)$(addsuffix funcs.switch.c,copy equal out read) nodetags.h

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.

The node structures are plain old C structures with the first field

being of type NodeTag. "Inheritance" is achieved by convention:

the first field can alternatively be of another node type.

Utility functions for manipulating node structures reside in this

directory. Some support functions are automatically generated by the

gen_node_support.pl script, other functions are maintained manually.

To control the automatic generation of support functions, node types

and node fields can be annotated with pg_node_attr() specifications;

see further documentation in src/include/nodes/nodes.h.

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

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

(*) - Most functions in these files are generated by

gen_node_support.pl and #include'd there.

Specialized manipulation functions:

bitmapset.c- Bitmapset support

list.c- generic list support

FILES IN src/include/nodes/

Node definitions:

nodes.h- define node tags (NodeTag)

nodes.h- define node tags (NodeTag) (*)

primnodes.h- primitive nodes

parsenodes.h- parse tree nodes

pathnodes.h- path tree nodes and planner internal structures

memnodes.h- memory nodes

pg_list.h- generic list

(*) - Also #include's files generated by gen_node_support.pl.

Steps to Add a Node

-------------------

Suppose you want to 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.

1. 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

4. Add cases to the functions in nodeFuncs.c as needed. There are many

of your struct definition. (The T_Foo tag is created automatically.)

2. Check that the generated support functions in copyfuncs.funcs.c,

equalfuncs.funcs.c,outfuncs.funcs.c and readfuncs.funcs.c look

3. 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

(Except for frequently-created nodes, don't bother writing a creator

function in makefuncs.c.)

4. Consider testing your new code with COPY_PARSE_PLAN_TREES,

WRITE_READ_PARSE_PLAN_TREES, and RAW_EXPRESSION_COVERAGE_TEST to ensure

support has been added everywhere that it's necessary; see

pg_config_manual.h about these.

Adding a new node type moves the numbers associated with existing

tags, so you'll need to recompile the whole tree after doing this.

(--enable-depend usually helps.) It doesn't force initdb though,

because the numbers never go to disk. But altering or removing a node

type should usually be accompanied by an initdb-forcing catalog

version change, since the interpretation of serialized node trees

stored in system catalogs is affected by that. (If the node type

never appears in stored parse trees, as for example Plan nodes do not,

then a catversion change is not needed to change it.)

(newnode->fldname = from->fldname)

returnnewnode;

}

returnnewnode;

}

returnnewnode;

}

_copyA_Const(constA_Const*from)

returnnewnode;

}

_copyFuncCall(constFuncCall*from)

{

returnnewnode;

}

returnnewnode;

}

returnnewnode;

}

switch (nodeTag(from))

{

caseT_BitString:

retval=_copyBitString(from);

break;

retval=list_copy(from);

break;

caseT_ForeignKeyCacheInfo:

retval=_copyForeignKeyCacheInfo(from);

break;

default:

elog(ERROR,"unrecognized node type: %d", (int)nodeTag(from));