head 1.15; access; symbols Version_2_1:1.9 Version_2:1.7 C_Demo_1:1.6; locks; strict; comment @ * @; 1.15 date 92.07.01.05.09.28; author mer; state Exp; branches; next 1.14; 1.14 date 92.06.26.17.56.36; author mer; state Exp; branches; next 1.13; 1.13 date 92.02.18.17.39.18; author hong; state Exp; branches; next 1.12; 1.12 date 92.02.17.14.59.40; author hong; state Exp; branches; next 1.11; 1.11 date 91.08.08.15.35.14; author hong; state Exp; branches; next 1.10; 1.10 date 91.06.18.23.28.22; author cimarron; state Exp; branches; next 1.9; 1.9 date 90.08.17.08.52.46; author cimarron; state Exp; branches; next 1.8; 1.8 date 90.08.01.17.29.50; author choi; state Exp; branches; next 1.7; 1.7 date 89.10.20.14.32.35; author sp; state Version_2; branches; next 1.6; 1.6 date 89.09.05.17.09.27; author mao; state C_Demo_1; branches; next 1.5; 1.5 date 89.08.16.12.21.23; author goh; state Exp; branches; next 1.4; 1.4 date 89.08.01.16.29.51; author goh; state Exp; branches; next 1.3; 1.3 date 89.07.20.10.06.33; author ong; state Exp; branches; next 1.2; 1.2 date 89.07.20.08.55.50; author goh; state Exp; branches; next 1.1; 1.1 date 89.07.20.08.41.21; author goh; state Exp; branches; next ; desc @accessor functions and misc defns for parsetree @ 1.15 log @add some macros to help with new tlist formats @ text @/* ---------------------------------------------------------------- * FILE * parsetree.h * * DESCRIPTION * Routines to access various components and subcomponents of * parse trees. * * IDENTIFICATION * $Header: /private/mer/pg/src/lib/H/parser/RCS/parsetree.h,v 1.14 1992/06/26 17:56:36 mer Exp mer $ * ---------------------------------------------------------------- */ #ifndef PARSETREE_H #define PARSETREE_H /* include once only */ /* ---------------- * need pg_lisp.h for definitions of CAR(), etc. macros * ---------------- */ #include "nodes/pg_lisp.h" /* ---------------- * top level parse tree macros * * parse tree: * (root targetlist qual) * ---------------- */ #define parse_root(parse) CAR(parse) #define parse_targetlist(parse) CADR(parse) #define parse_qualification(parse) CADDR(parse) #define parse_parallel(parse) ((length(parse)<4)?LispNil:CAR(nthCdr(3,parse))) /* eliminate this when tcop/pquery.c is unlocked */ #define parse_tree_root(parse) parse_root(parse) /* ---------------- * root macros * * parse tree: * (root targetlist qual) * ^^^^ * parse root: * (numlevels cmdtype resrel rangetable priority ruleinfo nestdotinfo) * ---------------- */ #define root_numlevels(root) CInteger(CAR(root)) #define root_command_type_atom(root) CADR(root) #define root_command_type(root) ((int) CAtom(root_command_type_atom(root))) #define root_result_relation(root) CADDR(root) #define root_rangetable(root) CADDR(CDR(root)) #define root_priority(root) CADDR(CDR(CDR(root))) #define root_ruleinfo(root) CADDR(CDR(CDR(CDR(root)))) #define root_nestdotinfo(root) CADDR(CDR(CDR(CDR(CDR(root))))) #define root_uniqueflag(root) nth(6, root) #define root_sortclause(root) nth(7, root) /* ---------------- * result relation macros * * parse tree: * (root targetlist qual) * ^^^^ * parse root: * (numlevels cmdtype resrel rangetable priority ruleinfo nestdotinfo) * ^^^^^^ * ---------------- */ #define parse_tree_result_relation(parse_tree) \ root_result_relation(parse_root(parse_tree)) /* ---------------- * range table macros * * parse tree: * (root targetlist qual) * ^^^^ * parse root: * (numlevels cmdtype resrel rangetable priority ruleinfo nestdotinfo) * ^^^^^^^^^^ * range table: * (rtentry ...) * * rtentry: * note: this might be wrong, I don't understand how * rt_time / rt_archive_time work together. anyways it * looks something like: * * (relname ? relid timestuff flags rulelocks) * or (new/cur relname relid timestuff flags rulelocks) * * someone who knows more should correct this -cim 6/9/91 * ---------------- */ #define parse_tree_range_table(parse_tree) \ root_rangetable(parse_root(parse_tree)) /* .. GetIDFromRangeTbl, InitPlan, print_rtentries, print_subplan * .. print_var */ #define rt_relname(rt_entry) \ ((!strcmp(CString(CAR(rt_entry)),"*CURRENT*") ||\ !strcmp(CString(CAR(rt_entry)),"*NEW*")) ? CAR(rt_entry) : \ CADR(rt_entry)) /* .. ExecutePlan, best-or-subclause-index, create_index_path * .. exec-set-lock, in-line-lambda%598040865, index-info, index-innerjoin * .. parameterize, plan-union-queries, plan-union-query * .. preprocess-targetlist, print_rtentries, print_var, relation-info * .. translate-relid, write-decorate */ #define rt_relid(rt_entry) CADDR(rt_entry) /* .. ExecBeginScan, ExecCreatR, ExecOpenR, InitPlan * .. in-line-lambda%598040864, print_rtentries */ #define rt_time(rt_entry) CADDR(CDR(rt_entry)) /*.. in-line-lambda%598040864 */ #define rt_archive_time(rt_entry) \ ( nth(5, rt_entry) ? rt_time (rt_entry) : LispNil ) /* .. in-line-lambda%598040866, plan-union-queries, print_rtentries */ #define rt_flags(rt_entry) CADDR(CDR(CDR(rt_entry))) /* .. add-read-locks, exec-make-intermediate-locks, exec-set-lock *.. make-parameterized-plans, make-rule-locks, print_rtentries * .. write-decorate */ #define rt_rulelocks(rt_entry) CADDR(CDR(CDR(CDR(rt_entry)))) /* * rt_fetch * rt_store * * Access and (destructively) replace rangetable entries. * * .. ExecCreatR, ExecOpenR, ExecutePlan, InitPlan, add-read-locks * .. exec-set-lock, plan-union-queries, write-decorate */ #define rt_fetch(rangetable_index, rangetable) \ nth((rangetable_index)-1, rangetable) #define rt_store(rangetable_index, rangetable, rt) \ nth((rangetable_index)-1, rangetable) = rt /* * getrelid * getrelname * * Given the range index of a relation, return the corresponding * relation id or relation name. * * .. best_or_subclause_index, create_index_path, index_info * .. index_innerjoin, parameterize, preprocess_targetlist, print_var * .. relation_info, translate_relid, write_decorate */ #define getrelid(rangeindex,rangetable) \ rt_relid(nth((rangeindex)-1, rangetable)) /* .. GetIDFromRangeTbl, print_subplan, print_var */ #define getrelname(rangeindex, rangetable) \ rt_relname(nth((rangeindex)-1, rangetable)) /* ---------------- * rule info macros * * parse tree: * (root targetlist qual) * ^^^^ * parse root: * (numlevels cmdtype resrel rangetable priority ruleinfo nestdotinfo) * ^^^^^^^^ * ruleinfo: * (ruleid ruletag) * ---------------- */ /* .. exec-make-intermediate-locks, exec-set-lock */ #define ruleinfo_ruleid(ruleinfo) CAR(ruleinfo) /* .. exec_make_intermediate_locks, exec_set_lock, make_rule_locks * .. process_rules */ #define ruleinfo_ruletag(ruleinfo) CADR(ruleinfo) /* ---------------- * target list macros * * parse tree: * (root targetlist qual) * ^^^^^^^^^^ * target list: * (tl_entry ...) * * tl_entry: * (resdom expr) * ---------------- */ /* .. MakeAttlist, compute-attribute-width, copy-vars, flatten-tlist-vars * .. in-line-lambda%598040855, new-result-tlist, new-unsorted-tlist * .. print_tlistentry, relation-sortkeys, replace-resultvar-refs * .. set-join-tlist-references, sort-level-result * .. targetlist-resdom-numbers, tlist-member, tlist-temp-references */ #define tl_resdom(tl_entry) CAR(tl_entry) #define tl_node(tl_entry) CAR(tl_entry) #define tl_is_resdom(tl_entry) IsA(CAR(tl_entry),Resdom) /* .. MakeAttlist, copy-vars, find-tlist-read-vars, flatten-tlist * .. flatten-tlist-vars, flatten-tlistentry, in-line-lambda%598041218 * .. in-line-lambda%598041219, in-line-lambda%598041221 * .. initialize-targetlist, matching_tlvar, new-join-tlist * .. new-level-tlist, new-result-tlist, print_tlistentry * .. relation-sortkeys, set-join-tlist-references, tlist-temp-references * .. update-relations */ #define tl_expr(tl_entry) CADR(tl_entry) /* ---------------------------------------------------------------- * NEW STUFF * ---------------------------------------------------------------- */ /* typedef struct parse_struct { LispValue root; LispValue targetlist; LispValue qualification; } parse; /* XXX constr name : new_parse */ /* typedef struct root_struct { LispValue levels; LispValue command_type ; LispValue result_relation ; LispValue rangetable ; LispValue priority; LispValue ruleinfo; } root; /* XXX constr name: new_root */ /* typedef struct resultrelation { LispValue id; LispValue archive_level; } result_relation; */ /* typedef struct rule_info { LispValue id; LispValue tag; } ruleinfo; */ /* typedef struct rt_struct { LispValue relation_name; LispValue relation_id; LispValue time; LispValue archival_p ; } rt; */ /* typedef struct tl_struct { LispValue resdom ; LispValue expr ; } tl; */ #endif PARSETREE_H @ 1.14 log @add a target list macro (tl_node) not always resdoms now @ text @d10 1 a10 1 * $Header: /private/mer/pg/src/lib/H/parser/RCS/parsetree.h,v 1.13 1992/02/18 17:39:18 hong Exp mer $ a209 1 d211 1 @ 1.13 log @added macros to manipulate parse tree root @ text @d10 1 a10 1 * $Header: RCS/parsetree.h,v 1.12 92/02/17 14:59:40 hong Exp $ d210 2 @ 1.12 log @fixed rt_store() macro @ text @d10 1 a10 1 * $Header: RCS/parsetree.h,v 1.11 91/08/08 15:35:14 hong Exp $ d56 2 @ 1.11 log @added a macro for parsetree manipulation @ text @d10 1 a10 1 * $Header: RCS/parsetree.h,v 1.10 91/06/18 23:28:22 cimarron Exp Locker: hong $ d146 1 a146 1 setf(nth((rangetable_index)-1, rangetable), rt) @ 1.10 log @reorganized executor to use tuple table properly for nested dot stuff @ text @d10 1 a10 1 * $Header$ d33 1 @ 1.9 log @added pathnames to #include statements @ text @d1 3 a3 2 /* * parsetree.l d5 3 a7 1 * Routines to access various components and subcomponents of parse trees. d9 3 a11 2 * XXX These will replaced with defstruct macros in Version 2. * $Header: RCS/parsetree.h,v 1.8 90/08/01 17:29:50 choi Exp Locker: cimarron $ d14 2 d17 4 a20 1 d23 7 a29 1 d33 14 d48 2 a49 1 #define root_command_type(root) ((int)CAtom(CADR(root))) d51 4 a54 2 /* DefineRule() uses that... */ #define root_command_type_atom(root) CADR(root) d56 13 d70 25 a94 5 /* .. subst-rangetable */ #define root_rangetable(root) CADDR(CDR(root)) #define root_priority(root) CADDR(CDR(CDR(root))) #define root_ruleinfo(root) CADDR(CDR(CDR(CDR(root)))) #define resultrelation_name(resultrelation) if (lisp (resultrelation)) nth (0, resultrelation) a95 3 #define resultrelation_archive(resultrelation) if (lisp (resultrelation)) nth (1, resultrelation) a103 2 a117 1 d119 2 a120 2 #define rt_archive_time(rt_entry) ( nth(5, rt_entry) ? \ rt_time (rt_entry) : LispNil ) a124 1 d132 7 a138 1 /* .. ExecCreatR, ExecOpenR, ExecutePlan, InitPlan, add-read-locks d140 3 a142 4 #define rt_fetch(inhrelid,rangetable) nth ( inhrelid -1, rangetable) #define rt_store(inhrelid,rangetable,rt_entry) \ setf (nth (inhrelid -1,rangetable) ,rt_entry) */ d144 56 d219 1 a219 10 /* .. exec-make-intermediate-locks, exec-set-lock */ #define ruleinfo_ruleid(ruleinfo) CAR(ruleinfo) /* .. exec_make_intermediate_locks, exec_set_lock, make_rule_locks * .. process_rules */ #define ruleinfo_ruletag(ruleinfo) CADR(ruleinfo) /* d221 1 d270 2 a271 40 /* * rt_archival_time * * Return the archival time range for a rangetable entry. */ #define rt_archival_time(rt) if (rt_archival_p(rt)) rt_time(rt) /* * rt_fetch * rt_store * * Access and (destructively) replace rangetable entries. */ #define rt_fetch(rangetable_index,rangetable) nth (rangetable_index -1, \ rangetable) #define rt_store(rangetable_index,rangetable, rt) \ setf (nth (rangetable_index - 1,rangetable) ,rt) /* * getrelid * getrelname * * Given the range index of a relation, return the corresponding * relation id or relation name. */ /* .. best_or_subclause_index, create_index_path, index_info * .. index_innerjoin, parameterize, preprocess_targetlist, print_var * .. relation_info, translate_relid, write_decorate */ #define getrelid(rangeindex,rangetable) rt_relid ( (nth ((rangeindex -1), rangetable))) /* .. GetIDFromRangeTbl, print_subplan, print_var */ #define getrelname(rangeindex,rangetable) rt_relname( nth( rangeindex -1, rangetable)) @ 1.8 log @rt_XXX macros changed so that StripRangeTable() is not necessary @ text @d7 1 a7 1 * $Header: RCS/parsetree.h,v 1.7 89/10/20 14:32:35 sp Version_2 Locker: choi $ d12 1 a12 1 #include "pg_lisp.h" @ 1.7 log @added definiton of root_command_type_atom(), used by RuleDefine() @ text @d7 1 a7 1 * $Header: RCS/parsetree.h,v 1.6 89/09/05 17:09:27 mao C_Demo_1 $ d37 4 a40 1 #define rt_relname(rt_entry) CAR(rt_entry) d43 1 d50 1 a50 1 #define rt_relid(rt_entry) CADR(rt_entry) d56 1 a56 1 #define rt_time(rt_entry) CADDR(rt_entry) d58 1 d60 1 a60 1 #define rt_archive_time(rt_entry) ( (CADDDR(rt_entry)) ? \ d64 1 a64 1 #define rt_flags(rt_entry) CADDR(CDR(rt_entry)) d66 1 d71 1 a71 1 #define rt_rulelocks(rt_entry) CADDR(CDR(CDR(rt_entry))) @ 1.6 log @Working version of C-only demo @ text @d7 1 a7 1 * $Header: RCS/parsetree.h,v 1.5 89/08/16 12:21:23 goh Exp Locker: goh $ d21 3 @ 1.5 log @fixed the last line (no closing paren) as reported by mike O. @ text @d7 1 a7 1 * $Header: /n/postgres/a/postgres/goh/postgres/src/lib/H/RCS/parsetree.h,v 1.4 89/08/01 16:29:51 goh Exp $ @ 1.4 log @*** empty log message *** @ text @d7 1 a7 1 * $Header: /usr6/postgres/goh/newpost/src/lib/H/RCS/parsetree.h,v 1.3 89/07/20 10:06:33 ong Exp $ d188 1 a188 1 #define getrelname(rangeindex,rangetable) rt_relname( nth( rangeindex -1, rangetable) @ 1.3 log @changed root_commandtype to root_command_type @ text @d7 1 a7 1 * $Header: parsetree.h,v 1.2 89/07/20 08:55:50 goh Locked $ d15 6 a20 6 #define parse_root(parse) CAR(parse) #define parse_targetlist(parse) CADR(parse) #define parse_qualification(parse) CADDR(parse) #define root_numlevels(root) CAR(root) #define root_command_type(root) CADR(root) #define root_result_relation(root) CADDR(root) d89 1 a89 2 /* #define tl_expr(tl_entry) CADR(tl_entry) extern LispValue tl_expr(); d184 1 a184 1 #define getrelid(rangeindex,rangetable) rt_relid ( (nth (rangeindex -1), rangetable)) @ 1.2 log @changed "nth"s to CA...R's so that we can use "=" to do setf's @ text @d7 1 a7 1 * $Header: parsetree.h,v 1.1 89/07/20 08:41:21 goh Locked $ d19 2 a20 2 #define root_commandtype(root) CADR(root) #define root_resultrelation(root) CADDR(root) d121 1 @ 1.1 log @Initial revision @ text @d7 1 a7 1 * $Header:$ d15 6 a20 6 #define parse_root(parse) nth (0, parse) #define parse_targetlist(parse) nth (1, parse) #define parse_qualification(parse) nth (2, parse) #define root_numlevels(root) nth (0, root) #define root_commandtype(root) nth (1, root) #define root_resultrelation(root) nth (2, root) d23 3 a25 3 #define root_rangetable(root) nth (3, root) #define root_priority(root) nth (4, root) #define root_ruleinfo(root) nth (5, root) d34 1 a34 1 #define rt_relname(rt_entry) nth (0, rt_entry) d52 2 a53 1 #define rt_archive_time(rt_entry) if (nth (3, rt_entry)) rt_time (rt_entry) a56 1 /* nth (3, rt_entry) */ a57 1 d62 1 a62 1 #define rt_rulelocks(rt_entry) nth (4, rt_entry) d68 1 a68 1 #define rt_store(inhrelid,rangetable,rt_entry) d78 1 a78 1 #define tl_resdom(tl_entry) nth (0, tl_entry) d89 1 a89 1 /* #define tl_expr(tl_entry) nth (1, tl_entry) */ d93 1 a93 1 #define ruleinfo_ruleid(ruleinfo) nth(0, ruleinfo) d98 1 a98 1 #define ruleinfo_ruletag(ruleinfo) nth (1, ruleinfo) @