4.3BSD - /usr/ingres/source/h/tree.h

   1: /*
   2: **  TREE.H -- defines the structure of a querytree
   3: **
   4: **	Version:
   5: **		@(#)tree.h	8.2	4/13/85
   6: */
   7: 
   8: 
   9: # ifndef QT_HDR_SIZ
  10: 
  11: # include   <ingres.h>
  12: 
  13: 
  14: /*
  15: **	Structures Used In The Value Fields of Querytree nodes
  16: */
  17: 
  18: /*
  19: **  STRKEEPER
  20: **
  21: **	This stores interval information for a char attribute
  22: **	type -- OPEN vs. CLOSED intervals
  23: **	strings -- the two delimiters
  24: **	flag -- 1st bit set if it is a special character
  25: **		2nd bit set if backwards searching indicated
  26: **      number -- which occurance of strings to grab
  27: **
  28: */
  29: 
  30: typedef struct strkeeper
  31: {
  32:     char    type[2];
  33:     char    *string[2];
  34:     char    flag[2];
  35:     char    number[2];
  36: } STRKEEPER;
  37: 
  38: /*
  39: **  VAR node
  40: **
  41: **	This node type contains info for a tuple variable.
  42: **	varno -- index into range table
  43: **	attno -- attribute number in this relation
  44: **	varfrmt -- type of this domain
  45: **	varfrml -- length of this domain
  46: **	valptr -- pointer to value when bound.
  47: **
  48: **	If varno == -1, then this variable has been substituted; to
  49: **	get the actual VAR node, follow the chain of valptr's.
  50: */
  51: 
  52: struct varnode
  53: {
  54:     char    varno;          /* variable number */
  55:     char    attno;          /* attribute number */
  56:     char    varfrmt;        /* type */
  57:     char    varfrml;        /* length */
  58:     STRKEEPER *varstr;      /* pointer to delimiter */
  59:     ANYTYPE *valptr;        /* pointer to value */
  60: };
  61: 
  62: 
  63: /*
  64: **	STRUCTURE FOR AND, AGHEAD, AND ROOT NODES
  65: **
  66: **		In the parser and qrymod none of these fields are used.
  67: **		Decomp maintains information about the variables
  68: **		in the left and right descendents of the nodes.
  69: **		The "rootuser" flag is present only in the ROOT and AGHEAD
  70: **		nodes.  It is TRUE only in the original ROOT node of the query.
  71: */
  72: 
  73: struct rootnode         /* AND, AGHEAD, ROOT nodes */
  74: {
  75:     char    tvarc;          /* total of var's in sub-tree */
  76:     char    lvarc;          /* # of variables in left branch */
  77:     short   lvarm;          /* bit map of var's in left branch */
  78:     short   rvarm;          /* bit map of var's in right branch*/
  79:     short   rootuser;       /* flag: TRUE if root of user generated query */
  80: };
  81: 
  82: struct opnode           /* AOP, BOP, UOP nodes */
  83: {
  84:     short   opno;           /* operator number */
  85:     char    opfrmt;         /* format of function */
  86:     char    opfrml;         /* length of function */
  87:     char    agfrmt;         /* in AOP, format of result */
  88:     char    agfrml;         /* in AOP, length of result */
  89: };
  90: 
  91: struct resdomnode       /* RESDOM node */
  92: {
  93:     short   resno;          /* result domain number */
  94:     char    resfrmt;        /* result format */
  95:     char    resfrml;        /* result length */
  96: };
  97: 
  98: 
  99: struct srcid            /* SOURCEID node */
 100: {
 101:     short   srcvar;         /* variable number */
 102:     DESC    srcdesc;        /* descriptor for this var */
 103: };
 104: 
 105: 
 106: /*
 107: **	SYMVALUE UNION
 108: **
 109: **		This union contains all of the types available
 110: **		in the value field of a querytree node.
 111: */
 112: 
 113: union symvalue
 114: {
 115:     union anytype       sym_data;
 116:     struct varnode      sym_var;
 117:     struct rootnode     sym_root;
 118:     struct opnode       sym_op;
 119:     struct resdomnode   sym_resdom;
 120:     struct srcid        sym_srcid;
 121: };
 122: 
 123: 
 124: /*
 125: **	SYMBOL DEFINITION
 126: **
 127: **		Basic symbol structure. "Type" is one of the symbols
 128: **		in "symbol.h", "len" is the length of the "value"
 129: **		field (0 to 255 bytes), "value" is variable length and
 130: **		holds the actual value (if len != 0) of the node.
 131: **		The "value" is one of the types contained in "union symvalue".
 132: **
 133: **		On a thirty-two bit machine, there are two bytes of padding
 134: **		after type and length.  These two bytes are discarded
 135: **		when a symbol is written to a pipe.
 136: **
 137: **		SYMOFF should be set to the number of bytes between
 138: **		the start to this structure and where the value field starts
 139: */
 140: 
 141: #define SYMOFF  4
 142: 
 143: struct symbol
 144: {
 145:     char        type;           /* type codes in symbol.h */
 146:     char        len;            /* length in bytes of value field */
 147:     union symvalue  value;
 148:     int     start;      /* start of string if char */
 149: };
 150: 
 151: typedef struct symbol   SYMBOL;
 152: 
 153: 
 154: /*
 155: **	QUERYTREE NODE
 156: **
 157: **		Basic node in the querytree. Each node has a left and
 158: **		right descendent. If the node is a leaf node then the
 159: **		left and right pointers will be NULL. Depending on the
 160: **		"type" field of the symbol structure, there may be additional
 161: **		information.
 162: */
 163: 
 164: struct querytree
 165: {
 166:     struct querytree    *left;
 167:     struct querytree    *right;
 168:     struct symbol       sym;
 169: };
 170: 
 171: typedef struct querytree    QTREE;
 172: 
 173: 
 174: /*
 175: **	SUNDRY CONSTANTS
 176: **
 177: **		There are several differences in the handling of data
 178: **		structures on 16 and 32 bit machines:
 179: **			1).  A pointer to  memory is either 2 or 4 bytes.
 180: **			2).  Padding is inserted in structures to insure
 181: **				alignment of 16 and 32 bit numbers.
 182: **
 183: **		For these reasons the following constant definitions
 184: **		are useful for machine independent allocation.
 185: **
 186: **		These are based on the PDP11 compile flag.
 187: **
 188: **		QT_HDR_SIZ -- size of left and right pointers, typ,
 189: **			len and padding
 190: **		SYM_HDR_SIZ -- size of type and len in symbol
 191: **			structure -- includes any padding before
 192: **			the value field
 193: **		TYP_LEN_SIZ -- size of type and len in symbol
 194: **			structure -- without padding
 195: **
 196: **		INGRES FOLKS: don't change these back to sizeof's!!!
 197: **			      The PDP-11 compiler doesn't understand!
 198: */
 199: 
 200: # ifdef PDP11
 201: # define    QT_HDR_SIZ  6
 202: # define    SYM_HDR_SIZ 2
 203: # define    TYP_LEN_SIZ 2
 204: # else
 205: # define    QT_HDR_SIZ  12
 206: # define    SYM_HDR_SIZ 4
 207: # define    TYP_LEN_SIZ 2
 208: 
 209: 
 210: 
 211: 
 212: # endif PDP11
 213: 
 214: 
 215: 
 216: 
 217: 
 218: /*
 219: **  Query Tree Header.
 220: **
 221: **	Qt_ctx should be of type 'ctx_t *', but it is 'char *'
 222: **		to insure that we don't need ctlmod.h.
 223: */
 224: 
 225: struct qthdr
 226: {
 227:     char    qt_active;      /* if set, Qt area is in use */
 228:     char    *qt_ctx;        /* pointer to context */
 229:     short   qt_qmode;       /* query mode */
 230:     short   qt_resvar;      /* result variable number */
 231:     RANGEV  qt_rangev[MAXRANGE];    /* the range table */
 232:     short   qt_remap[MAXRANGE]; /* variable remapping (for QM) */
 233: }  Qt;
 234: 
 235: 
 236: # endif QT_HDR_SIZ

Defined variables

Defined struct's

Defined union's

Defined typedef's

Defined macros