head 1.37; access; symbols Version_2_1:1.34 Version_2:1.27 C_Demo_1:1.6; locks; strict; comment @ * @; 1.37 date 92.07.24.01.54.21; author mer; state Exp; branches; next 1.36; 1.36 date 91.11.14.11.07.31; author glass; state Exp; branches; next 1.35; 1.35 date 91.08.15.17.45.09; author caetta; state Exp; branches; next 1.34; 1.34 date 90.10.01.07.46.08; author cimarron; state Exp; branches; next 1.33; 1.33 date 90.10.01.01.15.19; author cimarron; state Exp; branches; next 1.32; 1.32 date 90.08.18.15.29.51; author cimarron; state Exp; branches; next 1.31; 1.31 date 90.08.17.13.56.52; author hong; state Exp; branches; next 1.30; 1.30 date 90.08.13.20.58.21; author hong; state Exp; branches; next 1.29; 1.29 date 90.08.08.08.21.57; author cimarron; state Exp; branches; next 1.28; 1.28 date 90.08.01.14.35.48; author sp; state Exp; branches; next 1.27; 1.27 date 90.07.02.20.30.19; author cimarron; state Version_2; branches; next 1.26; 1.26 date 90.06.07.18.20.18; author cimarron; state Exp; branches; next 1.25; 1.25 date 90.06.06.20.37.54; author kemnitz; state Exp; branches; next 1.24; 1.24 date 90.03.31.18.54.18; author cimarron; state Exp; branches; next 1.23; 1.23 date 90.03.13.11.57.52; author cimarron; state Exp; branches; next 1.22; 1.22 date 90.03.13.08.01.47; author cimarron; state Exp; branches; next 1.21; 1.21 date 90.03.12.16.26.06; author cimarron; state Exp; branches; next 1.20; 1.20 date 90.03.01.15.39.42; author cimarron; state Exp; branches; next 1.19; 1.19 date 90.02.23.19.45.32; author cimarron; state Exp; branches; next 1.18; 1.18 date 90.02.01.13.51.37; author cimarron; state Exp; branches; next 1.17; 1.17 date 90.01.31.17.38.25; author cimarron; state Exp; branches; next 1.16; 1.16 date 90.01.30.23.25.57; author sp; state Exp; branches; next 1.15; 1.15 date 90.01.30.16.47.09; author jamesb; state Exp; branches; next 1.14; 1.14 date 89.11.02.18.05.35; author cimarron; state Exp; branches; next 1.13; 1.13 date 89.10.31.12.20.14; author mao; state Exp; branches; next 1.12; 1.12 date 89.10.20.19.52.15; author cimarron; state Exp; branches; next 1.11; 1.11 date 89.10.17.13.44.50; author cimarron; state Exp; branches; next 1.10; 1.10 date 89.10.12.16.44.21; author cimarron; state Exp; branches; next 1.9; 1.9 date 89.10.05.16.59.15; author cimarron; state Exp; branches; next 1.8; 1.8 date 89.09.18.20.25.22; author cimarron; state Exp; branches; next 1.7; 1.7 date 89.09.18.08.19.48; author cimarron; state Exp; branches; next 1.6; 1.6 date 89.09.05.17.05.52; author mao; state C_Demo_1; branches; next 1.5; 1.5 date 89.08.31.14.09.52; author cimarron; state Exp; branches; next 1.4; 1.4 date 89.08.30.12.59.48; author cimarron; state Exp; branches; next 1.3; 1.3 date 89.08.29.22.38.03; author cimarron; state Exp; branches; next 1.2; 1.2 date 89.08.24.17.04.21; author cimarron; state Exp; branches; next 1.1; 1.1 date 89.08.09.18.01.07; author cimarron; state Exp; branches; next ; desc @Executor support header file. Was src/executor/einternal.h but these definitions are too widely needed.. Eventually this file should be reorganized -cim @ 1.37 log @don't need both string.h and strings.h @ text @/* ---------------------------------------------------------------- * FILE * executor.h * * DESCRIPTION * support for the POSTGRES executor module * * $Header: /private/mer/pg/src/lib/H/executor/RCS/executor.h,v 1.36 1991/11/14 11:07:31 glass Exp mer $" * ---------------------------------------------------------------- */ #ifndef ExecutorIncluded #define ExecutorIncluded /* ---------------------------------------------------------------- * #includes * ---------------------------------------------------------------- */ #include #include #include "tmp/postgres.h" #include "nodes/pg_lisp.h" /* ---------------- * executor debugging definitions are kept in a separate file * so people can customize what debugging they want to see and not * have this information clobbered every time a new version of * executor.h is checked in -cim 10/26/89 * ---------------- */ #include "executor/execdebug.h" #include "access/ftup.h" #include "access/heapam.h" #include "access/htup.h" #include "access/istrat.h" #include "access/itup.h" #include "access/skey.h" #include "access/tqual.h" #include "catalog/catname.h" #include "catalog/syscache.h" #include "executor/execdefs.h" #include "executor/recursion.h" #include "executor/recursion_a.h" #include "executor/tuptable.h" #include "parser/parse.h" #include "storage/buf.h" #include "tmp/miscadmin.h" #include "tmp/simplelists.h" #include "utils/fmgr.h" #include "utils/log.h" #include "utils/mcxt.h" #include "utils/memutils.h" #include "utils/rel.h" #include "catalog/pg_index.h" #include "catalog/pg_proc.h" #include "catalog/pg_type.h" #include "catalog/pg_aggregate.h" #include "access/printtup.h" #include "nodes/primnodes.h" #include "nodes/plannodes.h" #include "nodes/execnodes.h" #include "parser/parsetree.h" #include "rules/prs2.h" #include "rules/prs2stub.h" #include "tcop/dest.h" #include "storage/smgr.h" /* ---------------- * .h files made from running pgdecs over generated .c files in obj/lib/C * ---------------- */ #include "nodes/primnodes.a.h" #include "nodes/plannodes.a.h" #include "nodes/execnodes.a.h" #include "executor/execshmem.h" #include "executor/execmisc.h" /* * public executor functions * * XXX reorganize me. */ #include "executor/externs.h" /* ---------------------------------------------------------------- * the end * ---------------------------------------------------------------- */ #endif ExecutorIncluded @ 1.36 log @fixes due to prototypes @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.35 91/08/15 17:45:09 caetta Exp Locker: glass $" a19 1 #include @ 1.35 log @more aggregates...ho, hum... @ text @d8 1 a8 1 * $Header: lib/H/executor/RCS/executor.h,v 1.34 90/10/01 07:46:08 cimarron Exp Locker: caetta $" d71 2 d82 1 d89 1 a89 29 #include "executor/aggregate.h" #include "executor/x_append.h" #include "executor/x_debug.h" #include "executor/x_endnode.h" #include "executor/x_eutils.h" #include "executor/x_execam.h" #include "executor/x_execfmgr.h" #include "executor/x_execinit.h" #include "executor/x_execmain.h" #include "executor/x_execmmgr.h" #include "executor/x_execstats.h" #include "executor/x_exist.h" #include "executor/hashjoin.h" #include "executor/x_indexscan.h" #include "executor/x_initnode.h" #include "executor/x_material.h" #include "executor/x_mergejoin.h" #include "executor/x_nestloop.h" #include "executor/x_parallel.h" #include "executor/x_procnode.h" #include "executor/x_qual.h" #include "executor/recursive.h" #include "executor/x_result.h" #include "executor/x_scan.h" #include "executor/x_seqscan.h" #include "executor/x_sort.h" #include "executor/x_tuples.h" #include "executor/x_unique.h" #include "executor/x_xdebug.h" @ 1.34 log @converted everything to use the new TupleTableSlot abstractions @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.33 90/10/01 01:15:19 cimarron Exp $" d61 1 d86 1 @ 1.33 log @*** empty log message *** @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.32 90/08/18 15:29:51 cimarron Exp Locker: cimarron $" @ 1.32 log @moved lots of stuff to execmisc.h @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.30 90/08/13 20:58:21 hong Exp Locker: hong $" a98 1 #include "executor/x_main.h" @ 1.31 log @modification for parallel query processing @ text @d21 1 d23 1 a23 1 #include "tmp/c.h" d35 3 d39 1 d41 1 a41 2 #include "tmp/align.h" #include "storage/buf.h" d43 1 a43 1 #include "tmp/clib.h" d45 2 d48 4 a52 4 #include "access/ftup.h" #include "access/heapam.h" #include "access/htup.h" #include "access/itup.h" d55 1 a55 4 #include "parser/parse.h" #include "tmp/pmod.h" #include "executor/recursion_a.h" #include "executor/recursion.h" a56 4 #include "tmp/simplelists.h" #include "strings.h" #include "catalog/syscache.h" #include "access/tqual.h" d79 1 a79 222 /* ---------------------------------------------------------------- * executor shared memory segment header definition * * After the executor's shared memory segment is allocated * the initial bytes are initialized to contain 2 pointers. * the first pointer points to the "low" end of the available * area and the second points to the "high" end. * * When part of the shared memory is reserved by a call to * ExecSMAlloc(), the "low" pointer is advanced to point * beyond the newly allocated area to the available free * area. If an allocation would cause "low" to exceed "high", * then the allocation fails and an error occurrs. * * Note: Since no heap management is done, there is no * provision for freeing shared memory allocated via ExecSMAlloc() * other than wipeing out the entire space with ExecSMClean(). * ---------------------------------------------------------------- */ typedef struct ExecSMHeaderData { Pointer low; /* pointer to low water mark */ Pointer high; /* pointer to high water mark */ } ExecSMHeaderData; typedef ExecSMHeaderData *ExecSMHeader; /* ---------------------------------------------------------------- * #define macros * XXX some of the macro definitions are copied to * tcop/pfrag.c in order to break up this catch-all * .h file. * ---------------------------------------------------------------- */ /* ---------------- * the reverse alignment macros are for use with the executor * shared memory allocator's ExecSMHighAlloc routine which * allocates memory from the high-area "down" to the low-area. * In this case we need alignment in the "other" direction than * provided by SHORTALIGN and LONGALIGN * ---------------- */ #define REVERSESHORTALIGN(LEN)\ (((long)(LEN)) & ~01) #ifndef sun #define REVERSELONGALIGN(LEN)\ (((long)(LEN)) & ~03) #else #define REVERSELONGALIGN(LEN) REVERSESHORTALIGN(LEN) #endif /* ---------------- * miscellany * ---------------- */ #define ExecCNull(Cptr) (Cptr == NULL) #define ExecCTrue(bval) (bval != 0) #define ExecCFalse(bval) (bval == 0) #define ExecCNot(bval) \ (ExecCFalse(bval) ? EXEC_C_TRUE : EXEC_C_FALSE) #define ExecRevDir(direction) (direction - 1) /* ---------------- * query descriptor accessors * ---------------- */ #define GetOperation(queryDesc) (List) CAR(queryDesc) #define QdGetParseTree(queryDesc) (List) CAR(CDR(queryDesc)) #define QdGetPlan(queryDesc) (Plan) CAR(CDR(CDR(queryDesc))) #define QdGetState(queryDesc) (EState) CAR(CDR(CDR(CDR(queryDesc)))) #define QdGetFeature(queryDesc) (List) CAR(CDR(CDR(CDR(CDR(queryDesc))))) #define QdSetState(queryDesc, s) \ (CAR(CDR(CDR(CDR(queryDesc)))) = (List) s) #define QdSetFeature(queryDesc, f) \ (CAR(CDR(CDR(CDR(CDR(queryDesc))))) = (List) f) /* ---------------- * query feature accessors * ---------------- */ #define FeatureGetCommand(feature) CAR(feature) #define FeatureGetCount(feature) CAR(CDR(feature)) #define QdGetCommand(queryDesc) FeatureGetCommand(QdGetFeature(queryDesc)) #define QdGetCount(queryDesc) FeatureGetCount(QdGetFeature(queryDesc)) /* ---------------- * parse tree accessors * ---------------- */ #define parse_tree_root(parse_tree) \ CAR(parse_tree) #define parse_tree_target_list(parse_tree) \ CAR(CDR(parse_tree)) #define parse_tree_qualification(parse_tree) \ CAR(CDR(CDR(parse_tree))) #define parse_tree_root_num_levels(parse_tree_root) \ CAR(parse_tree_root) #define parse_tree_root_command_type(parse_tree_root) \ CAR(CDR(parse_tree_root)) #define parse_tree_root_result_relation(parse_tree_root) \ CAR(CDR(CDR(parse_tree_root))) #define parse_tree_root_range_table(parse_tree_root) \ CAR(CDR(CDR(CDR(parse_tree_root)))) #define parse_tree_root_priority(parse_tree_root) \ CAR(CDR(CDR(CDR(CDR(parse_tree_root))))) #define parse_tree_root_rule_info(parse_tree_root) \ CAR(CDR(CDR(CDR(CDR(CDR((parse_tree_root))))))) #define parse_tree_range_table(parse_tree) \ parse_tree_root_range_table(parse_tree_root(parse_tree)) #define parse_tree_result_relation(parse_tree) \ parse_tree_root_result_relation(parse_tree_root(parse_tree)) /* ---------------- * macros to determine node types * ---------------- */ #define ExecIsRoot(node) LispNil #define ExecIsResult(node) IsA(node,Result) #define ExecIsExistential(node) IsA(node,Existential) #define ExecIsAppend(node) IsA(node,Append) #define ExecIsParallel(node) IsA(node,Parallel) #define ExecIsRecursive(node) IsA(node,Recursive) #define ExecIsNestLoop(node) IsA(node,NestLoop) #define ExecIsMergeJoin(node) IsA(node,MergeJoin) #define ExecIsHashJoin(node) IsA(node,HashJoin) #define ExecIsSeqScan(node) IsA(node,SeqScan) #define ExecIsIndexScan(node) IsA(node,IndexScan) #define ExecIsMaterial(node) IsA(node,Material) #define ExecIsSort(node) IsA(node,Sort) #define ExecIsUnique(node) IsA(node,Unique) #define ExecIsHash(node) IsA(node,Hash) #define ExecIsScanTemp(node) IsA(node,ScanTemp) /* ---------------------------------------------------------------- * debugging structures * ---------------------------------------------------------------- */ /* ---------------- * ExecAllocDebugData is used by ExecAllocDebug() and ExecFreeDebug() * to keep track of memory allocation. * ---------------- */ typedef struct ExecAllocDebugData { Pointer pointer; Size size; String routine; String file; int line; SLNode Link; } ExecAllocDebugData; /* ---------------- * DebugVariable is a structure holding a string * specifying the name of a debugging variable and * a pointer specifying the address of the object * holding the variable's value. This is used only * in debug.c * ---------------- */ typedef struct DebugVariable { String debug_variable; Pointer debug_address; } DebugVariable; typedef DebugVariable *DebugVariablePtr; /* ---------------------------------------------------------------- * externs * ---------------------------------------------------------------- */ /* * miscellany */ extern Relation amopen(); extern Relation AMopen(); extern Relation amopenr(); extern HeapScanDesc ambeginscan(); extern HeapTuple amgetnext(); extern char * amgetattr(); extern RuleLock aminsert(); extern RuleLock amdelete(); extern RuleLock amreplace(); extern GeneralInsertIndexResult AMinsert(); extern GeneralRetrieveIndexResult AMgettuple(); extern HeapTuple RelationGetHeapTupleByItemPointer(); extern Pointer get_cs_ResultTupleSlot(); extern Pointer get_css_ScanTupleSlot(); extern bool ExecIsInitialized; extern Const ConstTrue; extern Const ConstFalse; extern SLList ExecAllocDebugList; extern int _debug_hook_id_; extern HookNode _debug_hooks_[]; @ 1.30 log @to reduce levels of include nestings @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.29 90/08/08 08:21:57 cimarron Exp Locker: hong $" d22 2 a23 2 #include "c.h" #include "pg_lisp.h" d32 1 a32 1 #include "execdebug.h" d34 6 a39 6 #include "istrat.h" #include "skey.h" #include "align.h" #include "buf.h" #include "catname.h" #include "clib.h" d42 13 a54 13 #include "fmgr.h" #include "ftup.h" #include "heapam.h" #include "htup.h" #include "itup.h" #include "log.h" #include "mcxt.h" #include "parse.h" #include "pmod.h" #include "recursion_a.h" #include "recursion.h" #include "rel.h" #include "simplelists.h" d56 2 a57 2 #include "syscache.h" #include "tqual.h" d63 5 a67 5 #include "printtup.h" #include "primnodes.h" #include "plannodes.h" #include "execnodes.h" #include "parsetree.h" d69 2 a70 2 #include "prs2.h" #include "prs2stub.h" d76 3 a78 3 #include "primnodes.a.h" #include "plannodes.a.h" #include "execnodes.a.h" a107 26 * parallel fragment definition * * The parallel optimiser returns a FragmentInfo structure * which contains an array of fragment structures which * the executor executes in parallel. The Fragment structure * contains a pair of pointers - one to a current node in * the query plan and one to a replacement parallel node. * * ExecuteFragements() executes the fragment plans and replaces * the corresponding nodes in the query plan with materialized * results. * ---------------------------------------------------------------- */ typedef struct FragmentData { Plan current; /* pointer to node in query plan */ Plan replacement; /* pointer to parallel replacement node */ } FragmentData; typedef FragmentData *Fragment; typedef struct FragmentInfo { Fragment fragments; /* fragments to execute in parallel */ int numFragments; /* size of fragements array */ } FragmentInfo; /* ---------------------------------------------------------------- d109 3 d230 1 @ 1.29 log @reorganized some header files @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.28 90/08/01 14:35:48 sp Exp Locker: cimarron $" d34 1 @ 1.28 log @Include "prs2.h" and "prs2stub.h" @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.27 90/07/02 20:30:19 cimarron Exp $" a34 1 #include "anum.h" a36 1 #include "cat.h" a52 1 #include "rproc.h" d57 4 @ 1.27 log @reorganized headers and extern include files. @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.26 90/06/07 18:20:18 cimarron Exp $" d66 3 @ 1.26 log @made changes to simplify header include files @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.24 90/03/31 18:54:18 cimarron Exp $" d25 9 d41 2 a42 1 #include "execdefs.h" a67 9 * executor debugging definitions are kept in a separate file * so people can customize what debugging they want to see and not * have this information clobbered every time a new version of * executor.h is checked in -cim 10/26/89 * ---------------- */ #include "execdebug.h" /* ---------------- d307 3 d321 2 d324 11 a334 11 #include "executor/append.h" #include "executor/debug.h" #include "executor/endnode.h" #include "executor/eutils.h" #include "executor/execam.h" #include "executor/execfmgr.h" #include "executor/execinit.h" #include "executor/execmain.h" #include "executor/execmmgr.h" #include "executor/execstats.h" #include "executor/exist.h" d336 9 a344 9 #include "executor/indexscan.h" #include "executor/initnode.h" #include "executor/main.h" #include "executor/material.h" #include "executor/mergejoin.h" #include "executor/nestloop.h" #include "executor/parallel.h" #include "executor/procnode.h" #include "executor/qual.h" d346 7 a352 7 #include "executor/result.h" #include "executor/scan.h" #include "executor/seqscan.h" #include "executor/sort.h" #include "executor/tuples.h" #include "executor/unique.h" #include "executor/xdebug.h" @ 1.25 log @Added sparc stuff for LONGALIGH @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.24 90/03/31 18:54:18 cimarron Exp Locker: kemnitz $" d25 1 a25 1 #include "access.h" d29 1 a29 1 #include "catalog.h" a49 1 #include "tuple.h" d143 1 a143 3 #if defined(sun) && ! defined(sparc) #define REVERSELONGALIGN(LEN) REVERSESHORTALIGN(LEN) #else d146 2 @ 1.24 log @moved #defines shared by executor and tcop to other places (execdefs.h) @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.23 90/03/13 11:57:52 cimarron Exp $" d144 3 a146 1 #ifndef sun a148 2 #else #define REVERSELONGALIGN(LEN) REVERSESHORTALIGN(LEN) @ 1.23 log @fixed a structure defn problem @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.22 90/03/13 08:01:47 cimarron Exp $" d32 1 a126 73 /* ---------------------------------------------------------------- * constant #defines * ---------------------------------------------------------------- */ /* ---------------- * memory management defines * ---------------- */ #define M_STATIC 0 /* Static allocation mode */ #define M_DYNAMIC 1 /* Dynamic allocation mode */ /* ---------------- * executor scan direction definitions * ---------------- */ #define EXEC_FRWD 1 /* Scan forward */ #define EXEC_BKWD -1 /* Scan backward */ /* ---------------- * ExecutePlan() tuplecount definitions * ---------------- */ #define ALL_TUPLES 0 /* return all tuples */ #define ONE_TUPLE 1 /* return only one tuple */ /* ---------------- * boolean value returned by C routines * ---------------- */ #define EXEC_C_TRUE 1 /* C language boolean truth constant */ #define EXEC_C_FALSE 0 /* C language boolean false constant */ /* ---------------- * constants used by ExecMain * ---------------- */ #define EXEC_START 1 #define EXEC_END 2 #define EXEC_DUMP 3 #define EXEC_FOR 4 #define EXEC_BACK 5 #define EXEC_FDEBUG 6 #define EXEC_BDEBUG 7 #define EXEC_DEBUG 8 #define EXEC_RETONE 9 #define EXEC_RESULT 10 #define EXEC_INSERT_RULE 11 #define EXEC_DELETE_RULE 12 #define EXEC_DELETE_REINSERT_RULE 13 #define EXEC_MAKE_RULE_EARLY 14 #define EXEC_MAKE_RULE_LATE 15 #define EXEC_INSERT_CHECK_RULE 16 #define EXEC_DELETE_CHECK_RULE 17 /* ---------------- * Merge Join states * ---------------- */ #define EXEC_MJ_INITIALIZE 1 #define EXEC_MJ_JOINMARK 2 #define EXEC_MJ_JOINTEST 3 #define EXEC_MJ_JOINTUPLES 4 #define EXEC_MJ_NEXTOUTER 5 #define EXEC_MJ_TESTOUTER 6 #define EXEC_MJ_NEXTINNER 7 #define EXEC_MJ_SKIPINNER 8 #define EXEC_MJ_SKIPOUTER 9 @ 1.22 log @*** empty log message *** @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.21 90/03/12 16:26:06 cimarron Exp $" d339 16 @ 1.21 log @Integration Checkin @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.20 90/03/01 15:39:42 cimarron Exp $" a374 1 d376 1 d379 6 d386 1 d403 1 @ 1.20 log @general changes to add parallelism support, in-memory relations, and various code cleanups. @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.19 90/02/23 19:45:32 cimarron Exp $" d27 1 d74 19 d94 4 d99 2 d206 18 a226 1 d291 1 a291 1 CAR(CDR(CDR(CDR(CDRCDR((parse_tree_root)))))) @ 1.19 log @changed some Qd macros. @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.18 90/02/01 13:51:37 cimarron Exp Locker: cimarron $" d320 1 @ 1.18 log @added support for hooks, unique, parallel and material nodes @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.17 90/01/31 17:38:25 cimarron Exp Locker: cimarron $" d213 5 a217 2 #define QdGetCommand(queryDesc) CAR(QdGetFeature(queryDesc)) #define QdGetCount(queryDesc) CAR(CDR(QdGetFeature(queryDesc))) @ 1.17 log @added unique, material and parallel node definitions -cim @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.14 89/11/02 18:05:35 cimarron Exp $" d321 3 @ 1.16 log @removed the #include of rulemgr.h, executor/rulemgr.h and executor/rulelocks.h (these files have been removed) @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.15 90/01/30 16:47:09 jamesb Exp Locker: sp $" d30 1 d44 1 d73 2 d76 28 d263 1 d270 1 d272 1 d275 4 d280 15 a294 1 /* ---------------------------------------------------------------- d320 2 d333 1 d336 1 d345 1 a345 369 /* ---------------------------------------------------------------- * shit whose time is to die * (but we keep it around for reference purposes) * ---------------------------------------------------------------- */ #ifdef TIMETODIE #ifdef NOTYET /* ---------------- * Merge Join Macros * ---------------- */ #define MJGetOuterTuple(node) GetMJOuterTuple(get_state(node)) #define MJSetOuterTuple(node,value) setf(MJGetOuterTuple(node),value) #define MJGetTupType(node) GetMJTupType(get_state(node)) #define MJSetTupType(node,value) setf(MJGetTupType(node),value) #define MJGetTupValue(node) GetMJTupValue(get_state(node)) #define MJSetTupValue(node,value) setf(MJGetTupValue(node),value) #define MJGetBufferPage(node) GetMJBufferPage(get_state(node)) #define MJSetBufferPage(node,value) setf(MJGetBufferPage(node),value) #define MJGetOSortopI(node) GetMJOSortopI(get_state(node)) #define MJSetOSortopI(node,value) setf(MJGetOSortopI(node),value) #define MJGetISortopO(node) GetMJISortopO(get_state(node)) #define MJSetISortopO(node,value) setf(MJGetISortopO(node),value) #define MJGetMarkFlag(node) GetMJMarkFlag(get_state(node)) #define MJSetMarkFlag(node,value) setf(MJGetMarkFlag(node),value) #define MJGetFrwdMarkPos(node) GetMJFrwdMarkPos(get_state(node)) #define MJSetFrwdMarkPos(node,value) setf(MJGetFrwdMarkPos(node),value) #define MJGetBkwdMarkPos(node) GetMJBkwdMarkPos(get_state(node)) #define MJSetBkwdMarkPos(node,value) setf(MJGetBkwdMarkPos(node),value) #define MJGetMarkPos(node) \ (execDirection == EXEC_FRWD ? \ MJGetFrwdMarkPos(node) : MJGetBkwdMarkPos(node)) #define MJSetMarkPos(node,scanPos) \ (execDirection == EXEC_FRWD ? \ MJSetFrwdMarkPos(node,scanPos) : MJSetBkwdMarkPos(node,scanPos)) #endif NOTYET #ifdef NOTYET /* ---------------- * sort node defines * ---------------- */ #define SortGetSortedFlag(node) GetSortFlag(get_state(node)) #define SortSetSortedFlag(node,value) setf(SortGetSortedFlag (node),value) #define SortGetSortKeys(node) GetSortKeys(get_state(node)) #define SortSetSortKeys(node,value) setf(SortGetSortKeys(node),value) #endif NOTYET #ifdef NOTYET /* * index scan constants * * Offset definitions to access fields in 'states' of index nodes. */ #define EXEC_INDEXSCAN_IndexPtr 0 #define EXEC_INDEXSCAN_RuleFlag 1 #define EXEC_INDEXSCAN_RuleDesc 2 /* * seqscan constants * * The folowing offsets are used to access state information from the * 'states' field of the seqscan nodes */ #define EXEC_SEQSCAN_RuleFlag 0 #define EXEC_SEQSCAN_RuleDesc 1 /* * rule lock constants */ #define EXEC_EARLY 0 #define EXEC_LATE 1 #define EXEC_REFUSE 2 #define EXEC_ALWAYS 3 #endif NOTYET /* ---------------- * index scan accessor macros * * IGetRelID(node) get the id of the relation to be scanned * IGetRelDesc(node) get the relation descriptor from relation id * IGetScanDesc(node) get the scan descriptor from relation id * IGetQual(node) get the qualification clause * IGetTarget(node) get the target list * IGetRuleFlag(node) get the flag indicating rule activation * ISetRuleFlag(node, value) set the flag indicating rule activation * IGetRuleDesc(node) get rule descriptor * ISetRuleDesc(node, value) set rule descriptor * IGetIndices(node) get indices * IGetIndexPtr(node) get index pointer * ISetIndexPtr(node, value) set index pointer * IGetIndexQual(node) get index qualifications * ---------------- */ #define IGetRelID(node) get_scanrelid(node) #define IGetRelDesc(node) ExecGetRelDesc(IGetRelID(node)) #define IGetScanDesc(node) ExecGetScanDesc(IGetRelID(node)) #define IGetQual(node) get_qpqual(node) #define IGetTarget(node) get_qptargetlist(node) #define IGetRuleFlag(node) \ ExecGetStates(EXEC_INDEXSCAN_RuleFlag, get_states(node)) #define ISetRuleFlag(node, value) \ ExecSetStates(EXEC_INDEXSCAN_RuleFlag, get_states(node)), value) #define IGetRuleDesc(node) \ ExecGetStates(EXEC_INDEXSCAN_RuleDesc, get_states(node)) #define ISetRuleDesc(node, value) \ ExecSetStates(EXEC_INDEXSCAN_RuleDesc, get_states(node), value) #define IGetIndices(node) get_indxid(node) #define IGetIndexPtr(node) \ ExecGetStates(EXEC_INDEXSCAN_IndexPtr, get_states(node)) #define ISetIndexPtr(node, value) \ ExecSetStates(EXEC_INDEXSCAN_IndexPtr, get_states(node), value) #define IGetIndexQual(node) \ getindxqual(node) /* * XXX automatic conversion failed on this one but we might not need it * -cim 8/4/89 * * get the scan descriptor from index id = (relDesc, scanDesc) * * #define IGetIScanDesc,indexID (),ExecGetScanDesc (indexID) */ /* ---------------- * append node macros * ---------------- */ #define append_nplans_is_valid(nplans) \ (nplans > 0) #define append_whichplan_is_valid(whichplan, nplans) \ (whichplan >= 0 && whichplan < nplans) #define append_initialized_is_valid(initialized) \ (lispVectorp(initialized)) #define append_plans_is_valid(plans) \ (lispAtomp(plans)) #define append_rtentries_is_valid(rtentries) \ (lispAtomp(rtentries)) /* ---------------- * nest loop macros * ---------------- */ #define NLGetOuterTuple(node) GetNLOuterTuple(get_state(node)) #define NLSetOuterTuple(node,value) \ setf(NLGetOuterTuple(node), ppreserve (value)) #define NLGetPortalFlag(node) GetNLPortalFlag(get_state(node)) #define NLSetPortalFlag(node,value) setf(NLGetPortalFlag(node), value) #define NLGetTupType(node) GetNLTupType(get_state(node)) #define NLSetTupType(node,value) setf(NLGetTupType(node), value) #define NLGetTupValue(node) GetNLTupValue(get_state(node)) #define NLSetTupValue(node,value) setf(NLGetTupValue(node), value) /* ---------------- * scan/relation descriptor accessors * ---------------- */ #define SGetScanDesc(node) \ ExecGetScanDesc(get_scanrelid(node)) #define SSetScanDesc(node, scanDesc) \ ExecSetScanDesc(get_scanrelid(node), scanDesc) #define SGetRelDesc(node) \ ExecGetRelDesc(get_scanrelid(node)) #define SSetRelDesc(node,relDesc) \ ExecSetRelDesc(get_scanrelid(node), relDesc) /* ---------------- * Get/Set scan/relation descriptor from index id * ---------------- */ #define SGetIScanDesc(indexID) ExecGetScanDesc(indexID) #define SSetIScanDesc(indexID,indexDesc) ExecSetScanDesc(indexID, indexDesc) #define SGetIRelDesc(indexID) ExecGetRelDesc(indexID) #define SSetIRelDesc(indexID) ExecSetRelDesc(indexID) /* ---------------- * access state information of SCAN nodes * ---------------- */ #define SGetBufferPage(node) GetScanBufferPage(get_state(node)) #define SSetBufferPage(node,value) setf(SGetBufferPage(node),value) #define SGetTupType(node) GetScanTupType(get_state(node)) #define SSetTupType(node,value) setf(SGetTupType(node),value) #define SGetTupValue(node) GetScanTupValue(get_state(node)) #define SSetTupValue(node,value) setf(SGetTupValue(node),value) #define SGetOldRelId(node) GetScanOldRelId(get_state(node)) #define SSetOldRelId(node,value) setf(SGetOldRelId(node),value) /* * this is the attr types for tuples being scanned, not those returned * according to the target list */ #define SGetScanType(node) \ ExecGetTypeInfo(ExecGetRelDesc(get_scanrelid(node))) #define SGetRuleFlag(node) GetScanRuleFlag(get_state(node)) #define SSetRuleFlag(node,value) setf(SGetRuleFlag(node),value) #define SGetRuleDesc(node) GetScanRuleDesc(get_state (node)) #define SSetRuleDesc(node,value) setf(SGetRuleDesc(node),value) #define SGetProcLeftFlag(node) GetScanProcLeftFlag(get_state (node)) #define SSetProcLeftFlag(node,value) setf(SGetProcLeftFlag(node),value) #define SGetIndexPtr(node) GetScanIndexPtr(get_state (node)) #define SSetIndexPtr(node,value) setf(SGetIndexPtr(node),value) #define SGetSkeys(node) GetScanSkeys(get_state (node)) #define SSetSkeys(node,value) setf(SGetSkeys(node),value) #define SGetSkeysCount(node) GetScanSkeysCount(get_state (node)) #define SSetSkeysCount(node,value) setf(SGetSkeysCount(node),value) /* ---------------- * get/set index id pointed by the index ptr * ---------------- */ #define SGetIndexID(indexPtr,node) \ nth(indexPtr, get_indxid(node)) #define SSetIndexID(indexPtr,node,value) \ setf(SGetIndexPtr(indexPtr, get_indxid(node)), value) /* ---------------- * sequential scan node accessors * ---------------- */ #define SGetRelID(node) get_scanrelid(node) #define SGetQual(node) get_qpqual(node) #define SGetTarget(node) get_qptargetlist(node) /* ---------------- * result node accessors * ---------------- */ #define ResGetLoop(node) get_Loop(get_resstate(node)) #define ResSetLoop(node,value) set_Loop(get_resstate(node), value) #define ResGetLeftTuple(node) get_LeftTuple(get_resstate(node)) #define ResSetLeftTuple(node,value) set_LeftTuple(get_resstate(node), value) #define ResGetTupType(node) get_TupType(get_resstate(node)) #define ResSetTupType(node,value) set_TupType(get_resstate(node), value) #define ResGetTupValue(node) get_TupValue(get_resstate(node)) #define ResSetTupValue(node,value) set_TupValue(get_resstate(node), value) #define ResGetLevel(node) get_Level(get_resstate(node)) #define ResSetLevel(node,value) set_Level(get_resstate(node), value) /* ---------------- * Retrieve/Construct the components in relation ID. * Relation ID which is the relation name * is changed into (RelDesc ScanDesc) * after initialization. * ---------------- */ #define ExecMakeRelID(relDesc,scanDesc) \ lispList(relDesc,scanDesc) #define ExecGetRelDesc(relID) \ (CAR(relID)) #define ExecSetRelDesc(relID,relDesc) \ (ExecGetRelDesc(relID) = (relDesc))) #define ExecGetScanDesc(relID) \ (CAR(CDR(relID))) #define ExecSetScanDesc(relID,relDesc) \ (ExecGetScanDesc(relID) = (relDesc)) /* ---------------- * Things for tuple tid. * * (initializtion is in in executor.c as follows) * extern List _qual_tuple_tid_ = 0; * extern List _qual_tuple_ = LispNil; * extern List _result_relation_ = LispNil; * extern List _resdesc_ = LispNil; * ---------------- */ extern int _qual_tuple_tid_; extern List _qual_tuple_; extern Relation _result_relation_; extern List _resdesc_; /* ---------------- * Global variables * * TODO * Put into root node to allow concurrent executors * * initializtion is in in executor.c as follows: * * extern List execDirection = EXEC_FRWD; * extern List execTime = 0; * extern List execOwner = 0; * extern List execSPlanInfo = LispNil; * extern List execErrorMssg = LispNil; * extern List execRangeTbl = LispNil; * extern List _relation_relation_ = LispNil; * ---------------- */ extern int execDirection; extern int execTime; extern int execOwner; extern char *execErrorMssg; extern List execSPlanInfo; extern List execRangeTbl; extern Relation _relation_relation_; /* ---------------- * Variables global to all concurrent executors * ---------------- * * Queue of rule plans that want to be run as a Now time qual transacation * (initializtion is in in executor.c as follows) * * extern List _rule_now_plans_queue_ = LispNil; * * Queue of rule plans that want to be run as a Self Time qual transaction * * extern List _rule_self_plans_queue_ = LispNil; */ #endif TIMETODIE @ 1.15 log @provided for Recursive node @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.14 89/11/02 18:05:35 cimarron Exp Locker: jamesb $" a42 1 #include "rulemgr.h" a283 2 #include "executor/rulelocks.h" #include "executor/rulemgr.h" @ 1.14 log @added support for Merge Joins in the executor @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.12 89/10/20 19:52:15 cimarron Exp $" d39 2 d232 1 d283 1 @ 1.13 log @#undef TUPLECOUNT -- causes bad pointer accesses on decstations. @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.12 89/10/20 19:52:15 cimarron Exp Locker: mao $" d25 1 d30 1 d33 1 d36 1 d53 10 a62 1 /* d64 1 d76 1 a76 5 * TUPLECOUNT is a #define which, if set, will have the * executor keep track of tuple counts. This might be * causing some problems with the decstation stuff so * you might want to undefine this if you are doing work * on the decs - cim 10/20/89 a79 7 /* #define TUPLECOUNT 1 */ #undef TUPLECOUNT /* * memory management defines */ d83 4 d90 4 d97 1 a97 1 /* d99 1 a100 1 d104 1 a104 16 /* * attribute constants and definitions */ #ifdef vax #define EXEC_MAXATTR 1584 #endif #ifndef vax #define EXEC_MAXATTR 1600 /* Max # attributes */ #endif #define EXEC_T_CTID -1 #define EXEC_I_TID -3 #define EXEC_T_LOCK -2 /* d106 1 a107 1 d127 3 a129 3 /* ---------------------------------------------------------------- * #defines * ---------------------------------------------------------------- d131 9 d141 6 a146 1 /* ---------------- a236 1 @ 1.12 log @Added a #define TUPLECOUNT to control the inclusion of the tuple counting stuff. -cim @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.11 89/10/17 13:44:50 cimarron Exp $" d70 2 a71 1 #define TUPLECOUNT 1 @ 1.11 log @changes to support MergeJoins in the executor. @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.10 89/10/12 16:44:21 cimarron Exp $" d60 11 @ 1.10 log @pre-sort checkin for spyros. Sorts still don't work but functionality is almost there.. @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.9 89/10/05 16:59:15 cimarron Exp $" d110 1 a118 32 #ifdef NOTYET /* * index scan constants * * Offset definitions to access fields in 'states' of index nodes. */ #define EXEC_INDEXSCAN_IndexPtr 0 #define EXEC_INDEXSCAN_RuleFlag 1 #define EXEC_INDEXSCAN_RuleDesc 2 /* * seqscan constants * * The folowing offsets are used to access state information from the * 'states' field of the seqscan nodes */ #define EXEC_SEQSCAN_RuleFlag 0 #define EXEC_SEQSCAN_RuleDesc 1 /* * rule lock constants */ #define EXEC_EARLY 0 #define EXEC_LATE 1 #define EXEC_REFUSE 2 #define EXEC_ALWAYS 3 #endif NOTYET d209 1 a209 1 #define ExecIsMergeJoin(node) IsA(node,MergeSort) d218 57 d333 6 d340 3 d344 5 a348 3 /* ---------------------------------------------------------------- * externs * ---------------------------------------------------------------- d351 2 a352 17 /* * miscellany */ extern Relation amopen(); extern Relation AMopen(); extern Relation amopenr(); extern HeapScanDesc ambeginscan(); extern HeapTuple amgetnext(); extern char * amgetattr(); extern RuleLock aminsert(); extern RuleLock amdelete(); extern RuleLock amreplace(); extern GeneralInsertIndexResult AMinsert(); extern GeneralRetrieveIndexResult AMgettuple(); extern HeapTuple RelationGetHeapTupleByItemPointer(); d354 2 a355 5 extern Const ConstTrue; extern Const ConstFalse; /* * public executor functions d358 4 a361 18 #include "executor/append.h" #include "executor/endnode.h" #include "executor/eutils.h" #include "executor/exist.h" #include "executor/indexscan.h" #include "executor/initnode.h" #include "executor/main.h" #include "executor/mergejoin.h" #include "executor/nestloop.h" #include "executor/procnode.h" #include "executor/qual.h" #include "executor/result.h" #include "executor/rulelocks.h" #include "executor/rulemgr.h" #include "executor/scan.h" #include "executor/seqscan.h" #include "executor/sort.h" #include "executor/tuples.h" d363 1 a363 5 /* ---------------------------------------------------------------- * shit whose time is to die * (but we keep it around for reference purposes) * ---------------------------------------------------------------- */ a364 1 #ifdef TIMETODIE @ 1.9 log @added code to support mirroring of heap updates to index relations @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.8 89/09/18 20:25:22 cimarron Exp $" d37 1 @ 1.8 log @added dummy interfaces for parallel optimiser and made some misc changes.. @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.7 89/09/18 08:19:48 cimarron Exp $" d29 1 d36 1 a146 22 /* * Constants taken from RuleLock.h */ #define RuleLockTypeWrite 0 /* Rule lock Write 0 */ #define RuleLockTypeRead1 1 /* Rule lock Write 1 */ #define RuleLockTypeRead2 2 /* Rule Lock Read 2 */ #define RuleLockTypeRead3 3 /* Rule Lock Read 3 */ /* * RuleLockIntermediate.ruletype is one of the following */ #define RuleTypeRetrieve 0 /* Retrieve rule */ #define RuleTypeReplace 1 /* Replace rule */ #define RuleTypeAppend 2 /* Append rule */ #define RuleTypeDelete 3 /* Delete rule */ #define RuleTypeRefuseRetrieve 4 /* Refuse retrieve rule */ #define RuleTypeRefuseReplace 5 /* Refuse replace rule */ #define RuleTypeRefuseAppend 6 /* Refuse append rule */ #define RuleTypeRefuseDelete 7 /* Refuse delete rule */ a246 19 #ifdef NOTYET /* ---------------- * index scan accessor macros * * IGetRelID(node) get the id of the relation to be scanned * IGetRelDesc(node) get the relation descriptor from relation id * IGetScanDesc(node) get the scan descriptor from relation id * IGetQual(node) get the qualification clause * IGetTarget(node) get the target list * IGetRuleFlag(node) get the flag indicating rule activation * ISetRuleFlag(node, value) set the flag indicating rule activation * IGetRuleDesc(node) get rule descriptor * ISetRuleDesc(node, value) set rule descriptor * IGetIndices(node) get indices * IGetIndexPtr(node) get index pointer * ISetIndexPtr(node, value) set index pointer * IGetIndexQual(node) get index qualifications * ---------------- */ a247 40 #define IGetRelID(node) get_scanrelid(node) #define IGetRelDesc(node) ExecGetRelDesc(IGetRelID(node)) #define IGetScanDesc(node) ExecGetScanDesc(IGetRelID(node)) #define IGetQual(node) get_qpqual(node) #define IGetTarget(node) get_qptargetlist(node) #define IGetRuleFlag(node) \ ExecGetStates(EXEC_INDEXSCAN_RuleFlag, get_states(node)) #define ISetRuleFlag(node, value) \ ExecSetStates(EXEC_INDEXSCAN_RuleFlag, get_states(node)), value) #define IGetRuleDesc(node) \ ExecGetStates(EXEC_INDEXSCAN_RuleDesc, get_states(node)) #define ISetRuleDesc(node, value) \ ExecSetStates(EXEC_INDEXSCAN_RuleDesc, get_states(node), value) #define IGetIndices(node) get_indxid(node) #define IGetIndexPtr(node) \ ExecGetStates(EXEC_INDEXSCAN_IndexPtr, get_states(node)) #define ISetIndexPtr(node, value) \ ExecSetStates(EXEC_INDEXSCAN_IndexPtr, get_states(node), value) #define IGetIndexQual(node) \ getindxqual(node) /* * XXX automatic conversion failed on this one but we might not need it * -cim 8/4/89 * * get the scan descriptor from index id = (relDesc, scanDesc) * * #define IGetIScanDesc,indexID (),ExecGetScanDesc (indexID) */ #endif NOTYET d327 1 d364 57 @ 1.7 log @added index scan support. @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.5 89/08/31 14:09:52 cimarron Exp $" d29 1 d198 6 a205 13 * * BEWARE: the query "feature" can contain different sorts * of things depending on the operation. In particular, * in the case of "retrieve into", it is a list * * ('result intoRelationDesc) * * where 'result == lispInteger(EXEC_RESULT) and * intoRelationDesc == lispInteger(relation descriptor) * * It can also contain other stuff.. * * this is a real crappy interface.. we should fix it soon -cim 8/29/89 a209 3 #define QdGetIntoRelation(queryDesc) \ ((Relation) CInteger(CAR(CDR(QdGetFeature(queryDesc))))) @ 1.6 log @Working version of C-only demo @ text @d25 1 a25 1 #include "parse.h" d27 1 a27 2 #include "rel.h" #include "anum.h" d29 1 a29 1 #include "catalog.h" d31 3 d36 1 a37 2 #include "tqual.h" #include "pmod.h" d64 2 a65 2 #define EXEC_FRWD 0 /* Scan forward */ #define EXEC_BKWD 1 /* Scan backward */ d406 1 d411 3 d415 3 a426 1 #include "executor/error.h" @ 1.5 log @added a #include "tuples.h" needed by qual.c @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.4 89/08/30 12:59:48 cimarron Exp $" @ 1.4 log @append nodes now work, provided plans are correct @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.3 89/08/29 22:38:03 cimarron Exp $" d34 1 a276 87 * sequential scan node accessors * ---------------- */ #define SGetRelID(node) get_scanrelid(node) #define SGetQual(node) get_qpqual(node) #define SGetTarget(node) get_qptargetlist(node) #endif NOTYET #ifdef NOTYET /* ---------------- * scan/relation descriptor accessors * ---------------- */ #define SGetScanDesc(node) \ ExecGetScanDesc(get_scanrelid(node)) #define SSetScanDesc(node, scanDesc) \ ExecSetScanDesc(get_scanrelid(node), scanDesc) #define SGetRelDesc(node) \ ExecGetRelDesc(get_scanrelid(node)) #define SSetRelDesc(node,relDesc) \ ExecSetRelDesc(get_scanrelid(node), relDesc) /* ---------------- * Get/Set scan/relation descriptor from index id * ---------------- */ #define SGetIScanDesc(indexID) ExecGetScanDesc(indexID) #define SSetIScanDesc(indexID,indexDesc) ExecSetScanDesc(indexID, indexDesc) #define SGetIRelDesc(indexID) ExecGetRelDesc(indexID) #define SSetIRelDesc(indexID) ExecSetRelDesc(indexID) /* ---------------- * access state information of SCAN nodes * ---------------- */ #define SGetBufferPage(node) GetScanBufferPage(get_state(node)) #define SSetBufferPage(node,value) setf(SGetBufferPage(node),value) #define SGetTupType(node) GetScanTupType(get_state(node)) #define SSetTupType(node,value) setf(SGetTupType(node),value) #define SGetTupValue(node) GetScanTupValue(get_state(node)) #define SSetTupValue(node,value) setf(SGetTupValue(node),value) #define SGetOldRelId(node) GetScanOldRelId(get_state(node)) #define SSetOldRelId(node,value) setf(SGetOldRelId(node),value) /* * this is the attr types for tuples being scanned, not those returned * according to the target list */ #define SGetScanType(node) \ ExecGetTypeInfo(ExecGetRelDesc(get_scanrelid(node))) #define SGetRuleFlag(node) GetScanRuleFlag(get_state(node)) #define SSetRuleFlag(node,value) setf(SGetRuleFlag(node),value) #define SGetRuleDesc(node) GetScanRuleDesc(get_state (node)) #define SSetRuleDesc(node,value) setf(SGetRuleDesc(node),value) #define SGetProcLeftFlag(node) GetScanProcLeftFlag(get_state (node)) #define SSetProcLeftFlag(node,value) setf(SGetProcLeftFlag(node),value) #define SGetIndexPtr(node) GetScanIndexPtr(get_state (node)) #define SSetIndexPtr(node,value) setf(SGetIndexPtr(node),value) #define SGetSkeys(node) GetScanSkeys(get_state (node)) #define SSetSkeys(node,value) setf(SGetSkeys(node),value) #define SGetSkeysCount(node) GetScanSkeysCount(get_state (node)) #define SSetSkeysCount(node,value) setf(SGetSkeysCount(node),value) /* ---------------- * get/set index id pointed by the index ptr * ---------------- */ #define SGetIndexID(indexPtr,node) \ nth(indexPtr, get_indxid(node)) #define SSetIndexID(indexPtr,node,value) \ setf(SGetIndexPtr(indexPtr, get_indxid(node)), value) #endif NOTYET #ifdef NOTYET /* ---------------- a334 2 a336 23 * nest loop macros * ---------------- */ #define NLGetOuterTuple(node) GetNLOuterTuple(get_state(node)) #define NLSetOuterTuple(node,value) \ setf(NLGetOuterTuple(node), ppreserve (value)) #define NLGetPortalFlag(node) GetNLPortalFlag(get_state(node)) #define NLSetPortalFlag(node,value) setf(NLGetPortalFlag(node), value) #define NLGetTupType(node) GetNLTupType(get_state(node)) #define NLSetTupType(node,value) setf(NLGetTupType(node), value) #define NLGetTupValue(node) GetNLTupValue(get_state(node)) #define NLSetTupValue(node,value) setf(NLGetTupValue(node), value) #endif NOTYET #ifdef NOTYET /* ---------------- d395 1 a395 24 #ifdef NOTYET /* ---------------- * append node macros * ---------------- */ #define append_nplans_is_valid(nplans) \ (nplans > 0) #define append_whichplan_is_valid(whichplan, nplans) \ (whichplan >= 0 && whichplan < nplans) #define append_initialized_is_valid(initialized) \ (lispVectorp(initialized)) #define append_plans_is_valid(plans) \ (lispAtomp(plans)) #define append_rtentries_is_valid(rtentries) \ (lispAtomp(rtentries)) #endif NOTYET /* ---------------------------------------------------------------- d439 1 d444 117 @ 1.3 log @update queries checkin.. @ text @d8 1 a8 1 * $Header: RCS/executor.h,v 1.2 89/08/24 17:04:21 cimarron Exp $" d35 1 @ 1.2 log @seqscans with quals checkin @ text @d8 1 a8 1 * $Header$" d196 13 d211 5 a215 2 #define QdGetCommand(queryDesc) CAR(QdGetFeature(queryDesc)) #define QdGetCount(queryDesc) CAR(CDR(QdGetFeature(queryDesc))) @ 1.1 log @Initial revision @ text @d7 2 a10 1 static char *RCS_ID = "$Header$"; d22 1 d24 1 d28 1 d30 1 d33 2 d208 15 d226 7 d237 1 a237 1 CAR(CDR(CDR(CAR(CDR(parse_tree))))) a239 22 * Retrieve/Construct the components in relation ID. * Relation ID which is the relation name * is changed into (RelDesc ScanDesc) * after initialization. * ---------------- */ #define ExecMakeRelID(relDesc,scanDesc) \ lispList(relDesc,scanDesc) #define ExecGetRelDesc(relID) \ (CAR(relID)) #define ExecSetRelDesc(relID,relDesc) \ (ExecGetRelDesc(relID) = (relDesc))) #define ExecGetScanDesc(relID) \ (CAR(CDR(relID))) #define ExecSetScanDesc(relID,relDesc) \ (ExecGetScanDesc(relID) = (relDesc)) /* ---------------- a255 5 #ifdef TIMETODIE /* ---------------- * result node accessors * ---------------- */ a256 14 #define ResGetLoop(node) get_Loop(get_resstate(node)) #define ResSetLoop(node,value) set_Loop(get_resstate(node), value) #define ResGetLeftTuple(node) get_LeftTuple(get_resstate(node)) #define ResSetLeftTuple(node,value) set_LeftTuple(get_resstate(node), value) #define ResGetTupType(node) get_TupType(get_resstate(node)) #define ResSetTupType(node,value) set_TupType(get_resstate(node), value) #define ResGetTupValue(node) get_TupValue(get_resstate(node)) #define ResSetTupValue(node,value) set_TupValue(get_resstate(node), value) #define ResGetLevel(node) get_Level(get_resstate(node)) #define ResSetLevel(node,value) set_Level(get_resstate(node), value) #endif TIMETODIE a269 1 a511 2 d521 5 a525 3 extern Relation amopenr(); extern Bool ExprTrue; extern Bool ExprFalse; d527 3 a532 1 extern List ExecMain(); /* main */ d534 19 a552 5 extern List ExecGetSPlanTuple(); /* einternal */ extern void ExecSetSPlanTuple(); /* einternal */ extern List ExecGetSPlanType(); /* einternal */ extern void ExecSetSPlanType(); /* einternal */ extern List ExecInitSPlanInfo(); /* einternal */ d554 4 a557 9 extern List make_const(); /* einternal */ extern Expr ExecEvalVar(); /* einternal */ extern Expr ExecEvalOper(); /* einternal */ extern Expr ExecEvalFunc(); /* einternal */ extern Expr ExecEvalNot(); /* einternal */ extern Expr ExecEvalParam(); /* einternal */ extern Expr ExecEvalOr(); /* einternal */ extern List ExecQual(); /* einternal */ extern Expr ExecEvalExpr(); /* einternal */ d559 1 a559 2 extern List LispOr(); /* einternal */ extern Expr ExecMakeVarConst(); /* einternal */ d561 4 a564 3 extern List ExecOpenR(); /* eutils */ extern List ExecBeginScan(); /* eutils */ extern List GetIDFromRangeTbl(); /* eutils */ d566 10 a575 5 extern List ExecIndexScan(); /* indexscan */ extern List IndexNext(); /* indexscan */ extern List UseNextIndex(); /* indexscan */ extern List OpenScanIndices(); /* indexscan */ extern List MakeSkeys(); /* indexscan */ d577 9 a585 7 extern List InitPlan(); /* main */ extern List EndPlan(); /* main */ extern List ExecutePlan(); /* main */ extern List ExecAppend(); /* main */ extern List ExecRetrieve(); /* main */ extern List ExecDel(); /* main */ extern List ExecReplace(); /* main */ d587 2 a588 9 extern List GetMJOuterTuple(); /* mergejoin */ extern List GetMJTupType(); /* mergejoin */ extern List GetMJTupValue(); /* mergejoin */ extern List GetMJBufferPage(); /* mergejoin */ extern List GetMJOSortopI(); /* mergejoin */ extern List GetMJISortopO(); /* mergejoin */ extern List GetMJMarkFlag(); /* mergejoin */ extern List GetMJFrwdMarkPos(); /* mergejoin */ extern List GetMJBkwdarkPos(); /* mergejoin */ d590 2 a591 13 extern List ExecMergeJoin(); /* mergejoin */ extern List ExecInitMergeJoin(); /* mergejoin */ extern List ExecEndMergeJoin(); /* mergejoin */ extern List MergeSync(); /* mergejoin */ extern List RevScan(); /* mergejoin */ extern List DirScan(); /* mergejoin */ extern List SkipInner(); /* mergejoin */ extern List SkipOuter(); /* mergejoin */ extern List InnerSkipQual(); /* mergejoin */ extern List OuterSkipQual(); /* mergejoin */ extern List MJFormOSortopI(); /* mergejoin */ extern List MJFormISortopO(); /* mergejoin */ extern List Compare(); /* mergejoin */ d593 2 a594 4 extern List GetNLOuterTuple(); /* nestloop */ extern List GetNLTupType(); /* nestloop */ extern List GetNLTupValue(); /* nestloop */ extern List GetNLPortalFlag(); /* nestloop */ d596 2 a597 39 extern List ExecProcNode(); /* procnode */ extern List ExecRuleLocks (); /* rulelocks */ extern List exec_make_intermediate_locks (); /* rulelocks */ extern List exec_set_lock(); /* rulelocks */ extern List exec_run_plan(); /* rulelocks */ extern List exec_set_rule_default(); /* rulelocks */ extern List exec_determine_always(); /* rulelocks */ extern List GetRes(); /* result */ extern List ExecResult(); /* result */ extern List ExecInitResult(); /* result */ extern List ExecEndResult(); /* result */ extern List GetScanTupType(); /* scan */ extern List GetScanTupValue(); /* scan */ extern List GetScanRuleFlag(); /* scan */ extern List GetScanRuleDesc(); /* scan */ extern List GetScanProcLeftFlag(); /* scan */ extern List GetScanOldRelId(); /* scan */ extern List GetScanLispIndexPtr(); /* scan */ extern List GetScanSkeys(); /* scan */ extern List GetScanSkeysCount(); /* scan */ extern List GetSortFlag(); /* sort */ extern List GetSortKeys(); /* sort */ extern AttributePtr ExecGetTupType(); /* tuples */ extern AttributePtr ExecTypeFromTL(); /* tuples */ extern List ExecTargetList(); /* qual */ /* ---------------------------------------------------------------- * shit whose time is to die * ---------------------------------------------------------------- */ #ifdef TIMETODIE @